diff --git a/public/js/components/footer.js b/public/js/components/footer.js new file mode 100644 index 00000000..adb05c02 --- /dev/null +++ b/public/js/components/footer.js @@ -0,0 +1,181 @@ +/** + * Footer Component - i18n-enabled + * Shared footer for all Tractatus pages with language persistence + */ + +(function() { + 'use strict'; + + class TractatusFooter { + constructor() { + this.init(); + } + + init() { + console.log('[Footer] Initializing...'); + + // Listen for i18n initialization event (fired by i18n-simple.js) + if (window.I18n && window.I18n.translations && window.I18n.translations.footer) { + // i18n already loaded + console.log('[Footer] i18n already loaded, rendering immediately'); + this.render(); + this.attachEventListeners(); + } else { + // Wait for i18nInitialized event + console.log('[Footer] Waiting for i18nInitialized event...'); + window.addEventListener('i18nInitialized', () => { + console.log('[Footer] i18n initialized event received'); + // Double-check translations loaded + if (window.I18n && window.I18n.translations && window.I18n.translations.footer) { + console.log('[Footer] Footer translations confirmed, rendering'); + this.render(); + this.attachEventListeners(); + } else { + console.error('[Footer] Event fired but no footer translations:', window.I18n?.translations); + // Render anyway + this.render(); + this.attachEventListeners(); + } + }, { once: true }); + } + } + + render() { + const currentYear = new Date().getFullYear(); + + // Create footer HTML with data-i18n attributes + const footerHTML = ` + + `; + + // Insert footer at end of body + const existingFooter = document.querySelector('footer[role="contentinfo"]'); + if (existingFooter) { + existingFooter.outerHTML = footerHTML; + } else if (document.body) { + document.body.insertAdjacentHTML('beforeend', footerHTML); + } else { + // If body not ready, wait for DOM + document.addEventListener('DOMContentLoaded', () => { + document.body.insertAdjacentHTML('beforeend', footerHTML); + this.applyFooterTranslations(); + }); + return; // Exit early if DOM not ready + } + + // Apply translations after DOM update + this.applyFooterTranslations(); + } + + applyFooterTranslations() { + // Use double requestAnimationFrame to ensure DOM is fully painted + requestAnimationFrame(() => { + requestAnimationFrame(() => { + if (window.I18n && window.I18n.applyTranslations) { + console.log('[Footer] Applying translations...'); + console.log('[Footer] Footer exists:', !!document.querySelector('footer[role="contentinfo"]')); + console.log('[Footer] Elements with data-i18n:', document.querySelectorAll('footer[role="contentinfo"] [data-i18n]').length); + window.I18n.applyTranslations(); + console.log('[Footer] Translations applied'); + + // Verify a sample translation + const aboutHeading = document.querySelector('footer [data-i18n="footer.about_heading"]'); + if (aboutHeading) { + console.log('[Footer] about_heading element text:', aboutHeading.innerHTML); + } + } else { + console.warn('[Footer] I18n not available for translation'); + } + }); + }); + } + + attachEventListeners() { + // Listen for language changes and re-render footer + window.addEventListener('languageChanged', (event) => { + console.log('[Footer] Language changed to:', event.detail.language); + this.render(); + }); + } + } + + // Auto-initialize when DOM is ready + if (document.readyState === 'loading') { + document.addEventListener('DOMContentLoaded', () => new TractatusFooter()); + } else { + new TractatusFooter(); + } + +})(); diff --git a/public/js/i18n-simple.js b/public/js/i18n-simple.js new file mode 100644 index 00000000..5240f088 --- /dev/null +++ b/public/js/i18n-simple.js @@ -0,0 +1,259 @@ +/** + * Simple i18n system for Tractatus + * Supports: en (English), de (German), fr (French), mi (Te Reo Māori - coming soon) + */ + +const I18n = { + currentLang: 'en', + translations: {}, + supportedLanguages: ['en', 'de', 'fr'], + + async init() { + // 1. Detect language preference + this.currentLang = this.detectLanguage(); + + // 2. Load translations + await this.loadTranslations(this.currentLang); + + // 3. Apply to page + this.applyTranslations(); + + // 4. Update language selector if present + this.updateLanguageSelector(); + + // 5. Dispatch initialization complete event + window.dispatchEvent(new CustomEvent('i18nInitialized', { + detail: { language: this.currentLang } + })); + + console.log(`[i18n] Initialized with language: ${this.currentLang}`); + }, + + detectLanguage() { + // Priority order: + // 1. User's manual selection (localStorage) - allows override via flag clicks + // 2. Browser's language setting (automatic detection) + // 3. Default to English (fallback) + + // 1. Check localStorage first (user override) + const saved = localStorage.getItem('tractatus-lang'); + if (saved && this.supportedLanguages.includes(saved)) { + console.log(`[i18n] Language detected from user preference: ${saved}`); + return saved; + } + + // 2. Check browser language (automatic detection) + const browserLang = (navigator.language || navigator.userLanguage).split('-')[0]; + if (this.supportedLanguages.includes(browserLang)) { + console.log(`[i18n] Language detected from browser: ${browserLang} (from ${navigator.language})`); + return browserLang; + } + + // 3. Default to English + console.log(`[i18n] Language defaulted to: en (browser language '${navigator.language}' not supported)`); + return 'en'; + }, + + detectPageName() { + // Try to get page name from data attribute first + const pageAttr = document.documentElement.getAttribute('data-page'); + if (pageAttr) { + return pageAttr; + } + + // Detect from URL path + const path = window.location.pathname; + + // Map paths to translation file names + const pageMap = { + '/': 'homepage', + '/index.html': 'homepage', + '/researcher.html': 'researcher', + '/leader.html': 'leader', + '/implementer.html': 'implementer', + '/about.html': 'about', + '/about/values.html': 'values', + '/about/values': 'values', + '/faq.html': 'faq', + '/koha.html': 'koha', + '/koha/transparency.html': 'transparency', + '/koha/transparency': 'transparency', + '/privacy.html': 'privacy', + '/privacy': 'privacy' + }; + + return pageMap[path] || 'homepage'; + }, + + async loadTranslations(lang) { + try { + // Always load common translations (footer, navbar, etc.) + const commonResponse = await fetch(`/locales/${lang}/common.json`); + let commonTranslations = {}; + if (commonResponse.ok) { + commonTranslations = await commonResponse.json(); + } + + // Load page-specific translations + const pageName = this.detectPageName(); + const pageResponse = await fetch(`/locales/${lang}/${pageName}.json`); + let pageTranslations = {}; + if (pageResponse.ok) { + pageTranslations = await pageResponse.json(); + } else if (pageName !== 'homepage') { + // If page-specific translations don't exist, that's okay for some pages + console.warn(`[i18n] No translations found for ${lang}/${pageName}, using common only`); + } else { + throw new Error(`Failed to load translations for ${lang}/${pageName}`); + } + + // Deep merge common and page-specific translations (page-specific takes precedence) + // Uses deep merge to preserve nested objects like footer in common.json + this.translations = this.deepMerge(commonTranslations, pageTranslations); + console.log(`[i18n] Loaded translations: common + ${pageName}`); + console.log(`[i18n] Footer translations present:`, !!this.translations.footer); + console.log(`[i18n] Footer.about_heading:`, this.translations.footer?.about_heading); + } catch (error) { + console.error(`[i18n] Error loading translations:`, error); + // Fallback to English if loading fails + if (lang !== 'en') { + this.currentLang = 'en'; + await this.loadTranslations('en'); + } + } + }, + + t(key) { + const keys = key.split('.'); + let value = this.translations; + + for (const k of keys) { + if (value && typeof value === 'object') { + value = value[k]; + } else { + return key; // Return key if translation not found + } + } + + return value || key; + }, + + applyTranslations() { + // Find all elements with data-i18n attribute + // Using innerHTML to preserve formatting like , , tags in translations + document.querySelectorAll('[data-i18n]').forEach(el => { + const key = el.dataset.i18n; + const translation = this.t(key); + + if (typeof translation === 'string') { + el.innerHTML = translation; + } + }); + + // Handle data-i18n-html for HTML content (kept for backward compatibility) + document.querySelectorAll('[data-i18n-html]').forEach(el => { + const key = el.dataset.i18nHtml; + const translation = this.t(key); + + if (typeof translation === 'string') { + el.innerHTML = translation; + } + }); + + // Handle data-i18n-placeholder for input placeholders + document.querySelectorAll('[data-i18n-placeholder]').forEach(el => { + const key = el.dataset.i18nPlaceholder; + const translation = this.t(key); + + if (typeof translation === 'string') { + el.placeholder = translation; + } + }); + }, + + async setLanguage(lang) { + if (!this.supportedLanguages.includes(lang)) { + console.error(`[i18n] Unsupported language: ${lang}`); + return; + } + + // Save preference (overrides browser language detection) + localStorage.setItem('tractatus-lang', lang); + console.log(`[i18n] User manually selected language: ${lang} (saved to localStorage)`); + + // Update current language + this.currentLang = lang; + + // Reload translations + await this.loadTranslations(lang); + + // Reapply to page + this.applyTranslations(); + + // Update selector + this.updateLanguageSelector(); + + // Update HTML lang attribute + document.documentElement.lang = lang; + + // Dispatch event for language change + window.dispatchEvent(new CustomEvent('languageChanged', { + detail: { language: lang } + })); + + console.log(`[i18n] Language changed to: ${lang} (will persist across pages)`); + }, + + updateLanguageSelector() { + const selector = document.getElementById('language-selector'); + if (selector) { + selector.value = this.currentLang; + } + }, + + getLanguageName(code) { + const names = { + 'en': 'English', + 'de': 'Deutsch', + 'fr': 'Français', + 'mi': 'Te Reo Māori' + }; + return names[code] || code; + }, + + /** + * Deep merge utility function + * Recursively merges source into target without overwriting nested objects + * @param {Object} target - Base object (e.g., commonTranslations) + * @param {Object} source - Override object (e.g., pageTranslations) + * @returns {Object} - Deeply merged result + */ + deepMerge(target, source) { + const output = { ...target }; + + for (const key in source) { + if (source.hasOwnProperty(key)) { + // If both values are objects (and not arrays), merge recursively + if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key]) && + target[key] && typeof target[key] === 'object' && !Array.isArray(target[key])) { + output[key] = this.deepMerge(target[key], source[key]); + } else { + // Otherwise, source value takes precedence + output[key] = source[key]; + } + } + } + + return output; + } +}; + +// Auto-initialize when DOM is ready +if (document.readyState === 'loading') { + document.addEventListener('DOMContentLoaded', () => I18n.init()); +} else { + I18n.init(); +} + +// Make available globally +window.I18n = I18n; diff --git a/public/js/researcher-page.js b/public/js/researcher-page.js new file mode 100644 index 00000000..b8e9208b --- /dev/null +++ b/public/js/researcher-page.js @@ -0,0 +1,48 @@ +/** + * Researcher Page - Accordion Functionality + * Handles expandable/collapsible sections for research content + * Implements WAI-ARIA Authoring Practices for accordions + */ + +document.addEventListener('DOMContentLoaded', function() { + // Get all accordion buttons + const accordionButtons = document.querySelectorAll('[data-accordion]'); + + accordionButtons.forEach(button => { + // Click handler + button.addEventListener('click', function() { + const accordionId = this.dataset.accordion; + toggleAccordion(accordionId, this); + }); + + // Keyboard handler (Enter and Space) + button.addEventListener('keydown', function(e) { + if (e.key === 'Enter' || e.key === ' ') { + e.preventDefault(); + const accordionId = this.dataset.accordion; + toggleAccordion(accordionId, this); + } + }); + }); + + /** + * Toggle accordion section open/closed + * @param {string} id - Accordion section ID + * @param {HTMLElement} button - The button element that triggered toggle + */ + function toggleAccordion(id, button) { + const content = document.getElementById(id + '-content'); + const icon = document.getElementById(id + '-icon'); + + if (content && icon) { + const isExpanded = content.classList.contains('active'); + + // Toggle CSS classes for visual state + content.classList.toggle('active'); + icon.classList.toggle('active'); + + // Update ARIA state + button.setAttribute('aria-expanded', isExpanded ? 'false' : 'true'); + } + } +}); diff --git a/public/leader.html b/public/leader.html index 834836b0..4efa11f4 100644 --- a/public/leader.html +++ b/public/leader.html @@ -594,12 +594,8 @@ - - - - - - + + @@ -607,8 +603,12 @@ + + + + - + diff --git a/public/locales/en/common.json b/public/locales/en/common.json new file mode 100644 index 00000000..b33250bd --- /dev/null +++ b/public/locales/en/common.json @@ -0,0 +1,45 @@ +{ + "footer": { + "about_heading": "Tractatus Framework", + "about_text": "Architectural constraints for AI safety that preserve human agency through structural, not aspirational, enforcement.", + "documentation_heading": "Documentation", + "documentation_links": { + "framework_docs": "Framework Docs", + "about": "About", + "core_values": "Core Values", + "interactive_demo": "Interactive Demo" + }, + "support_heading": "Support", + "support_links": { + "koha": "Support (Koha)", + "transparency": "Transparency", + "media_inquiries": "Media Inquiries", + "submit_case": "Submit Case Study" + }, + "legal_heading": "Legal", + "legal_links": { + "privacy": "Privacy Policy", + "contact": "Contact Us", + "github": "GitHub" + }, + "te_tiriti_label": "Te Tiriti o Waitangi:", + "te_tiriti_text": "We acknowledge Te Tiriti o Waitangi and our commitment to partnership, protection, and participation. This project respects Māori data sovereignty (rangatiratanga) and collective guardianship (kaitiakitanga).", + "copyright": "John G Stroh. Licensed under", + "license": "Apache 2.0", + "location": "Made in Aotearoa New Zealand 🇳🇿", + "additional_resources": "Additional Resources", + "for_decision_makers": "For Decision-Makers", + "for_decision_makers_desc": "Strategic perspective on governance challenges and architectural approaches", + "implementation_guide": "Implementation Guide", + "implementation_guide_desc": "Technical integration patterns and deployment considerations", + "further_info": "Further Information", + "technical_docs": "Technical Documentation", + "technical_docs_desc": "Complete architecture specifications, implementation patterns, API reference", + "system_architecture": "System Architecture", + "system_architecture_desc": "Runtime-agnostic governance layer design and integration approach", + "research_case_studies": "Research & Case Studies", + "research_case_studies_desc": "Academic foundations, failure mode analysis, governance research", + "contact": "Contact:", + "contact_text": "For pilot partnerships, validation studies, or technical consultation, contact via" + } +} diff --git a/public/locales/en/leader.json b/public/locales/en/leader.json new file mode 100644 index 00000000..b4568d34 --- /dev/null +++ b/public/locales/en/leader.json @@ -0,0 +1,54 @@ +{ + "page": { + "title": "For Decision-Makers | Tractatus AI Safety Framework", + "description": "Structural AI governance for organisations deploying LLM systems at scale. Research framework addressing architectural gaps in AI safety." + }, + "header": { + "badge": "Research Framework • Early Development", + "title": "Tractatus: Architectural Governance for LLM Systems", + "subtitle": "A governance framework addressing structural gaps in AI safety through external architectural controls. Designed for organisations deploying large language models at scale where conventional oversight mechanisms prove insufficient." + }, + "sections": { + "governance_gap": { + "heading": "The Governance Gap", + "intro": "Current AI governance approaches—policy documents, training programmes, ethical guidelines—rely on voluntary compliance. LLM systems can bypass these controls simply by not invoking them. When an AI agent needs to check a policy, it must choose to do so. When it should escalate a decision to human oversight, it must recognise that obligation.", + "problem": "This creates a structural problem: governance exists only insofar as the AI acknowledges it. For organisations subject to EU AI Act Article 14 (human oversight requirements) or deploying AI in high-stakes domains, this voluntary model is inadequate.", + "solution": "Tractatus explores whether governance can be made architecturally external—difficult to bypass not through better prompts, but through system design that places control points outside the AI's discretion." + }, + "architectural_approach": { + "heading": "Architectural Approach", + "three_layer_title": "Three-Layer Architecture", + "services_title": "Six Governance Services" + }, + "governance_capabilities": { + "heading": "Governance Capabilities", + "intro": "Three interactive demonstrations showing governance infrastructure in operation. These show mechanisms, not fictional scenarios.", + "audit_trail_title": "Audit Trail & Compliance Evidence Generation", + "audit_trail_desc": "Immutable logging, evidence extraction, regulatory reporting", + "continuous_improvement_title": "Continuous Improvement: Incident → Rule Creation", + "continuous_improvement_desc": "Learning from failures, automated rule generation, validation", + "pluralistic_deliberation_title": "Pluralistic Deliberation: Values Conflict Resolution", + "pluralistic_deliberation_desc": "Multi-stakeholder engagement, non-hierarchical process, moral remainder documentation" + }, + "development_status": { + "heading": "Development Status", + "warning_title": "Early-Stage Research Framework", + "warning_text": "Tractatus is a proof-of-concept developed over six months in a single project context (this website). It demonstrates architectural patterns for AI governance but has not undergone independent validation, red-team testing, or multi-organisation deployment.", + "validation_title": "Validated vs. Not Validated" + }, + "eu_ai_act": { + "heading": "EU AI Act Considerations", + "article_14_title": "Regulation 2024/1689, Article 14: Human Oversight" + }, + "research_foundations": { + "heading": "Research Foundations", + "org_theory_title": "Organisational Theory & Philosophical Basis" + }, + "scope_limitations": { + "heading": "Scope & Limitations", + "title": "What This Is Not • What It Offers", + "not_title": "Tractatus is not:", + "offers_title": "What it offers:" + } + } +} diff --git a/public/locales/en/researcher.json b/public/locales/en/researcher.json new file mode 100644 index 00000000..72649ab7 --- /dev/null +++ b/public/locales/en/researcher.json @@ -0,0 +1,52 @@ +{ + "page": { + "title": "For Researchers | Tractatus AI Safety Framework", + "description": "Research foundations, empirical observations, and theoretical basis for architectural approaches to AI governance. Early-stage framework exploring structural constraints on LLM systems." + }, + "header": { + "badge": "Research Framework • Empirical Observations", + "title": "Research Foundations & Empirical Observations", + "subtitle": "Tractatus explores architectural approaches to AI governance through empirical observation of failure modes and application of organisational theory. This page documents research foundations, observed patterns, and theoretical basis for the framework." + }, + "sections": { + "research_context": { + "heading": "Research Context & Scope", + "development_note": "Development Context", + "development_text": "Tractatus was developed over six months (April–October 2025) in progressive stages that evolved into a live demonstration of its capabilities in the form of a single-project context (https://agenticgovernance.digital). Observations derive from direct engagement with Claude Code (Anthropic's Sonnet 4.5 model) across approximately 500 development sessions. This is exploratory research, not controlled study." + }, + "theoretical_foundations": { + "heading": "Theoretical Foundations", + "org_theory_title": "Organisational Theory Basis", + "values_pluralism_title": "Values Pluralism & Moral Philosophy" + }, + "empirical_observations": { + "heading": "Empirical Observations: Documented Failure Modes", + "intro": "Three failure patterns observed repeatedly during framework development. These are not hypothetical scenarios—they are documented incidents that occurred during this project's development.", + "failure_1_title": "Pattern Recognition Bias Override (The 27027 Incident)", + "failure_2_title": "Gradual Values Drift Under Context Pressure", + "failure_3_title": "Silent Quality Degradation at High Context Pressure", + "research_note": "These patterns emerged from direct observation, not hypothesis testing. We don't claim they're universal to all LLM systems or deployment contexts. They represent empirical basis for framework design decisions—problems we actually encountered and architectural interventions that actually worked in this specific context." + }, + "architecture": { + "heading": "Six-Component Architecture", + "services_title": "Framework Services & Functions", + "principle": "Services operate external to AI runtime with autonomous triggering. AI doesn't decide \"should I check governance rules?\"—architecture enforces checking by default. This addresses voluntary compliance problem inherent in prompt-based governance." + }, + "demos": { + "heading": "Interactive Demonstrations", + "classification_title": "Instruction Classification", + "classification_desc": "Explore how instructions are classified across quadrants with persistence levels and temporal scope.", + "incident_title": "27027 Incident Timeline", + "incident_desc": "Step through pattern recognition bias failure and architectural intervention that prevented it.", + "boundary_title": "Boundary Evaluation", + "boundary_desc": "Test decisions against boundary enforcement to see which require human judgment vs. AI autonomy." + }, + "resources": { + "heading": "Research Documentation" + }, + "limitations": { + "heading": "Limitations & Future Research Directions", + "title": "Known Limitations & Research Gaps" + } + } +} diff --git a/public/researcher.html b/public/researcher.html index 07b2bfbd..3afd0680 100644 --- a/public/researcher.html +++ b/public/researcher.html @@ -25,25 +25,50 @@ .skip-link:focus { left: 0; z-index: 100; background: white; padding: 1rem; } a:focus, button:focus { outline: 2px solid #d97706; outline-offset: 2px; } - /* Accordion styles */ - .accordion-button { cursor: pointer; user-select: none; } + /* Accordion styles - mobile-optimized */ + .accordion-button { + cursor: pointer; + user-select: none; + touch-action: manipulation; /* Prevent double-tap zoom on mobile */ + -webkit-tap-highlight-color: rgba(139, 92, 246, 0.1); /* iOS tap feedback */ + min-height: 44px; /* WCAG touch target minimum */ + } .accordion-content { max-height: 0; overflow: hidden; transition: max-height 0.3s ease-out; } .accordion-content.active { - max-height: 3000px; + max-height: 5000px; /* Increased for mobile scrolling */ transition: max-height 0.5s ease-in; } .accordion-icon { transition: transform 0.3s ease; } .accordion-icon.active { transform: rotate(180deg); } + + /* Mobile-specific adjustments */ + @media (max-width: 640px) { + .accordion-button { min-height: 48px; } /* Larger touch target on small screens */ + body { font-size: 16px; } /* Prevent iOS zoom on input focus */ + } + + /* Progressive enhancement: Show all content if JavaScript disabled */ + noscript + * .accordion-content { + max-height: none !important; + overflow: visible !important; + } + + + @@ -88,10 +113,16 @@

- The framework emerged from practical necessity rather than theoretical speculation. During development, we observed recurring patterns where AI systems would override explicit instructions, drift from established values constraints, or silently degrade quality under context pressure. Traditional governance approaches (policy documents, ethical guidelines, prompt engineering) proved insufficient to prevent these failures. + Aligning advanced AI with human values is among the most consequential challenges we face. As capability growth accelerates under big tech momentum, we confront a categorical imperative: preserve human agency over values decisions, or risk ceding control entirely.

- This led to research question: Can governance be made architecturally external to AI systems rather than relying on voluntary AI compliance? Tractatus represents one exploration of that question, grounded in organisational theory and validated through empirical observation of what actually prevented failures in practice. + The framework emerged from practical necessity. During development, we observed recurring patterns where AI systems would override explicit instructions, drift from established values constraints, or silently degrade quality under context pressure. Traditional governance approaches (policy documents, ethical guidelines, prompt engineering) proved insufficient to prevent these failures. +

+

+ Instead of hoping AI systems "behave correctly," Tractatus proposes structural constraints where certain decision types require human judgment. These architectural boundaries can adapt to individual, organizational, and societal norms—creating a foundation for bounded AI operation that may scale more safely with capability growth. +

+

+ This led to the central research question: Can governance be made architecturally external to AI systems rather than relying on voluntary AI compliance? If this approach can work at scale, Tractatus may represent a turning point—a path where AI enhances human capability without compromising human sovereignty.

@@ -102,13 +133,17 @@
-
+
-
+ +

Tractatus draws on four decades of organisational research addressing authority structures during knowledge democratisation: @@ -151,35 +186,54 @@

-
+
-
+ +
+
+ Core Research Focus: The PluralisticDeliberationOrchestrator represents Tractatus's primary theoretical contribution, addressing how to maintain human values persistence in organizations augmented by AI agents. +
+

- The PluralisticDeliberationOrchestrator addresses fundamental problem in AI safety: many "safety" questions are actually values conflicts where multiple legitimate perspectives exist. + The Central Problem: Many "safety" questions in AI governance are actually values conflicts where multiple legitimate perspectives exist. When efficiency conflicts with transparency, or innovation with risk mitigation, no algorithm can determine the "correct" answer. These are values trade-offs requiring human deliberation across stakeholder perspectives. +

+ +

Isaiah Berlin: Value Pluralism

+

+ Berlin's concept of value pluralism argues that legitimate values can conflict without one being objectively superior. Liberty and equality, justice and mercy, innovation and stability—these are incommensurable goods. AI systems trained on utilitarian efficiency maximization cannot adjudicate between them without imposing a single values framework that excludes legitimate alternatives. +

+ +

Simone Weil: Attention and Human Needs

+

+ Weil's philosophy of attention informs the orchestrator's deliberative process. The Need for Roots identifies fundamental human needs (order, liberty, responsibility, equality, hierarchical structure, honor, security, risk, etc.) that exist in tension. Proper attention requires seeing these needs in their full particularity rather than abstracting them into algorithmic weights. In AI-augmented organizations, the risk is that bot-mediated processes treat human values as optimization parameters rather than incommensurable needs requiring careful attention. +

+ +

Bernard Williams: Moral Remainder

+

+ Williams' concept of moral remainder acknowledges that even optimal decisions create unavoidable harm to other legitimate values. The orchestrator documents dissenting perspectives not as "minority opinions to be overruled" but as legitimate moral positions that the chosen course necessarily violates. This prevents the AI governance equivalent of declaring optimization complete when values conflicts are merely suppressed.

- When efficiency conflicts with transparency, or innovation with risk mitigation, no algorithm can determine the "correct" answer. These are values trade-offs requiring human deliberation across stakeholder perspectives. AI systems that attempt to resolve such conflicts autonomously impose single values framework—often utilitarian efficiency maximisation encoded in training data. -

- -

- Framework draws on moral pluralism literature (Isaiah Berlin, Bernard Williams, Martha Nussbaum) arguing legitimate values can conflict without one being objectively superior. Rather than algorithmic resolution, framework facilitates: + Framework Implementation: Rather than algorithmic resolution, the PluralisticDeliberationOrchestrator facilitates:

    -
  • Stakeholder identification: Who has legitimate interest in this decision?
    • -
  • Non-hierarchical deliberation: Equal voice without automatic expert override
    • -
  • Documented dissent: Minority positions recorded in full
    • -
  • Moral remainder: Acknowledgment that even optimal decisions create unavoidable harm to other legitimate values
    • +
  • Stakeholder identification: Who has legitimate interest in this decision? (Weil: whose needs are implicated?)
    • +
  • Non-hierarchical deliberation: Equal voice without automatic expert override (Berlin: no privileged value hierarchy)
    • +
  • Quality of attention: Detailed exploration of how decision affects each stakeholder's needs (Weil: particularity not abstraction)
    • +
  • Documented dissent: Minority positions recorded in full (Williams: moral remainder made explicit)

- This approach recognises that governance isn't solving values conflicts—it's ensuring they're addressed through appropriate deliberative process rather than AI imposing resolution. + This approach recognises that governance isn't solving values conflicts—it's ensuring they're addressed through appropriate deliberative process with genuine human attention rather than AI imposing resolution through training data bias or efficiency metrics.

@@ -298,13 +352,17 @@

Six-Component Architecture

-
+
-
+ +
@@ -440,13 +498,17 @@

Limitations & Future Research Directions

-
+
-
+ +
@@ -490,6 +552,46 @@
+ +
+

References & Bibliography

+ +
+
+ Theoretical Priority: Tractatus emerged from concerns about maintaining human values persistence in AI-augmented organizations. Moral pluralism and deliberative process form the CORE theoretical foundation. Organizational theory provides supporting context for temporal decision authority and structural implementation. +
+ +

Moral Pluralism & Values Philosophy (Primary Foundation)

+
    +
  • Berlin, Isaiah (1969). Four Essays on Liberty. Oxford: Oxford University Press. [Value pluralism, incommensurability of legitimate values]
    • +
  • Weil, Simone (1949/2002). The Need for Roots: Prelude to a Declaration of Duties Towards Mankind (A. Wills, Trans.). London: Routledge. [Human needs, obligations, rootedness in moral community]
    • +
  • Weil, Simone (1947/2002). Gravity and Grace (E. Crawford & M. von der Ruhr, Trans.). London: Routledge. [Attention, moral perception, necessity vs. grace]
    • +
  • Williams, Bernard (1981). Moral Luck: Philosophical Papers 1973-1980. Cambridge: Cambridge University Press. [Moral remainder, conflicts without resolution]
    • +
  • Nussbaum, Martha C. (2000). Women and Human Development: The Capabilities Approach. Cambridge: Cambridge University Press. [Human capabilities, plural values in development]
    • +
+ +

Organisational Theory (Supporting Context)

+
    +
  • Bluedorn, A. C., & Denhardt, R. B. (1988). Time and organizations. Journal of Management, 14(2), 299-320. [Temporal decision horizons]
    • +
  • Crossan, M. M., Lane, H. W., & White, R. E. (1999). An organizational learning framework: From intuition to institution. Academy of Management Review, 24(3), 522-537. [Knowledge coordination]
    • +
  • Hamel, Gary (2007). The Future of Management. Boston: Harvard Business School Press. [Post-hierarchical authority]
    • +
  • Hannan, M. T., & Freeman, J. (1984). Structural inertia and organizational change. American Sociological Review, 49(2), 149-164. [Architectural resistance to drift]
    • +
  • Laloux, Frederic (2014). Reinventing Organizations: A Guide to Creating Organizations Inspired by the Next Stage of Human Consciousness. Brussels: Nelson Parker. [Distributed decision-making]
    • +
+ +

AI Governance & Technical Context

+
    +
  • Anthropic (2024). Claude Code: Technical Documentation. Available at: https://docs.anthropic.com/claude-code
    • +
+ +
+ Note on Intellectual Lineage: The framework's central concern—human values persistence in AI-augmented organizational contexts—derives from moral philosophy rather than management science. The PluralisticDeliberationOrchestrator represents the primary research focus, embodying Weil's concept of attention to plural human needs and Berlin's recognition of incommensurable values. + + Berlin and Weil will be integral to further development of the deliberation component—their work provides the philosophical foundation for understanding how to preserve human agency over values decisions as AI capabilities accelerate. Traditional organizational theory (Weber, Taylor) addresses authority through hierarchy; post-AI organizational contexts require authority through appropriate deliberative process across stakeholder perspectives. Framework development documentation (incident reports, session logs) maintained in project repository but not publicly released pending peer review. +
+
+
+

Additional Resources

@@ -508,12 +610,8 @@
- - - - - - + + @@ -521,8 +619,12 @@ + + + + - + diff --git a/public/version.json b/public/version.json new file mode 100644 index 00000000..6d4ab7f3 --- /dev/null +++ b/public/version.json @@ -0,0 +1,13 @@ +{ + "version": "1.3.0", + "buildDate": "2025-10-22T14:00:00Z", + "changelog": [ + "FIXED: Footer i18n - Implemented deep merge instead of shallow merge", + "Root cause: Shallow merge overwrote footer translations from common.json", + "Solution: Recursive deepMerge() preserves nested objects during translation merge", + "Added diagnostic logging: footer.about_heading value confirmed in console", + "Researcher page: Categorical imperative, Berlin/Weil, WCAG compliance" + ], + "forceUpdate": true, + "minVersion": "1.1.5" +}