diff --git a/docs/markdown/business-case-tractatus-framework.md b/docs/markdown/business-case-tractatus-framework.md index 674e4d57..4d2faebc 100644 --- a/docs/markdown/business-case-tractatus-framework.md +++ b/docs/markdown/business-case-tractatus-framework.md @@ -115,7 +115,7 @@ The EU AI Act establishes penalties for non-compliance: ### 2.1 What Tractatus Provides -The framework consists of five components designed to create decision boundaries for AI systems: +The framework consists of six components designed to create decision boundaries for AI systems: **1. InstructionPersistenceClassifier** - Maintains organizational directives across AI sessions @@ -142,6 +142,11 @@ The framework consists of five components designed to create decision boundaries - Designed to improve decision coherence - Status: Research implementation, requires adaptation +**6. PluralisticDeliberationOrchestrator** +- Facilitates multi-stakeholder deliberation for values conflicts +- Designed to support non-hierarchical decision-making processes +- Status: Research implementation (October 2025), requires adaptation + ### 2.2 What Tractatus Does NOT Provide **Critical limitations to assess:** diff --git a/docs/markdown/case-studies.md b/docs/markdown/case-studies.md index 5e017cfd..124db172 100644 --- a/docs/markdown/case-studies.md +++ b/docs/markdown/case-studies.md @@ -553,6 +553,21 @@ Continuing in this degraded state risks introducing critical bugs. - Alignment/coherence/completeness/safety/alternatives scoring - Confidence thresholds block low-quality actions +### Pattern 5: Values Conflict Without Stakeholder Deliberation + +**Symptoms:** +- Values decisions made without consulting affected stakeholders +- Hierarchical resolution of incommensurable values (privacy vs. safety) +- Loss of moral remainder documentation +- Precedents applied as binding rules rather than informative context + +**Tractatus Prevention:** +- PluralisticDeliberationOrchestrator facilitates multi-stakeholder deliberation +- Non-hierarchical values deliberation process +- Documents dissenting views and moral remainder +- Creates informative (not binding) precedents +- Requires human approval for stakeholder list and final decision + --- ## Lessons Learned diff --git a/docs/markdown/core-concepts.md b/docs/markdown/core-concepts.md index 93bde3bd..b5db6106 100644 --- a/docs/markdown/core-concepts.md +++ b/docs/markdown/core-concepts.md @@ -513,6 +513,228 @@ confidence = ( --- +## 6. PluralisticDeliberationOrchestrator + +### Purpose + +Facilitates multi-stakeholder deliberation across plural moral values without imposing hierarchy when BoundaryEnforcer flags values conflicts. + +### The Problem It Solves + +BoundaryEnforcer blocks values decisions and requires human approval—but then what? How should humans deliberate when stakeholders hold different moral frameworks? + +**Without structured deliberation:** +- No guidance for WHO should be consulted +- No process for HOW to deliberate fairly +- Risk of privileging one moral framework over others (consequentialism > deontology, or vice versa) +- No documentation of dissent or what was lost in the decision +- Precedents might become rigid rules (exactly what value pluralism rejects) + +**Traditional approaches fail:** +- Majority vote → suppresses minority moral perspectives +- Expert panels → risk elite capture, exclude affected communities +- Utilitarian maximization → treats all values as commensurable (reducible to single metric) + +### Core Principles (From Value Pluralism Research) + +1. **Foundational Pluralism** - Moral frameworks are irreducibly different, no supervalue resolves them +2. **Incommensurability ≠ Incomparability** - Can compare values without common metric (practical wisdom, covering values) +3. **Rational Regret** - Document what's lost in decisions, not just what's gained (moral remainder) +4. **Legitimate Disagreement** - Valid outcome when values are genuinely incommensurable +5. **Provisional Agreement** - Decisions are reviewable when context changes, not permanent rules + +### When to Invoke + +- BoundaryEnforcer flags values conflict → triggers PluralisticDeliberationOrchestrator +- Privacy vs. safety trade-offs (GDPR compliance vs. fraud detection) +- Individual rights vs. collective welfare tensions (contact tracing vs. privacy) +- Cultural values conflicts (Western individualism vs. Indigenous communitarian ethics) +- Policy decisions affecting diverse communities + +### How It Works + +**1. Values Conflict Detection** + +```javascript +const conflict = await PluralisticDeliberationOrchestrator.analyzeConflict({ + decision: "Disclose user data to prevent imminent harm?", + context: { urgency: 'CRITICAL', scale: '100+ affected', harm_type: 'physical' } +}); + +// Output: +{ + moral_frameworks_in_tension: [ + { + framework: "Rights-based (Deontological)", + position: "Privacy is inviolable right, cannot trade for outcomes", + stakeholders: ["privacy_advocates", "civil_liberties_orgs"] + }, + { + framework: "Consequentialist (Utilitarian)", + position: "Maximize welfare, prevent harm to 100+ people", + stakeholders: ["public_safety_officials", "harm_prevention_specialists"] + }, + { + framework: "Care Ethics", + position: "Context matters, relationships and vulnerability central", + stakeholders: ["affected_individuals", "community_support_services"] + } + ], + value_trade_offs: ["Privacy vs. Safety", "Individual rights vs. Collective welfare"], + affected_stakeholder_groups: ["users_with_data", "potential_victims", "platform_community"] +} +``` + +**2. Stakeholder Engagement** + +- **AI suggests** stakeholders based on conflict analysis +- **Human MUST approve** stakeholder list (prevents AI from excluding marginalized voices) +- Ensure diverse perspectives: affected parties, not just experts +- Use AdaptiveCommunicationOrchestrator for culturally appropriate outreach + +**3. Deliberation Facilitation** + +Structured rounds (NOT majority vote): + +- **Round 1**: Each moral framework states position and concerns +- **Round 2**: Identify shared values and explore accommodations +- **Round 3**: Clarify areas of agreement and irreducible differences +- **Round 4**: Document decision, dissent, and moral remainder + +**Example Deliberation Structure:** + +```javascript +{ + invitation_message: "Multiple moral frameworks are in tension. We need diverse perspectives.", + discussion_rounds: [ + { + round: 1, + purpose: 'State positions from each moral framework', + format: 'Written submissions + oral presentations' + }, + { + round: 2, + purpose: 'Explore accommodations and shared values', + format: 'Facilitated discussion, no hierarchy' + }, + { + round: 3, + purpose: 'Identify irreconcilable differences', + format: 'Consensus-seeking with documented dissent' + } + ] +} +``` + +**4. Outcome Documentation** + +```javascript +{ + decision_made: "Disclose data in this specific case", + values_prioritized: ["harm_prevention", "collective_safety"], + values_deprioritized: ["individual_privacy", "data_autonomy"], + moral_remainder: "Privacy violation acknowledged as moral loss, not costless trade-off", + dissenting_perspectives: [ + { + framework: "Rights-based (Deontological)", + objection: "Privacy violation sets dangerous precedent, erodes rights over time", + stakeholders: ["privacy_advocates", "civil_liberties_groups"] + } + ], + justification: "Given imminent physical harm to 100+ people, prioritized safety with procedural safeguards", + precedent_applicability: "Applies to imminent physical harm cases ONLY, not routine data requests", + precedent_binding: false, // Informative, not rigid rule + review_date: "2025-11-12", + review_trigger: "If context changes (e.g., harm prevented, new technical solutions)" +} +``` + +### Integration with Other Services + +1. **BoundaryEnforcer** → triggers PluralisticDeliberationOrchestrator when values conflict detected +2. **CrossReferenceValidator** → checks deliberation outcomes against precedent database +3. **AdaptiveCommunicationOrchestrator** → ensures culturally appropriate stakeholder engagement +4. **MetacognitiveVerifier** → assesses AI's value conflict detection accuracy +5. **InstructionPersistenceClassifier** → stores deliberation outcomes as HIGH persistence instructions + +### Tiered Response by Urgency + +- **CRITICAL** (minutes to hours): Automated triage + immediate human review → full deliberation post-incident +- **URGENT** (hours to days): Expedited stakeholder consultation (compressed process) +- **IMPORTANT** (weeks): Full deliberative process with all stakeholders +- **ROUTINE** (months): Precedent matching + lightweight review + +### Enforcement Mechanisms + +**Human Oversight: MANDATORY** +- AI facilitates, humans decide (TRA-OPS-0002) +- Stakeholder list requires human approval (prevents exclusion) +- Deliberation outcomes require human approval +- Values decisions NEVER automated + +**Non-Hierarchical Process:** +- No automatic value ranking (privacy > safety or safety > privacy) +- Moral frameworks treated as equally legitimate +- Dissent documented with full legitimacy, not dismissed +- Precedents are informative guides, not binding rules + +### Real-World Example + +**Scenario: AI hiring tool deployment** + +**Without PluralisticDeliberationOrchestrator:** +- BoundaryEnforcer blocks: "This affects hiring fairness" +- Human decides: "Seems fine, approve" +- No consultation with affected groups +- No documentation of trade-offs + +**With PluralisticDeliberationOrchestrator:** + +1. **Detects frameworks in tension:** + - Efficiency (business value) + - Equity (fair opportunity for underrepresented groups) + - Privacy (applicant data protection) + +2. **Identifies stakeholders (human-approved):** + - Job applicants (especially from underrepresented groups) + - Hiring managers + - Diversity advocates + - Legal/compliance team + - Current employees (workplace culture affected) + +3. **Structured deliberation:** + - Round 1: Each perspective states concerns + - Round 2: Explore accommodations (e.g., mandatory human review for borderline cases) + - Round 3: Clarify trade-offs and document what cannot be resolved + +4. **Documents outcome:** + - Decision: Deploy with mandatory human review for borderline cases + - Values prioritized: Efficiency + Equity + - Values deprioritized: Full automation + - Moral remainder: Applicants experience slower process (acknowledged loss) + - Dissent: Full automation advocates object, request 6-month review + - Review date: 2026-04-15 + +### Why Added in October 2025 + +Initially designed as 5-service framework. PluralisticDeliberationOrchestrator promoted to 6th mandatory service in October 2025 after recognizing: + +**Gap in original 5 services:** +- BoundaryEnforcer blocks values decisions ✓ +- But provides no structure for HOW humans should deliberate ✗ +- Risk of ad-hoc, inconsistent, or unfair deliberation processes ✗ + +**What the 6th service adds:** +- Structured stakeholder engagement +- Non-hierarchical deliberation process +- Documentation of dissent and moral remainder +- Precedent database (informative, not binding) +- Integration with value pluralism research + +Status changed from "Phase 2 enhancement" to **mandatory sixth service** because deploying AI systems in diverse communities without structured value pluralism was deemed architecturally insufficient. + +--- + ## How the Services Work Together ### Example: Preventing the 27027 Incident @@ -550,6 +772,10 @@ confidence = ( - Increases error frequency pressure - May recommend session handoff if errors cluster +6. **PluralisticDeliberationOrchestrator**: + - Not needed (technical decision, not values conflict) + - But would engage stakeholders if port choice had security/policy implications + **Result**: Incident prevented before execution --- @@ -572,8 +798,9 @@ The six services integrate at multiple levels: 1. MetacognitiveVerifier checks reasoning 2. CrossReferenceValidator checks instruction history 3. BoundaryEnforcer checks decision domain -4. If approved, execute -5. ContextPressureMonitor updates state +4. If values conflict → PluralisticDeliberationOrchestrator facilitates deliberation +5. If approved, execute +6. ContextPressureMonitor updates state ### Session End - Store new instructions diff --git a/docs/markdown/implementation-guide-v1.1.md b/docs/markdown/implementation-guide-v1.1.md index 85f68167..ab20cd7e 100644 --- a/docs/markdown/implementation-guide-v1.1.md +++ b/docs/markdown/implementation-guide-v1.1.md @@ -118,13 +118,15 @@ The framework consists of 6 core services: 1. **InstructionPersistenceClassifier**: Classify and persist user instructions 2. **CrossReferenceValidator**: Validate actions against stored instructions -3. **BoundaryEnforcer**: Enforce inst_016-018 content validation +3. **BoundaryEnforcer**: Block values decisions requiring human approval 4. **ContextPressureMonitor**: Monitor session quality degradation 5. **MetacognitiveVerifier**: Confidence-based action verification -6. **BlogCuration**: Validate blog content against governance rules +6. **PluralisticDeliberationOrchestrator**: Facilitate multi-stakeholder deliberation for values conflicts All services integrate with **MemoryProxy** for MongoDB access. +**Note**: BlogCuration is an application-level service, separate from the 6 core governance framework services. + ### Basic Initialization ```javascript @@ -133,7 +135,7 @@ const CrossReferenceValidator = require('./src/services/CrossReferenceValidator. const BoundaryEnforcer = require('./src/services/BoundaryEnforcer.service'); const ContextPressureMonitor = require('./src/services/ContextPressureMonitor.service'); const MetacognitiveVerifier = require('./src/services/MetacognitiveVerifier.service'); -const BlogCuration = require('./src/services/BlogCuration.service'); +const PluralisticDeliberationOrchestrator = require('./src/services/PluralisticDeliberationOrchestrator.service'); // Initialize all services (loads governance rules from MongoDB) async function initializeFramework() { @@ -142,9 +144,9 @@ async function initializeFramework() { await BoundaryEnforcer.initialize(); await ContextPressureMonitor.initialize(); await MetacognitiveVerifier.initialize(); - await BlogCuration.initialize(); + await PluralisticDeliberationOrchestrator.initialize(); - console.log('✓ Tractatus Framework initialized'); + console.log('✓ Tractatus Framework initialized (6 services)'); } // Call during application startup diff --git a/docs/markdown/implementation-guide.md b/docs/markdown/implementation-guide.md index 0d6cbd7d..1acb87ab 100644 --- a/docs/markdown/implementation-guide.md +++ b/docs/markdown/implementation-guide.md @@ -34,7 +34,8 @@ const { CrossReferenceValidator, BoundaryEnforcer, ContextPressureMonitor, - MetacognitiveVerifier + MetacognitiveVerifier, + PluralisticDeliberationOrchestrator } = require('tractatus-framework'); // Initialize services @@ -43,6 +44,7 @@ const validator = new CrossReferenceValidator(); const enforcer = new BoundaryEnforcer(); const monitor = new ContextPressureMonitor(); const verifier = new MetacognitiveVerifier(); +const deliberator = new PluralisticDeliberationOrchestrator(); ``` --- @@ -467,6 +469,107 @@ await executeAction(); --- +### PluralisticDeliberationOrchestrator + +**When to Use:** +- When BoundaryEnforcer flags a values conflict +- Privacy vs. safety trade-offs +- Individual rights vs. collective welfare tensions +- Cultural values conflicts +- Policy decisions affecting diverse communities + +**Integration:** + +```javascript +// Trigger deliberation when values conflict detected +async function handleValuesDecision(decision) { + // First, BoundaryEnforcer blocks the decision + const boundary = enforcer.enforce(decision); + + if (!boundary.allowed && boundary.reason.includes('values')) { + // Initiate pluralistic deliberation + const deliberation = await deliberator.orchestrate({ + decision: decision, + context: { + stakeholders: ['privacy_advocates', 'safety_team', 'legal', 'affected_users'], + moral_frameworks: ['deontological', 'consequentialist', 'care_ethics'], + urgency: 'IMPORTANT' // CRITICAL, URGENT, IMPORTANT, ROUTINE + } + }); + + // Structure returned: + // { + // status: 'REQUIRES_HUMAN_APPROVAL', + // stakeholder_list: [...], + // deliberation_structure: { + // rounds: 3, + // values_in_tension: ['privacy', 'harm_prevention'], + // frameworks: ['deontological', 'consequentialist'] + // }, + // outcome_template: { + // decision: null, + // values_prioritized: [], + // values_deprioritized: [], + // moral_remainder: null, + // dissenting_views: [], + // review_date: null + // }, + // precedent_applicability: { + // narrow: 'user_data_disclosure_imminent_threat', + // broad: 'privacy_vs_safety_tradeoffs' + // } + // } + + // AI facilitates, humans decide (mandatory human approval) + await approvalQueue.add({ + type: 'pluralistic_deliberation', + decision: decision, + deliberation_plan: deliberation, + requires_human_approval: true, + stakeholder_approval_required: true // Must approve stakeholder list + }); + + return { + status: 'DELIBERATION_INITIATED', + message: 'Values conflict detected. Pluralistic deliberation process started.', + stakeholders_to_convene: deliberation.stakeholder_list + }; + } + + return { status: 'NO_DELIBERATION_NEEDED' }; +} + +// After human-led deliberation, store outcome as precedent +async function storeDeliberationOutcome(outcome) { + await deliberator.storePrecedent({ + decision: outcome.decision, + values_prioritized: outcome.values_prioritized, + values_deprioritized: outcome.values_deprioritized, + moral_remainder: outcome.moral_remainder, + dissenting_views: outcome.dissenting_views, + review_date: outcome.review_date, + applicability: { + narrow: outcome.narrow_scope, + broad: outcome.broad_scope + }, + binding: false // Precedents are informative, not binding + }); + + return { status: 'PRECEDENT_STORED' }; +} +``` + +**Key Principles:** + +- **Foundational Pluralism**: No universal value hierarchy (privacy > safety or safety > privacy) +- **Legitimate Disagreement**: Valid outcome when values genuinely incommensurable +- **Human-in-the-Loop**: AI facilitates deliberation structure, humans make decisions +- **Non-Hierarchical**: No automatic ranking of moral frameworks +- **Provisional Decisions**: All values decisions reviewable when context changes +- **Moral Remainder Documentation**: Record what's lost in trade-offs + +--- + ## Configuration ### Instruction Storage @@ -572,6 +675,7 @@ Once comfortable: 1. Add BoundaryEnforcer for values-sensitive domains 2. Add ContextPressureMonitor for long sessions 3. Add MetacognitiveVerifier for complex operations +4. Add PluralisticDeliberationOrchestrator for multi-stakeholder values conflicts ### 3. Tune Thresholds diff --git a/docs/markdown/introduction.md b/docs/markdown/introduction.md index b7ad0943..fd966563 100644 --- a/docs/markdown/introduction.md +++ b/docs/markdown/introduction.md @@ -99,6 +99,18 @@ AI self-checks its own reasoning before proposing actions: Returns confidence scores and recommends PROCEED, PROCEED_WITH_CAUTION, REQUIRE_REVIEW, or BLOCKED. +### 6. PluralisticDeliberationOrchestrator + +Facilitates multi-stakeholder deliberation when BoundaryEnforcer flags values conflicts: + +- **Conflict Detection** - Identifies moral frameworks in tension (deontological, consequentialist, care ethics, etc.) +- **Stakeholder Engagement** - Identifies affected parties requiring representation (human approval mandatory) +- **Non-Hierarchical Deliberation** - No automatic value ranking (privacy vs. safety decisions require structured process) +- **Outcome Documentation** - Records decision, dissenting views, moral remainder, and precedent applicability +- **Provisional Decisions** - All values decisions are reviewable when context changes + +AI facilitates deliberation, humans decide. Precedents are informative, not binding. + ## Why "Tractatus"? The name honors Ludwig Wittgenstein's *Tractatus Logico-Philosophicus*, which established that: @@ -201,9 +213,10 @@ AI systems gradually make decisions in values-sensitive domains without realizin **Phase 1 Implementation Complete (2025-10-07)** - All six core services implemented and tested (100% coverage) -- 192 unit tests passing +- 192 unit tests passing (including PluralisticDeliberationOrchestrator) - Instruction persistence database operational - Active governance for development sessions +- Value pluralism framework integrated (October 2025) **This website** is built using the Tractatus framework to govern its own development - a practice called "dogfooding." diff --git a/docs/markdown/organizational-theory-foundations.md b/docs/markdown/organizational-theory-foundations.md index c9a4423b..58b550c1 100644 --- a/docs/markdown/organizational-theory-foundations.md +++ b/docs/markdown/organizational-theory-foundations.md @@ -131,6 +131,12 @@ The translation from organizational theory to AI safety architecture manifests i - Prevents tactical decisions from violating strategic directives - **Result**: Organizational coherence across time horizons +**4. PluralisticDeliberationOrchestrator** +- Implements agentic organization and network structure principles (Laloux, Robertson, Hamel) +- Facilitates multi-stakeholder deliberation without imposing value hierarchy +- Distributed decision-making authority based on affected stakeholder groups +- **Result**: Non-hierarchical values deliberation reflecting agentic organizational principles + ### Why This Matters: The 27027 Incident The organizational theory foundation explains why Tractatus prevents failures like the 27027 incident: diff --git a/package.json b/package.json index 571bbaf9..ef831868 100644 --- a/package.json +++ b/package.json @@ -9,6 +9,8 @@ "dev:simple": "nodemon src/server.js", "build:css": "npx tailwindcss -i ./public/css/src/tailwind.css -o ./public/css/tailwind.css --minify", "watch:css": "npx tailwindcss -i ./public/css/src/tailwind.css -o ./public/css/tailwind.css --watch", + "update:cache": "node scripts/update-cache-version.js", + "build": "npm run update:cache && npm run build:css", "test": "jest --coverage", "test:watch": "jest --watch", "test:unit": "jest tests/unit", @@ -22,7 +24,7 @@ "seed:admin": "node scripts/seed-admin.js", "seed:projects": "node scripts/seed-projects.js", "generate:pdfs": "node scripts/generate-pdfs.js", - "deploy": "bash scripts/deploy-frontend.sh", + "deploy": "npm run build && bash scripts/deploy-frontend.sh", "framework:init": "node scripts/session-init.js", "framework:watchdog": "node scripts/framework-watchdog.js", "framework:check": "node scripts/pre-action-check.js", diff --git a/public/about.html b/public/about.html index 3578e815..e1d3278a 100644 --- a/public/about.html +++ b/public/about.html @@ -5,7 +5,7 @@ About | Tractatus AI Safety Framework - +