feat(i18n): add complete German and French translations for implementer page

Add comprehensive internationalization support for implementer.html:

- Added 277 data-i18n attributes across all major sections:
  * Hero section (title, subtitle, 3 value props)
  * Quick Links navigation (8 items)
  * How It Works section
  * Architecture diagrams (3 sections)
  * Hook Architecture (~50+ elements)
  * Deployment guide
  * Core Services (6 service cards)
  * API Reference (4 examples)
  * Integration Examples & Patterns (8 items)
  * Development Roadmap (6 items + CTA)
  * Resources section

- Translation files:
  * EN: 289 keys (complete structure)
  * DE: 282 keys translated via DeepL Pro API (0 errors)
  * FR: 282 keys translated via DeepL Pro API (0 errors)
  * Validation: 100% - all 277 HTML keys present in all languages

- Added automation scripts:
  * translate-implementer-deepl.js - DeepL translation automation
  * validate-implementer-i18n.js - Translation validation

Follows successful pattern from researcher page translation.
All translations professionally formatted with proper formality.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

public/locales/de/implementer.json

@@ -38,7 +38,24 @@
     "integration_2_title": "Anweisungspersistenz",
     "integration_2_desc": "Benutzeranweisungen klassifiziert und für Kreuzreferenzvalidierung gespeichert",
     "integration_3_title": "Umfassender Audit-Trail",
-    "integration_3_desc": "Jede Governance-Aktion für Compliance und Analyse protokolliert"
+    "integration_3_desc": "Jede Governance-Aktion für Compliance und Analyse protokolliert",
+    "six_services_title": "Sechs Kerndienste",
+    "service_1": "BoundaryEnforcer (Tractatus 12.1-12.7)",
+    "service_2": "InstructionPersistenceClassifier",
+    "service_3": "CrossReferenceValidator",
+    "service_4": "ContextPressureMonitor",
+    "service_5": "Metakognitiver Verifizierer",
+    "service_6": "PluralistischeBeratungOrchestrator",
+    "main_flow_title": "Service Interaktionsablauf",
+    "main_flow_alt": "Tractatus Rahmenarchitektur: Zeigt, wie 6 Governance-Dienste nacheinander interagieren",
+    "trigger_tree_title": "Dienst Auslösende Bedingungen",
+    "trigger_tree_alt": "Entscheidungsbaum für Dienstauslöser: Wenn jeder Rahmendienst aktiviert wird",
+    "system_arch_title": "Systemarchitektur",
+    "system_arch_desc": "Überblick über die Integration der 6 Governance-Dienste in Ihre Anwendungs- und Datenschicht.",
+    "system_arch_alt": "Tractatus Systemarchitektur: Interaktion der Komponenten und Datenfluss",
+    "download_svg_aria": "Download des Hauptflussdiagramms der Architektur als SVG",
+    "download_trigger_svg_aria": "Entscheidungsbaum für Dienstauslöser als SVG herunterladen",
+    "download_system_svg_aria": "Systemarchitekturdiagramm als SVG herunterladen"
   },
   "integration_approaches": {
     "heading": "Integrationsansätze",
@@ -74,12 +91,299 @@
     "technical_docs_title": "Technische Dokumentation",
     "examples_title": "Beispiele",
     "support_title": "Support",
-    "support_desc": "Holen Sie sich Hilfe bei Implementierung, Integration und Fehlerbehebung."
+    "support_desc": "Holen Sie sich Hilfe bei Implementierung, Integration und Fehlerbehebung.",
+    "docs_title": "Dokumentation",
+    "docs_github": "→ GitHub-Repository",
+    "docs_full": "→ Vollständige Dokumentation",
+    "docs_demos": "→ Live-Demos",
+    "reference_title": "Referenz Implementierung",
+    "reference_desc": "Diese Website (agenticgovernance.digital) läuft auf Tractatus governance.",
+    "reference_services": "Dienstleistungen:",
+    "reference_services_value": "22 Komponenten der Governance",
+    "reference_models": "Datenmodelle:",
+    "reference_models_value": "29 MongoDB-Schemata",
+    "reference_tests": "Testabdeckung:",
+    "reference_tests_value": "35 Testsuiten",
+    "reference_repo": "→ Repository für die Zusammenarbeit",
+    "support_issues": "→ GitHub-Ausgaben",
+    "support_discussions": "→ GitHub-Diskussionen",
+    "support_email": "→ research@agenticgovernance.digital",
+    "support_faq": "→ Häufig gestellte Fragen"
   },
   "cta": {
     "title": "Implementierung erkunden?",
     "description": "Erkunden Sie architektonische Muster für KI-Sicherheit, die in einer Einzelprojekt-Validierung demonstriert wurden.",
     "view_docs_btn": "Vollständige Dokumentation anzeigen",
     "research_btn": "Forschungshintergrund →"
+  },
+  "ui": {
+    "breadcrumb_home": "Startseite",
+    "breadcrumb_implementer": "Leitfaden für die Umsetzung",
+    "skip_to_content": "Zum Hauptinhalt springen"
+  },
+  "hero": {
+    "title": "Externe Governance-Dienstleistungen für AI-Systeme",
+    "subtitle": "Sechs architektonische Dienste für die Überschreibung von Mustern und die Rückverfolgbarkeit von Entscheidungen in agentenbasierten Systemen. Entwicklungsrahmen für die Persistenz von Anweisungen, die Durchsetzung von Grenzwerten und die Protokollierung von Prüfungen.",
+    "value_prop_1_icon": "🏗️",
+    "value_prop_1_title": "Architektonische Trennung",
+    "value_prop_1_desc": "Governance läuft außerhalb des AI-Modells",
+    "value_prop_2_icon": "💾",
+    "value_prop_2_title": "Unterweisung Persistenz",
+    "value_prop_2_desc": "Validiert Anweisungen kontextübergreifend",
+    "value_prop_3_icon": "📋",
+    "value_prop_3_title": "Audit Trail by Design",
+    "value_prop_3_desc": "MongoDB-Protokolle mit Dienstzuordnung"
+  },
+  "nav": {
+    "quick_links_label": "Seitenabschnitte",
+    "how_it_works": "Wie es funktioniert",
+    "architecture": "Architektur",
+    "hooks": "Haken Architektur",
+    "deployment": "Einsatz",
+    "services": "Dienstleistungen",
+    "api": "API-Referenz",
+    "patterns": "Integration von Mustern",
+    "roadmap": "Straßenkarte"
+  },
+  "how_it_works": {
+    "heading": "Wie es funktioniert",
+    "problem_title": "Muster überschreiben Herausforderung",
+    "problem_desc": "Bei KI-Systemen, die über längere Zeiträume hinweg interagieren, kann es vorkommen, dass die Konsistenz der Anweisungen nicht gewahrt bleibt, wenn sich der Kontext ändert. Frühzeitig erteilte Anweisungen können depriorisiert oder uminterpretiert werden.",
+    "approach_title": "Ansatz der externen Architektur",
+    "approach_desc": "Die Tractatus-Dienste laufen außerhalb des KI-Modells und bieten durch die architektonische Trennung Grenzvalidierung, Befehlsklassifizierung und Audit-Protokollierung.",
+    "diagram_title": "Anfragefluss mit Governance",
+    "diagram_desc": "Beispiel: KI-Entscheidungsfluss mit Grenzdurchsetzung - von der Benutzeranfrage über die Governance-Validierung bis hin zur menschlichen Genehmigung.",
+    "diagram_alt": "Ablauf des Anfrageflusses: Wie AI-Entscheidungen gesteuert werden",
+    "download_svg": "SVG herunterladen"
+  },
+  "hooks": {
+    "badge": "ARCHITEKTONISCHE DURCHSETZUNG",
+    "heading": "Haken Architektur: Die Glaubwürdigkeitsschicht",
+    "subtitle": "Tractatus Governance ist keine freiwillige Einhaltung. PreToolUse Hooks setzen Grenzen durch, bevor KI-Aktionen ausgeführt werden, was eine Umgehung architektonisch unmöglich macht.",
+    "problem_title": "Das Problem der freiwilligen Einhaltung",
+    "problem_desc_1": "Herkömmliche KI-Sicherheit beruht darauf, dass das KI-System sich dafür entscheidet, Regeln zu befolgen, die in Trainingsdaten oder Systemaufforderungen enthalten sind. Bei diesen Ansätzen wird davon ausgegangen, dass die KI unabhängig vom Druck des Kontextes oder der Fähigkeit die Ausrichtung beibehält.",
+    "problem_desc_2": "Der Tractatus löst dieses Problem durch architektonische Durchsetzung: Die Steuerung läuft in einem separaten Prozess, auf den die KI nicht zugreifen, ihn nicht verändern oder umgehen kann.",
+    "flow_title": "PreToolUse Hook Ausführungsablauf",
+    "flow_desc": "Bevor eine Datei bearbeitet, geschrieben oder ein Bash-Befehl ausgeführt wird, fängt der Hook die Aktion ab und führt Validierungsprüfungen durch. Nur wenn ALLE Prüfungen erfolgreich sind (Exit-Code 0), wird die AI-Aktion fortgesetzt.",
+    "flow_alt": "Hook-Architektur: PreToolUse Abfangfluss mit Validierung und harten Blöcken",
+    "examples_title": "Beispiele für die tatsächliche Durchsetzung",
+    "example_1_icon": "🚫",
+    "example_1_title": "GitHub URL-Schutz (inst_084)",
+    "example_1_desc": "AI hat versucht, die URL des GitHub-Repositorys von tractatus-framework (öffentlich) auf tractatus (privat) zu ändern.",
+    "example_1_blocked": "GESPERRT:",
+    "example_1_reason": "Änderung der Repository-URL entdeckt",
+    "example_1_detail": "Grund: Würde private Repo-Struktur offenlegen",
+    "example_1_hook": "Haken: validate-file-edit.js Zeile 448-505",
+    "example_2_icon": "🚫",
+    "example_2_title": "CSP-Verstoß (inst_008)",
+    "example_2_desc": "AI hat versucht, einem HTML-Element ein Inline-Style-Attribut hinzuzufügen.",
+    "example_2_blocked": "GESPERRT:",
+    "example_2_reason": "Inline-Stil erkannt",
+    "example_2_pattern": "Muster:",
+    "example_2_hook": "Haken: validate-file-write.js Zeile 68-149",
+    "example_3_icon": "🚫",
+    "example_3_title": "Schutz von Governance-Dateien (inst_027)",
+    "example_3_desc": "AI hat versucht, die Datei instruction-history.json direkt zu bearbeiten.",
+    "example_3_blocked": "GESPERRT:",
+    "example_3_reason": "inst_027 harter Block",
+    "example_3_use": "Verwenden Sie stattdessen: scripts/add-instruction.js",
+    "example_3_hook": "Haken: framework-audit-hook.js Zeile 204-209",
+    "example_4_icon": "⚠",
+    "example_4_title": "Menschliche Zustimmung erforderlich (BoundaryEnforcer)",
+    "example_4_desc": "Die AI-Aktion berührt eine wertesensitive Datei (Datenschutzrichtlinie).",
+    "example_4_status": "ASK HUMAN:",
+    "example_4_reason": "Werte Entscheidung erkannt",
+    "example_4_requires": "Erfordert: Ausdrückliche menschliche Zustimmung",
+    "example_4_hook": "Haken: validate-file-write.js Zeile 239-262",
+    "tech_impl_title": "Technische Umsetzung",
+    "process_sep_icon": "🔒",
+    "process_sep_title": "Prozess-Trennung",
+    "process_sep_desc": "Hooks werden in einem separaten Node.js-Prozess (child_process.spawn) mit eigenem Speicherplatz ausgeführt. Der KI-Agent kann nicht auf den Validierungsprozess zugreifen, ihn ändern oder beenden.",
+    "exit_code_icon": "⚙️",
+    "exit_code_title": "Exit-Code-Durchsetzung",
+    "exit_code_desc": "Hook-Validatoren geben Exit-Codes zurück, die von der Architektur von Claude Code erzwungen werden:",
+    "exit_code_0": "0 = PASS → Werkzeug wird ausgeführt",
+    "exit_code_2": "2 = HARD BLOCK → Werkzeugausführung angehalten, Fehler wird dem Benutzer angezeigt",
+    "audit_icon": "📊",
+    "audit_title": "Prüfpfad",
+    "audit_desc": "Jede Hook-Ausführung wird in .claude/metrics/hooks-metrics.json mit Zeitstempel, Datei, Ergebnis und Grund protokolliert. Die Blöcke werden für die Analyse separat aufgezeichnet.",
+    "why_matters_title": "Warum die architektonische Durchsetzung wichtig ist",
+    "why_matters_desc": "Dies ist der grundlegende Unterschied zwischen dem Tractatus und den traditionellen Sicherheitsansätzen der KI:",
+    "voluntary_title": "❌ Freiwillige Einhaltung",
+    "voluntary_1": "KI \"entscheidet\" sich für die Einhaltung von Regeln",
+    "voluntary_2": "Kann unter Kontextdruck abdriften",
+    "voluntary_3": "Mustererkennung kann Anweisungen außer Kraft setzen",
+    "voluntary_4": "Keine Überprüfung vor der Ausführung",
+    "architectural_title": "✓ Architektonische Durchsetzung",
+    "architectural_1": "Hook fängt vor der Ausführung ab",
+    "architectural_2": "Separater Prozess, kein Zugriff möglich",
+    "architectural_3": "Von der Laufzeit erzwungene Exit-Codes",
+    "architectural_4": "Prüfpfad für alle Entscheidungen"
+  },
+  "deployment": {
+    "heading": "Architektur des Einsatzes",
+    "tech_stack_title": "Technologie-Stapel",
+    "runtime": "Laufzeit:",
+    "runtime_value": "Node.js v20+",
+    "database": "Datenbank:",
+    "database_value": "MongoDB 7.0+",
+    "framework": "Rahmen:",
+    "framework_value": "Express.js",
+    "process": "Prozess:",
+    "process_value": "Systemd (empfohlen)",
+    "guide_title": "Einsatz in der Produktion",
+    "guide_desc": "Umfassender Leitfaden für die Bereitstellung, der die lokale Entwicklung, die Konfiguration des Produktionsservers, die Docker-Containerisierung, die Bereitstellungsmuster in der Cloud (AWS, GCP, Kubernetes), das Datenbankmanagement, die Überwachung und bewährte Sicherheitsverfahren abdeckt.",
+    "covered_title": "📦 Abgedeckt im Leitfaden:",
+    "covered_1": "Aufbau der lokalen Entwicklung",
+    "covered_2": "Konfiguration des Produktionsservers",
+    "covered_3": "Docker und Docker Compose",
+    "covered_4": "Cloud-Bereitstellung (AWS/GCP)",
+    "also_title": "🔧 Enthält auch:",
+    "also_1": "Kubernetes-Manifeste",
+    "also_2": "Sicherung und Migration von Datenbanken",
+    "also_3": "SSL/TLS-Konfiguration",
+    "also_4": "Überwachung und Protokollierung",
+    "download_guide": "Bereitstellungsleitfaden herunterladen (PDF)"
+  },
+  "services": {
+    "heading": "Zentrale Dienste",
+    "service_1_name": "BoundaryEnforcer",
+    "service_1_desc": "Setzt Tractatus 12.1-12.7 um: KI kann keine Wertentscheidungen ohne menschliche Zustimmung treffen.",
+    "service_1_boundaries": "Grenzen:",
+    "service_1_boundary_1": "WERTE (12.1) - Ethik, Datenschutz, Grundsätze",
+    "service_1_boundary_2": "INNOVATION (12.2) - Architektonische Entscheidungen",
+    "service_1_boundary_3": "WISDOM (12.3) - Strategisches Urteilsvermögen",
+    "service_1_boundary_4": "ZWECK (12.4) - Definition des Ziels",
+    "service_2_name": "InstructionPersistenceClassifier",
+    "service_2_desc": "Klassifizierung der Anweisungen nach Quadranten (STRATEGIC/OPERATIONAL/TACTICAL/SYSTEM) und Persistenzniveau (HIGH/MEDIUM/LOW).",
+    "service_2_classification": "Einstufung:",
+    "service_2_class_1": "Quadrant (STRATEGISCH/OPERATIONELL/TAKTISCH/SYSTEM)",
+    "service_2_class_2": "Persistenz (HOCH/MITTEL/NIEDRIG)",
+    "service_2_class_3": "Zeitlicher Geltungsbereich (PROJEKT/SITZUNG/AUFGABE)",
+    "service_2_class_4": "Deutlichkeitsgrad (0,0-1,0)",
+    "service_3_name": "CrossReferenceValidator",
+    "service_3_desc": "Validiert KI-Aktionen anhand gespeicherter Anweisungen, um zu verhindern, dass die Mustererkennung übergangen wird.",
+    "service_3_validation": "Validierung:",
+    "service_3_val_1": "Prüft die Aktion gegen HIGH-Persistenzanweisungen",
+    "service_3_val_2": "Erkennung von Konflikten (Muster vs. explizite Anweisung)",
+    "service_3_val_3": "Liefert bei Ablehnung korrekte Parameter",
+    "service_4_name": "ContextPressureMonitor",
+    "service_4_desc": "Überwacht die Token-Nutzung und den Kontextdruck und löst bei bestimmten Schwellenwerten Sicherheitsprotokolle aus.",
+    "service_4_levels": "Druckstufen:",
+    "service_4_level_1": "NORMAL (0-50%) - Voller Betrieb",
+    "service_4_level_2": "ELEVATED (50-75%) - Verstärkte Überprüfung",
+    "service_4_level_3": "HOCH (75-90%) - Reduzierung der Komplexität",
+    "service_4_level_4": "CRITICAL (90%+) - Übergabe vorschlagen",
+    "service_5_name": "Metakognitiver Verifizierer",
+    "service_5_desc": "Überprüft die Argumentation und das Vertrauen in die Aktion und verlangt eine Bestätigung für Aktionen mit geringem Vertrauen.",
+    "service_5_verification": "Verifizierung:",
+    "service_5_ver_1": "Konfidenzbewertung (0,0-1,0)",
+    "service_5_ver_2": "Selektiver Modus (nur HIGH Persistence)",
+    "service_5_ver_3": "Erfordert eine Bestätigung, wenn das Vertrauen < 0,7 ist",
+    "service_6_name": "PluralistischeBeratungOrchestrator",
+    "service_6_desc": "Leitung von Beratungen mit mehreren Interessengruppen, um die Pluralität der Werte bei Entscheidungen zu gewährleisten.",
+    "service_6_features": "Merkmale:",
+    "service_6_feature_1": "Verfolgung der Stakeholder-Perspektive",
+    "service_6_feature_2": "Erkennung von Wertkonflikten",
+    "service_6_feature_3": "Verwaltung von Beratungssitzungen",
+    "service_6_feature_4": "Vorrangige Speicherung",
+    "source_code_label": "📁 Quellcode",
+    "source_code_desc": "Code-Muster und Beispiele sind im GitHub-Repository verfügbar."
+  },
+  "api": {
+    "heading": "API-Referenz",
+    "boundary_method": "BoundaryEnforcer.checkBoundary()",
+    "boundary_keywords": "Schlüsselwörter entdeckt:",
+    "boundary_keywords_list": "wert, Prinzip, Ethik, Moral, Sollen, Sollen, Richtig, Falsch, Privatsphäre, Politik, Kompromiss, usw.",
+    "classifier_method": "InstructionPersistenceClassifier.classify()",
+    "classifier_quadrants": "Quadranten:",
+    "classifier_quadrants_list": "STRATEGISCH, OPERATIV, TAKTISCH, SYSTEM, LAGERUNG",
+    "classifier_persistence": "Beharrlichkeit:",
+    "classifier_persistence_desc": "HIGH (alle überschreiben), MEDIUM (session-scoped), LOW (kann ersetzt werden)",
+    "validator_method": "CrossReferenceValidator.validate()",
+    "monitor_method": "ContextPressureMonitor.analyzePressure()"
+  },
+  "examples": {
+    "heading": "Beispiele für die Integration",
+    "express_title": "Express-Middleware-Integration",
+    "validation_title": "Validierung von Anweisungen",
+    "mongodb_title": "MongoDB-Datenmodelle",
+    "governance_rule": "GovernanceRegel",
+    "audit_log": "AuditLog"
+  },
+  "patterns": {
+    "heading": "Integration von Mustern",
+    "intro": "Gemeinsame Architekturmuster für die Integration von Tractatus in bestehende Systeme.",
+    "middleware_title": "Middleware-Integration",
+    "middleware_desc": "Fügen Sie Governance-Prüfungen als Middleware in Ihre Anforderungspipeline ein. Geeignet für API-basierte KI-Systeme.",
+    "middleware_usecase": "Anwendungsfall:",
+    "middleware_usecase_value": "REST-APIs, Express.js-Anwendungen",
+    "event_title": "Ereignisgesteuerte Governance",
+    "event_desc": "Auslösen von Governance-Prüfungen über Ereignisse. Geeignet für asynchrone Workflows und Microservices.",
+    "event_usecase": "Anwendungsfall:",
+    "event_usecase_value": "Nachrichtenwarteschlangen, Ereignisbusse, asynchrone Verarbeitung",
+    "hook_title": "Pre-/Post-Action-Haken",
+    "hook_desc": "Validierung von Aktionen vor und nach der Ausführung. Aktuelles Produktionsmuster für Claude Code.",
+    "hook_usecase": "Anwendungsfall:",
+    "hook_usecase_value": "Einsatz von LLM-Werkzeugen, autonome Agenten",
+    "sidecar_title": "Sidecar Governance-Dienst",
+    "sidecar_desc": "Bereitstellung von Governance als separater Dienst. Geeignet für Multi-LLM- oder polyglotte Umgebungen.",
+    "sidecar_usecase": "Anwendungsfall:",
+    "sidecar_usecase_value": "Kubernetes, containerisierte Bereitstellungen"
+  },
+  "roadmap": {
+    "heading": "Entwicklungsfahrplan & Zusammenarbeit",
+    "intro": "Tractatus ist ein aktiver Forschungsrahmen. Wir begrüßen die Zusammenarbeit in vorrangigen Entwicklungsbereichen.",
+    "priority_title": "🚀 Vorrangige Bereiche für die Entwicklung",
+    "priority_desc": "Diese Initiativen bieten wichtige Möglichkeiten zur Verbesserung des Rahmens. Technische Mitarbeiter, Forscher und Organisationen sind aufgefordert, sich daran zu beteiligen.",
+    "multi_llm_icon": "🤖",
+    "multi_llm_title": "Multi-LLM-Unterstützung",
+    "multi_llm_status": "Status: Forschungsphase",
+    "multi_llm_desc": "Ausweitung der Verwaltung auf GPT-4, Gemini, Llama und lokale Modelle. Erfordert die Anpassung der Hakenarchitektur an verschiedene LLM-Schnittstellen.",
+    "multi_llm_challenges": "Technische Herausforderungen:",
+    "multi_llm_challenges_desc": "Anbieterspezifische Werkzeug-/Funktionsaufrufe, Ratenbegrenzung, Kontextfensterunterschiede",
+    "bindings_icon": "📚",
+    "bindings_title": "Sprachbindungen",
+    "bindings_status": "Status: Interesse der Gemeinschaft",
+    "bindings_desc": "Python-, Go- und Rust-Implementierungen für eine breitere Entwicklergemeinschaft. Die Kernlogik ist portabel, die MongoDB-Integration ist universell.",
+    "bindings_value": "Wert:",
+    "bindings_value_desc": "Ermöglicht polyglotte KI-Stacks, leistungskritische Anwendungen (Rust), Data-Science-Workflows (Python)",
+    "cloud_icon": "☁️",
+    "cloud_title": "Cloud-Native-Bereitstellung",
+    "cloud_status": "Status: Referenzarchitekturen werden benötigt",
+    "cloud_desc": "Terraform/Helm-Diagramme für AWS, Azure, GCP. Einschließlich verwalteter MongoDB (Atlas), automatischer Skalierung und Überwachungsintegration.",
+    "cloud_deliverables": "Ergebnisse:",
+    "cloud_deliverables_desc": "Referenz IaC-Vorlagen, Leitfäden zur Kostenoptimierung, Checkliste für die Sicherheitshärtung",
+    "integrations_icon": "🔗",
+    "integrations_title": "AI-Framework-Integration",
+    "integrations_status": "Status: Konzeptionell",
+    "integrations_desc": "Adapter für LangChain, Semantic Kernel, AutoGPT, und CrewAI. Ermöglicht Governance für bestehende Agenten-Frameworks.",
+    "integrations_approach": "Herangehensweise:",
+    "integrations_approach_desc": "Plugin/Middleware-Architektur, die Agentenaktionen mit Governance-Prüfungen umhüllt",
+    "performance_icon": "⚡",
+    "performance_title": "Leistung auf Unternehmensebene",
+    "performance_status": "Status: Validierung erforderlich",
+    "performance_desc": "Optimierung für 1000+ gleichzeitige KI-Agenten. Erfordert Caching-Strategien, Regelkompilierung und verteilte Audit-Protokollierung.",
+    "performance_target": "Metrisches Ziel:",
+    "performance_target_desc": "< 5 ms Governance-Overhead pro Entscheidung, 99,9 % Betriebszeit, horizontale Skalierbarkeit",
+    "extended_icon": "🛡️",
+    "extended_title": "Erweiterte Governance-Dienste",
+    "extended_status": "Status: Forschung",
+    "extended_desc": "Kostenüberwachung, Ratenbegrenzung, Erkennung von PII, Abwehr von Angriffen auf die Privatsphäre. Bereichsspezifische Dienste für regulierte Branchen.",
+    "extended_examples": "Beispiele:",
+    "extended_examples_desc": "FinancialComplianceService, HealthcarePrivacyService, CostBudgetEnforcer",
+    "involved_title": "Engagieren Sie sich",
+    "involved_desc": "Tractatus ist Apache 2.0 lizenzierte Forschung. Wir begrüßen Beiträge, Pilotimplementierungen und kollaborative Forschungspartnerschaften.",
+    "contributors_title": "👨‍💻 Technische Mitwirkende",
+    "contributors_desc": "Implementierung von Funktionen, Behebung von Fehlern, Verbesserung der Dokumentation",
+    "contributors_link": "→ Leitfaden für Beitragszahler",
+    "research_title": "🔬 Forschungspartner",
+    "research_desc": "Validierungsstudien, akademische Zusammenarbeit, Fallstudien",
+    "research_email": "→ research@agenticgovernance.digital",
+    "pilots_title": "🏢 Organisation Lotsen",
+    "pilots_desc": "Einsatz in der Produktion, Unternehmensanforderungen, Feedback-Schleifen",
+    "pilots_link": "→ Fallstudie einreichen",
+    "why_collab": "Warum zusammenarbeiten?",
+    "why_collab_desc": "Tractatus adressiert echte Lücken in der KI-Sicherheit. Frühe Anwender gestalten die Entwicklung des Rahmens und erwerben Fachkenntnisse in der strukturellen KI-Governance - eine differenzierende Fähigkeit, wenn die regulatorischen Anforderungen reifen."
   }
 }

public/locales/en/implementer.json

@@ -1,85 +1,319 @@
 {
   "page": {
-    "title": "For Implementers | Tractatus AI Safety Framework",
-    "description": "Integrate Tractatus framework into your AI systems: practical guides, code examples, and step-by-step implementation for production safety."
+    "title": "Framework Implementation Guide | Tractatus",
+    "description": "Technical documentation for integrating Tractatus framework: architecture, API reference, and code examples from production implementation."
   },
-  "header": {
-    "title": "Reference Implementation",
-    "subtitle_line1": "AI Safety Patterns",
-    "description": "Integrate Tractatus framework into your AI systems with practical guides, code examples, and patterns demonstrated in 6-month development project.",
-    "quick_start_btn": "Quick Start Guide",
-    "view_docs_btn": "View Documentation"
+  "ui": {
+    "breadcrumb_home": "Home",
+    "breadcrumb_implementer": "Implementation Guide",
+    "skip_to_content": "Skip to main content"
   },
-  "development_context": {
-    "title": "Development Context",
-    "description": "Framework developed over six months in single-project context. Code examples below show reference implementation architecture. The npm package @tractatus/framework represents planned API design, not published package. Actual implementation requires adapting patterns from this project's source code.",
-    "note": "This is exploratory research demonstrating feasibility of architectural governance patterns, not commercial software."
+  "hero": {
+    "title": "External Governance Services for AI Systems",
+    "subtitle": "Six architectural services addressing pattern override and decision traceability in agentic systems. Development framework for instruction persistence, boundary enforcement, and audit logging.",
+    "value_prop_1_icon": "🏗️",
+    "value_prop_1_title": "Architectural Separation",
+    "value_prop_1_desc": "Governance runs external to AI model",
+    "value_prop_2_icon": "💾",
+    "value_prop_2_title": "Instruction Persistence",
+    "value_prop_2_desc": "Validates instructions across context",
+    "value_prop_3_icon": "📋",
+    "value_prop_3_title": "Audit Trail by Design",
+    "value_prop_3_desc": "MongoDB logs with service attribution"
   },
-  "deployment_guide": {
-    "badge": "DOCUMENTATION",
-    "title": "Deployment Architecture Guide",
-    "description": "Comprehensive conceptual guide to deploying Tractatus-based systems. Understand architecture patterns, security best practices, and integration strategies for research and educational purposes.",
-    "view_guide_btn": "View Deployment Guide",
-    "support_note": "For production implementation support, contact research@agenticgovernance.digital"
+  "nav": {
+    "quick_links_label": "Page sections",
+    "how_it_works": "How It Works",
+    "architecture": "Architecture",
+    "hooks": "Hook Architecture",
+    "deployment": "Deployment",
+    "services": "Services",
+    "api": "API Reference",
+    "patterns": "Integration Patterns",
+    "roadmap": "Roadmap"
+  },
+  "how_it_works": {
+    "heading": "How It Works",
+    "problem_title": "Pattern Override Challenge",
+    "problem_desc": "AI systems operating across extended interactions may not maintain instruction consistency as context evolves. Instructions given early can be deprioritized or reinterpreted.",
+    "approach_title": "External Architecture Approach",
+    "approach_desc": "Tractatus services run external to the AI model, providing boundary validation, instruction classification, and audit logging through architectural separation.",
+    "diagram_title": "Request Flow with Governance",
+    "diagram_desc": "Example: AI decision flow with boundary enforcement—from user request through governance validation to human approval.",
+    "diagram_alt": "Request Flow Sequence: How AI decisions are governed",
+    "download_svg": "Download SVG"
   },
   "architecture": {
     "heading": "System Architecture",
-    "subheading": "Understanding how Tractatus integrates with Claude Code to provide robust AI governance",
+    "six_services_title": "Six Core Services",
+    "service_1": "BoundaryEnforcer (Tractatus 12.1-12.7)",
+    "service_2": "InstructionPersistenceClassifier",
+    "service_3": "CrossReferenceValidator",
+    "service_4": "ContextPressureMonitor",
+    "service_5": "MetacognitiveVerifier",
+    "service_6": "PluralisticDeliberationOrchestrator",
+    "main_flow_title": "Service Interaction Flow",
+    "main_flow_alt": "Tractatus Framework Architecture: Shows how 6 governance services interact in sequence",
+    "trigger_tree_title": "Service Trigger Conditions",
+    "trigger_tree_alt": "Service Trigger Decision Tree: When each framework service activates",
+    "system_arch_title": "System Architecture",
+    "system_arch_desc": "High-level overview showing how the 6 governance services integrate with your application and data layer.",
+    "system_arch_alt": "Tractatus System Architecture: Component interaction and data flow",
     "download_svg": "Download SVG",
-    "download_png": "Download PNG (High-Res)",
-    "download_pdf": "Technical Documentation PDF",
-    "layer_4_title": "API & Web Interface",
-    "layer_3_title": "Tractatus Governance",
-    "layer_2_title": "MongoDB Persistence",
-    "layer_1_title": "Claude Code Runtime",
-    "integration_points_title": "Key Integration Points",
-    "integration_1_title": "Pre-Action Checks",
-    "integration_1_desc": "All actions validated against governance rules before execution",
-    "integration_2_title": "Instruction Persistence",
-    "integration_2_desc": "User instructions classified and stored for cross-reference validation",
-    "integration_3_title": "Comprehensive Audit Trail",
-    "integration_3_desc": "Every governance action logged for compliance and analysis"
+    "download_svg_aria": "Download architecture main flow diagram as SVG",
+    "download_trigger_svg_aria": "Download service trigger decision tree as SVG",
+    "download_system_svg_aria": "Download system architecture diagram as SVG"
   },
-  "integration_approaches": {
-    "heading": "Integration Approaches",
-    "full_stack_title": "Full Stack",
-    "full_stack_desc": "Complete framework integration for new AI-powered applications. All six services active with persistent instruction storage.",
-    "full_stack_note": "Best for: New projects, greenfield AI applications",
-    "middleware_title": "Middleware Layer",
-    "middleware_desc": "Add Tractatus validation as middleware in existing AI pipelines. Non-invasive integration with gradual rollout support.",
-    "middleware_note": "Best for: Existing production AI systems",
-    "selective_title": "Selective Components",
-    "selective_desc": "Use individual Tractatus services à la carte. Mix and match components based on your specific safety requirements.",
-    "selective_note": "Best for: Specific safety requirements"
+  "hooks": {
+    "badge": "ARCHITECTURAL ENFORCEMENT",
+    "heading": "Hook Architecture: The Credibility Layer",
+    "subtitle": "Tractatus governance is not voluntary compliance. PreToolUse hooks enforce boundaries before AI actions execute, making circumvention architecturally impossible.",
+    "problem_title": "The Voluntary Compliance Problem",
+    "problem_desc_1": "Traditional AI safety relies on the AI system \"choosing\" to follow rules embedded in training data or system prompts. These approaches assume the AI will maintain alignment regardless of context pressure or capability.",
+    "problem_desc_2": "Tractatus addresses this through architectural enforcement: governance runs in a separate process that the AI cannot access, modify, or bypass.",
+    "flow_title": "PreToolUse Hook Execution Flow",
+    "flow_desc": "Before any file edit, write, or bash command executes, the hook intercepts the action and runs validation checks. Only if ALL checks pass (exit code 0) does the AI action proceed.",
+    "flow_alt": "Hook Architecture: PreToolUse intercept flow showing validation and hard blocks",
+    "examples_title": "Real Enforcement Examples",
+    "example_1_icon": "🚫",
+    "example_1_title": "GitHub URL Protection (inst_084)",
+    "example_1_desc": "AI attempted to change GitHub repository URL from tractatus-framework (public) to tractatus (private).",
+    "example_1_blocked": "BLOCKED:",
+    "example_1_reason": "Repository URL modification detected",
+    "example_1_detail": "Reason: Would expose private repo structure",
+    "example_1_hook": "Hook: validate-file-edit.js line 448-505",
+    "example_2_icon": "🚫",
+    "example_2_title": "CSP Violation (inst_008)",
+    "example_2_desc": "AI attempted to add inline style attribute to HTML element.",
+    "example_2_blocked": "BLOCKED:",
+    "example_2_reason": "Inline style detected",
+    "example_2_pattern": "Pattern:",
+    "example_2_hook": "Hook: validate-file-write.js line 68-149",
+    "example_3_icon": "🚫",
+    "example_3_title": "Governance File Protection (inst_027)",
+    "example_3_desc": "AI attempted direct edit of instruction-history.json.",
+    "example_3_blocked": "BLOCKED:",
+    "example_3_reason": "inst_027 hard block",
+    "example_3_use": "Use: scripts/add-instruction.js instead",
+    "example_3_hook": "Hook: framework-audit-hook.js line 204-209",
+    "example_4_icon": "⚠",
+    "example_4_title": "Human Approval Required (BoundaryEnforcer)",
+    "example_4_desc": "AI action touches values-sensitive file (privacy policy).",
+    "example_4_status": "ASK HUMAN:",
+    "example_4_reason": "Values decision detected",
+    "example_4_requires": "Requires: Explicit human approval",
+    "example_4_hook": "Hook: validate-file-write.js line 239-262",
+    "tech_impl_title": "Technical Implementation",
+    "process_sep_icon": "🔒",
+    "process_sep_title": "Process Separation",
+    "process_sep_desc": "Hooks execute in a separate Node.js process (child_process.spawn) with their own memory space. The AI agent cannot access, modify, or terminate the validation process.",
+    "exit_code_icon": "⚙️",
+    "exit_code_title": "Exit Code Enforcement",
+    "exit_code_desc": "Hook validators return exit codes that Claude Code's architecture enforces:",
+    "exit_code_0": "0 = PASS → Tool executes",
+    "exit_code_2": "2 = HARD BLOCK → Tool execution halted, error shown to user",
+    "audit_icon": "📊",
+    "audit_title": "Audit Trail",
+    "audit_desc": "Every hook execution is logged to .claude/metrics/hooks-metrics.json with timestamp, file, result, and reason. Blocks are separately tracked for analysis.",
+    "why_matters_title": "Why Architectural Enforcement Matters",
+    "why_matters_desc": "This is the fundamental difference between Tractatus and traditional AI safety approaches:",
+    "voluntary_title": "❌ Voluntary Compliance",
+    "voluntary_1": "AI \"chooses\" to follow rules",
+    "voluntary_2": "Can drift under context pressure",
+    "voluntary_3": "Pattern recognition may override instructions",
+    "voluntary_4": "No verification before execution",
+    "architectural_title": "✓ Architectural Enforcement",
+    "architectural_1": "Hook intercepts before execution",
+    "architectural_2": "Separate process, cannot be accessed",
+    "architectural_3": "Exit codes enforced by runtime",
+    "architectural_4": "Audit trail of all decisions"
   },
-  "quick_start": {
-    "heading": "Quick Start Guide",
-    "disclaimer_title": "Note: Reference Implementation",
-    "disclaimer_text": "The code examples below show conceptual API design. The npm package @tractatus/framework is not yet published. To implement these patterns, adapt the governance services from this project's source code.",
-    "step_1_title": "Installation",
-    "step_2_title": "Initialize Services",
-    "step_3_title": "Classify Instructions",
-    "step_4_title": "Validate Actions",
-    "step_5_title": "Enforce Boundaries"
+  "deployment": {
+    "heading": "Deployment Architecture",
+    "tech_stack_title": "Technology Stack",
+    "runtime": "Runtime:",
+    "runtime_value": "Node.js v20+",
+    "database": "Database:",
+    "database_value": "MongoDB 7.0+",
+    "framework": "Framework:",
+    "framework_value": "Express.js",
+    "process": "Process:",
+    "process_value": "Systemd (recommended)",
+    "guide_title": "Production Deployment",
+    "guide_desc": "Comprehensive deployment guide covering local development, production server configuration, Docker containerization, cloud deployment patterns (AWS, GCP, Kubernetes), database management, monitoring, and security best practices.",
+    "covered_title": "📦 Covered in Guide:",
+    "covered_1": "Local development setup",
+    "covered_2": "Production server configuration",
+    "covered_3": "Docker and Docker Compose",
+    "covered_4": "Cloud deployment (AWS/GCP)",
+    "also_title": "🔧 Also Includes:",
+    "also_1": "Kubernetes manifests",
+    "also_2": "Database backup and migration",
+    "also_3": "SSL/TLS configuration",
+    "also_4": "Monitoring and logging",
+    "download_guide": "Download Deployment Guide (PDF)"
   },
-  "integration_patterns": {
+  "services": {
+    "heading": "Core Services",
+    "service_1_name": "BoundaryEnforcer",
+    "service_1_desc": "Implements Tractatus 12.1-12.7: AI cannot make values decisions without human approval.",
+    "service_1_boundaries": "Boundaries:",
+    "service_1_boundary_1": "VALUES (12.1) - Ethics, privacy, principles",
+    "service_1_boundary_2": "INNOVATION (12.2) - Architectural decisions",
+    "service_1_boundary_3": "WISDOM (12.3) - Strategic judgment",
+    "service_1_boundary_4": "PURPOSE (12.4) - Goal definition",
+    "service_2_name": "InstructionPersistenceClassifier",
+    "service_2_desc": "Classifies instructions by quadrant (STRATEGIC/OPERATIONAL/TACTICAL/SYSTEM) and persistence level (HIGH/MEDIUM/LOW).",
+    "service_2_classification": "Classification:",
+    "service_2_class_1": "Quadrant (STRATEGIC/OPERATIONAL/TACTICAL/SYSTEM)",
+    "service_2_class_2": "Persistence (HIGH/MEDIUM/LOW)",
+    "service_2_class_3": "Temporal scope (PROJECT/SESSION/TASK)",
+    "service_2_class_4": "Explicitness score (0.0-1.0)",
+    "service_3_name": "CrossReferenceValidator",
+    "service_3_desc": "Validates AI actions against stored instructions to prevent pattern recognition overrides.",
+    "service_3_validation": "Validation:",
+    "service_3_val_1": "Checks action against HIGH persistence instructions",
+    "service_3_val_2": "Detects conflicts (pattern vs explicit instruction)",
+    "service_3_val_3": "Provides correct parameters when rejected",
+    "service_4_name": "ContextPressureMonitor",
+    "service_4_desc": "Monitors token usage and context pressure, triggering safety protocols at thresholds.",
+    "service_4_levels": "Pressure Levels:",
+    "service_4_level_1": "NORMAL (0-50%) - Full operation",
+    "service_4_level_2": "ELEVATED (50-75%) - Increase verification",
+    "service_4_level_3": "HIGH (75-90%) - Reduce complexity",
+    "service_4_level_4": "CRITICAL (90%+) - Suggest handoff",
+    "service_5_name": "MetacognitiveVerifier",
+    "service_5_desc": "Verifies action reasoning and confidence, requiring confirmation for low-confidence actions.",
+    "service_5_verification": "Verification:",
+    "service_5_ver_1": "Confidence scoring (0.0-1.0)",
+    "service_5_ver_2": "Selective mode (HIGH persistence only)",
+    "service_5_ver_3": "Requires confirmation if confidence < 0.7",
+    "service_6_name": "PluralisticDeliberationOrchestrator",
+    "service_6_desc": "Manages multi-stakeholder deliberation ensuring value pluralism in decisions.",
+    "service_6_features": "Features:",
+    "service_6_feature_1": "Stakeholder perspective tracking",
+    "service_6_feature_2": "Value conflict detection",
+    "service_6_feature_3": "Deliberation session management",
+    "service_6_feature_4": "Precedent storage",
+    "source_code_label": "📁 Source Code",
+    "source_code_desc": "Code patterns and examples are available in the GitHub repository."
+  },
+  "api": {
+    "heading": "API Reference",
+    "boundary_method": "BoundaryEnforcer.checkBoundary()",
+    "boundary_keywords": "Keywords detected:",
+    "boundary_keywords_list": "value, principle, ethic, moral, should, ought, right, wrong, privacy, policy, trade-off, etc.",
+    "classifier_method": "InstructionPersistenceClassifier.classify()",
+    "classifier_quadrants": "Quadrants:",
+    "classifier_quadrants_list": "STRATEGIC, OPERATIONAL, TACTICAL, SYSTEM, STORAGE",
+    "classifier_persistence": "Persistence:",
+    "classifier_persistence_desc": "HIGH (override all), MEDIUM (session-scoped), LOW (can be superseded)",
+    "validator_method": "CrossReferenceValidator.validate()",
+    "monitor_method": "ContextPressureMonitor.analyzePressure()"
+  },
+  "examples": {
+    "heading": "Integration Examples",
+    "express_title": "Express Middleware Integration",
+    "validation_title": "Instruction Validation",
+    "mongodb_title": "MongoDB Data Models",
+    "governance_rule": "GovernanceRule",
+    "audit_log": "AuditLog"
+  },
+  "patterns": {
     "heading": "Integration Patterns",
-    "express_middleware": "Express Middleware",
-    "content_moderation": "Content Moderation",
-    "pressure_monitoring": "Pressure Monitoring",
-    "custom_classification": "Custom Classification"
+    "intro": "Common architectural patterns for integrating Tractatus into existing systems.",
+    "middleware_title": "Middleware Integration",
+    "middleware_desc": "Insert governance checks as middleware in your request pipeline. Suitable for API-based AI systems.",
+    "middleware_usecase": "Use Case:",
+    "middleware_usecase_value": "REST APIs, Express.js applications",
+    "event_title": "Event-Driven Governance",
+    "event_desc": "Trigger governance checks via events. Suitable for async workflows and microservices.",
+    "event_usecase": "Use Case:",
+    "event_usecase_value": "Message queues, event buses, async processing",
+    "hook_title": "Pre/Post-Action Hooks",
+    "hook_desc": "Validate actions before and after execution. Current production pattern for Claude Code.",
+    "hook_usecase": "Use Case:",
+    "hook_usecase_value": "LLM tool use, autonomous agents",
+    "sidecar_title": "Sidecar Governance Service",
+    "sidecar_desc": "Deploy governance as a separate service. Suitable for multi-LLM or polyglot environments.",
+    "sidecar_usecase": "Use Case:",
+    "sidecar_usecase_value": "Kubernetes, containerized deployments"
+  },
+  "roadmap": {
+    "heading": "Development Roadmap & Collaboration",
+    "intro": "Tractatus is an active research framework. We welcome collaboration on priority development areas.",
+    "priority_title": "🚀 Priority Areas for Development",
+    "priority_desc": "These initiatives represent high-impact opportunities for framework enhancement. Technical contributors, researchers, and organizations are encouraged to engage.",
+    "multi_llm_icon": "🤖",
+    "multi_llm_title": "Multi-LLM Support",
+    "multi_llm_status": "Status: Research Phase",
+    "multi_llm_desc": "Extend governance to GPT-4, Gemini, Llama, and local models. Requires adapting hook architecture to different LLM interfaces.",
+    "multi_llm_challenges": "Technical Challenges:",
+    "multi_llm_challenges_desc": "Provider-specific tool/function calling, rate limiting, context window differences",
+    "bindings_icon": "📚",
+    "bindings_title": "Language Bindings",
+    "bindings_status": "Status: Community Interest",
+    "bindings_desc": "Python, Go, and Rust implementations to serve broader developer communities. Core logic is portable; MongoDB integration is universal.",
+    "bindings_value": "Value:",
+    "bindings_value_desc": "Enable polyglot AI stacks, performance-critical applications (Rust), data science workflows (Python)",
+    "cloud_icon": "☁️",
+    "cloud_title": "Cloud-Native Deployment",
+    "cloud_status": "Status: Reference Architectures Needed",
+    "cloud_desc": "Terraform/Helm charts for AWS, Azure, GCP. Include managed MongoDB (Atlas), auto-scaling, and monitoring integration.",
+    "cloud_deliverables": "Deliverables:",
+    "cloud_deliverables_desc": "Reference IaC templates, cost optimization guides, security hardening checklist",
+    "integrations_icon": "🔗",
+    "integrations_title": "AI Framework Integration",
+    "integrations_status": "Status: Conceptual",
+    "integrations_desc": "Adapters for LangChain, Semantic Kernel, AutoGPT, and CrewAI. Enable governance for existing agent frameworks.",
+    "integrations_approach": "Approach:",
+    "integrations_approach_desc": "Plugin/middleware architecture that wraps agent actions with governance checks",
+    "performance_icon": "⚡",
+    "performance_title": "Enterprise-Scale Performance",
+    "performance_status": "Status: Validation Needed",
+    "performance_desc": "Optimize for 1000+ concurrent AI agents. Requires caching strategies, rule compilation, and distributed audit logging.",
+    "performance_target": "Metrics Target:",
+    "performance_target_desc": "< 5ms governance overhead per decision, 99.9% uptime, horizontal scalability",
+    "extended_icon": "🛡️",
+    "extended_title": "Extended Governance Services",
+    "extended_status": "Status: Research",
+    "extended_desc": "Cost monitoring, rate limiting, PII detection, adversarial prompt defense. Domain-specific services for regulated industries.",
+    "extended_examples": "Examples:",
+    "extended_examples_desc": "FinancialComplianceService, HealthcarePrivacyService, CostBudgetEnforcer",
+    "involved_title": "Get Involved",
+    "involved_desc": "Tractatus is Apache 2.0 licensed research. We welcome contributions, pilot implementations, and collaborative research partnerships.",
+    "contributors_title": "👨‍💻 Technical Contributors",
+    "contributors_desc": "Implement features, fix bugs, improve documentation",
+    "contributors_link": "→ Contributing Guide",
+    "research_title": "🔬 Research Partners",
+    "research_desc": "Validation studies, academic collaboration, case studies",
+    "research_email": "→ research@agenticgovernance.digital",
+    "pilots_title": "🏢 Organization Pilots",
+    "pilots_desc": "Production deployments, enterprise requirements, feedback loops",
+    "pilots_link": "→ Submit Case Study",
+    "why_collab": "Why Collaborate?",
+    "why_collab_desc": "Tractatus addresses real gaps in AI safety. Early adopters shape the framework's evolution and gain expertise in structural AI governance—a differentiating capability as regulatory requirements mature."
   },
   "resources": {
-    "heading": "Implementation Resources",
-    "technical_docs_title": "Technical Documentation",
-    "examples_title": "Examples",
+    "heading": "Resources",
+    "docs_title": "Documentation",
+    "docs_github": "→ GitHub Repository",
+    "docs_full": "→ Full Documentation",
+    "docs_demos": "→ Live Demos",
+    "reference_title": "Reference Implementation",
+    "reference_desc": "This website (agenticgovernance.digital) runs on Tractatus governance.",
+    "reference_services": "Services:",
+    "reference_services_value": "22 governance components",
+    "reference_models": "Data Models:",
+    "reference_models_value": "29 MongoDB schemas",
+    "reference_tests": "Test Coverage:",
+    "reference_tests_value": "35 test suites",
+    "reference_repo": "→ Collaboration Repository",
     "support_title": "Support",
-    "support_desc": "Get help with implementation, integration, and troubleshooting."
-  },
-  "cta": {
-    "title": "Exploring Implementation?",
-    "description": "Explore architectural patterns for AI safety demonstrated in single-project validation.",
-    "view_docs_btn": "View Full Documentation",
-    "research_btn": "Research Background →"
+    "support_desc": "Questions about implementation or integration?",
+    "support_issues": "→ GitHub Issues",
+    "support_discussions": "→ GitHub Discussions",
+    "support_email": "→ research@agenticgovernance.digital",
+    "support_faq": "→ Frequently Asked Questions"
   }
 }

public/locales/fr/implementer.json

@@ -38,7 +38,24 @@
     "integration_2_title": "Persistance des Instructions",
     "integration_2_desc": "Instructions utilisateur classifiées et stockées pour la validation par références croisées",
     "integration_3_title": "Piste d'Audit Complète",
-    "integration_3_desc": "Chaque action de gouvernance enregistrée pour la conformité et l'analyse"
+    "integration_3_desc": "Chaque action de gouvernance enregistrée pour la conformité et l'analyse",
+    "six_services_title": "Six services de base",
+    "service_1": "Renforcer les frontières (Tractatus 12.1-12.7)",
+    "service_2": "InstructionPersistenceClassifier",
+    "service_3": "Valideur de référence croisée",
+    "service_4": "ContextPressureMonitor",
+    "service_5": "Vérificateur métacognitif",
+    "service_6": "Délibération pluralisteOrchestrateur",
+    "main_flow_title": "Flux d'interactions de services",
+    "main_flow_alt": "Architecture du cadre Tractatus : Montre comment les 6 services de gouvernance interagissent en séquence",
+    "trigger_tree_title": "Conditions de déclenchement du service",
+    "trigger_tree_alt": "Arbre de décision des déclencheurs de service : Lorsque chaque service-cadre est activé",
+    "system_arch_title": "Architecture du système",
+    "system_arch_desc": "Aperçu de haut niveau montrant comment les 6 services de gouvernance s'intègrent à votre application et à votre couche de données.",
+    "system_arch_alt": "Tractatus Architecture du système : Interaction des composants et flux de données",
+    "download_svg_aria": "Télécharger le schéma principal de l'architecture au format SVG",
+    "download_trigger_svg_aria": "Télécharger l'arbre de décision du déclencheur de service sous forme de SVG",
+    "download_system_svg_aria": "Télécharger le diagramme d'architecture du système au format SVG"
   },
   "integration_approaches": {
     "heading": "Approches d'Intégration",
@@ -74,12 +91,299 @@
     "technical_docs_title": "Documentation Technique",
     "examples_title": "Exemples",
     "support_title": "Support",
-    "support_desc": "Obtenez de l'aide pour l'implémentation, l'intégration et le dépannage."
+    "support_desc": "Obtenez de l'aide pour l'implémentation, l'intégration et le dépannage.",
+    "docs_title": "Documentation",
+    "docs_github": "→ Dépôt GitHub",
+    "docs_full": "→ Documentation complète",
+    "docs_demos": "→ Démonstrations en direct",
+    "reference_title": "Mise en œuvre de référence",
+    "reference_desc": "Ce site web (agenticgovernance.digital) fonctionne sur Tractatus governance.",
+    "reference_services": "Services :",
+    "reference_services_value": "22 composantes de la gouvernance",
+    "reference_models": "Modèles de données :",
+    "reference_models_value": "29 Schémas MongoDB",
+    "reference_tests": "Couverture des tests :",
+    "reference_tests_value": "35 suites de tests",
+    "reference_repo": "→ Référentiel de collaboration",
+    "support_issues": "→ GitHub Issues",
+    "support_discussions": "→ Discussions sur GitHub",
+    "support_email": "→ research@agenticgovernance.digital",
+    "support_faq": "→ Questions fréquemment posées"
   },
   "cta": {
     "title": "Explorer l'Implémentation ?",
     "description": "Explorez les modèles architecturaux pour la sécurité de l'IA démontrés dans une validation de projet unique.",
     "view_docs_btn": "Voir la Documentation Complète",
     "research_btn": "Contexte de Recherche →"
+  },
+  "ui": {
+    "breadcrumb_home": "Accueil",
+    "breadcrumb_implementer": "Guide de mise en œuvre",
+    "skip_to_content": "Skip to main content"
+  },
+  "hero": {
+    "title": "Services de gouvernance externe pour les systèmes d'IA",
+    "subtitle": "Six services architecturaux traitant de l'annulation des modèles et de la traçabilité des décisions dans les systèmes agentiques. Cadre de développement pour la persistance des instructions, l'application des limites et l'enregistrement des audits.",
+    "value_prop_1_icon": "🏗️",
+    "value_prop_1_title": "Séparation architecturale",
+    "value_prop_1_desc": "La gouvernance est externe au modèle d'IA",
+    "value_prop_2_icon": "💾",
+    "value_prop_2_title": "Persistance de l'enseignement",
+    "value_prop_2_desc": "Valide les instructions en fonction du contexte",
+    "value_prop_3_icon": "📋",
+    "value_prop_3_title": "Piste d'audit dès la conception",
+    "value_prop_3_desc": "Journaux MongoDB avec attribution de service"
+  },
+  "nav": {
+    "quick_links_label": "Rubriques de la page",
+    "how_it_works": "Comment ça marche",
+    "architecture": "Architecture",
+    "hooks": "Hook Architecture",
+    "deployment": "Déploiement",
+    "services": "Services",
+    "api": "Référence API",
+    "patterns": "Modèles d'intégration",
+    "roadmap": "Feuille de route"
+  },
+  "how_it_works": {
+    "heading": "Comment ça marche",
+    "problem_title": "Défi de l'annulation du motif",
+    "problem_desc": "Les systèmes d'IA fonctionnant dans le cadre d'interactions prolongées peuvent ne pas maintenir la cohérence des instructions au fur et à mesure que le contexte évolue. Les instructions données tôt peuvent être dépourvues de priorité ou réinterprétées.",
+    "approach_title": "Approche de l'architecture externe",
+    "approach_desc": "Les services Tractatus fonctionnent en dehors du modèle d'IA et assurent la validation des limites, la classification des instructions et l'enregistrement des audits par le biais d'une séparation architecturale.",
+    "diagram_title": "Flux de demandes avec gouvernance",
+    "diagram_desc": "Exemple : Flux décisionnel d'IA avec application des limites - de la demande de l'utilisateur à l'approbation humaine, en passant par la validation de la gouvernance.",
+    "diagram_alt": "Séquence de flux de demandes : Comment les décisions en matière d'IA sont régies",
+    "download_svg": "Télécharger le SVG"
+  },
+  "hooks": {
+    "badge": "APPLICATION DES RÈGLES ARCHITECTURALES",
+    "heading": "L'architecture du crochet : La couche de crédibilité",
+    "subtitle": "La gouvernance du Tractatus n'est pas une conformité volontaire. Les crochets PreToolUse imposent des limites avant que les actions de l'IA ne soient exécutées, ce qui rend tout contournement impossible sur le plan architectural.",
+    "problem_title": "Le problème de la conformité volontaire",
+    "problem_desc_1": "La sécurité traditionnelle de l'IA repose sur le fait que le système d'IA \"choisit\" de suivre les règles intégrées dans les données de formation ou les invites du système. Ces approches supposent que l'IA maintiendra l'alignement indépendamment de la pression du contexte ou de la capacité.",
+    "problem_desc_2": "Le Tractatus aborde cette question par le biais de l'application architecturale : la gouvernance s'exécute dans un processus distinct auquel l'IA ne peut accéder, qu'elle ne peut modifier ou contourner.",
+    "flow_title": "Flux d'exécution du crochet PreToolUse",
+    "flow_desc": "Avant toute modification de fichier, écriture ou commande bash, le crochet intercepte l'action et effectue des contrôles de validation. Ce n'est que si TOUS les contrôles sont réussis (code de sortie 0) que l'action AI est exécutée.",
+    "flow_alt": "Architecture du crochet : Flux d'interception de PreToolUse montrant la validation et les blocs durs",
+    "examples_title": "Exemples réels d'application de la loi",
+    "example_1_icon": "🚫",
+    "example_1_title": "Protection des URL de GitHub (inst_084)",
+    "example_1_desc": "AI a tenté de changer l'URL du dépôt GitHub de tractatus-framework (public) à tractatus (privé).",
+    "example_1_blocked": "BLOCKED :",
+    "example_1_reason": "Modification de l'URL du référentiel détectée",
+    "example_1_detail": "Raison : Exposerait la structure privée du repo",
+    "example_1_hook": "Accroche : validate-file-edit.js ligne 448-505",
+    "example_2_icon": "🚫",
+    "example_2_title": "Violation de la CSP (inst_008)",
+    "example_2_desc": "AI a tenté d'ajouter un attribut de style en ligne à un élément HTML.",
+    "example_2_blocked": "BLOCKED :",
+    "example_2_reason": "Style en ligne détecté",
+    "example_2_pattern": "Modèle :",
+    "example_2_hook": "Accroche : validate-file-write.js ligne 68-149",
+    "example_3_icon": "🚫",
+    "example_3_title": "Protection des fichiers de gouvernance (inst_027)",
+    "example_3_desc": "AI a tenté d'éditer directement le fichier instruction-history.json.",
+    "example_3_blocked": "BLOCKED :",
+    "example_3_reason": "inst_027 bloc dur",
+    "example_3_use": "Utilisez plutôt : scripts/add-instruction.js",
+    "example_3_hook": "Hook : framework-audit-hook.js ligne 204-209",
+    "example_4_icon": "⚠",
+    "example_4_title": "Approbation humaine requise (BoundaryEnforcer)",
+    "example_4_desc": "L'action de l'IA touche un fichier sensible aux valeurs (politique de confidentialité).",
+    "example_4_status": "DEMANDEZ À HUMAN :",
+    "example_4_reason": "Décision sur les valeurs détectées",
+    "example_4_requires": "Nécessite : Approbation explicite de l'homme",
+    "example_4_hook": "Accroche : validate-file-write.js ligne 239-262",
+    "tech_impl_title": "Mise en œuvre technique",
+    "process_sep_icon": "🔒",
+    "process_sep_title": "Séparation des processus",
+    "process_sep_desc": "Les crochets s'exécutent dans un processus Node.js distinct (child_process.spawn) disposant de son propre espace mémoire. L'agent d'intelligence artificielle ne peut pas accéder au processus de validation, le modifier ou y mettre fin.",
+    "exit_code_icon": "⚙️",
+    "exit_code_title": "Application du code de sortie",
+    "exit_code_desc": "Les validateurs de crochets renvoient des codes de sortie que l'architecture de Claude Code met en œuvre :",
+    "exit_code_0": "0 = PASS → L'outil s'exécute",
+    "exit_code_2": "2 = BLOCAGE DUR → Arrêt de l'exécution de l'outil, affichage de l'erreur à l'utilisateur",
+    "audit_icon": "📊",
+    "audit_title": "Piste d'audit",
+    "audit_desc": "Chaque exécution de crochet est enregistrée dans le fichier .claude/metrics/hooks-metrics.json avec l'horodatage, le fichier, le résultat et la raison. Les blocs sont suivis séparément à des fins d'analyse.",
+    "why_matters_title": "L'importance de l'application des règles architecturales",
+    "why_matters_desc": "C'est la différence fondamentale entre le Tractatus et les approches traditionnelles de la sécurité de l'IA :",
+    "voluntary_title": "❌ Conformité volontaire",
+    "voluntary_1": "L'IA \"choisit\" de suivre les règles",
+    "voluntary_2": "Peut dériver sous la pression du contexte",
+    "voluntary_3": "La reconnaissance des formes peut annuler les instructions",
+    "voluntary_4": "Pas de vérification avant l'exécution",
+    "architectural_title": "✓ Application des règles architecturales",
+    "architectural_1": "Le crochet intercepte avant l'exécution",
+    "architectural_2": "Processus séparé, non accessible",
+    "architectural_3": "Codes de sortie appliqués par le système d'exécution",
+    "architectural_4": "Piste d'audit de toutes les décisions"
+  },
+  "deployment": {
+    "heading": "Architecture de déploiement",
+    "tech_stack_title": "Pile technologique",
+    "runtime": "Durée d'exécution :",
+    "runtime_value": "Node.js v20+",
+    "database": "Base de données :",
+    "database_value": "MongoDB 7.0+",
+    "framework": "Le cadre :",
+    "framework_value": "Express.js",
+    "process": "Processus :",
+    "process_value": "Systemd (recommandé)",
+    "guide_title": "Déploiement de la production",
+    "guide_desc": "Guide de déploiement complet couvrant le développement local, la configuration des serveurs de production, la conteneurisation Docker, les modèles de déploiement dans le cloud (AWS, GCP, Kubernetes), la gestion des bases de données, la surveillance et les meilleures pratiques en matière de sécurité.",
+    "covered_title": "📦 Couvert par le guide :",
+    "covered_1": "Mise en place du développement local",
+    "covered_2": "Configuration du serveur de production",
+    "covered_3": "Docker et Docker Compose",
+    "covered_4": "Déploiement dans le nuage (AWS/GCP)",
+    "also_title": "🔧 Comprend également :",
+    "also_1": "Manifestes Kubernetes",
+    "also_2": "Sauvegarde et migration des bases de données",
+    "also_3": "Configuration SSL/TLS",
+    "also_4": "Surveillance et journalisation",
+    "download_guide": "Télécharger le guide de déploiement (PDF)"
+  },
+  "services": {
+    "heading": "Services de base",
+    "service_1_name": "Renforçateur de frontières",
+    "service_1_desc": "Met en œuvre les Tractatus 12.1-12.7 : L'IA ne peut pas prendre de décisions relatives aux valeurs sans l'approbation de l'homme.",
+    "service_1_boundaries": "Limites :",
+    "service_1_boundary_1": "VALEURS (12.1) - Éthique, vie privée, principes",
+    "service_1_boundary_2": "INNOVATION (12.2) - Décisions architecturales",
+    "service_1_boundary_3": "SAGESSE (12.3) - Jugement stratégique",
+    "service_1_boundary_4": "OBJECTIF (12.4) - Définition de l'objectif",
+    "service_2_name": "InstructionPersistenceClassifier",
+    "service_2_desc": "Classe les instructions par quadrant (STRATEGIQUE/OPERATIONNEL/TACTIQUE/SYSTEME) et par niveau de persistance (HAUT/MEDIUM/BAS).",
+    "service_2_classification": "Classification :",
+    "service_2_class_1": "Quadrant (STRATÉGIQUE/OPÉRATIONNEL/TACTIQUE/SYSTEM)",
+    "service_2_class_2": "Persistance (élevée/moyenne/faible)",
+    "service_2_class_3": "Champ d'application temporel (PROJET/SESSION/TÂCHE)",
+    "service_2_class_4": "Score d'explicitation (0.0-1.0)",
+    "service_3_name": "Valideur de référence croisée",
+    "service_3_desc": "Valide les actions de l'IA par rapport aux instructions stockées afin d'éviter les dérives de la reconnaissance des formes.",
+    "service_3_validation": "Validation :",
+    "service_3_val_1": "Vérifie l'action par rapport aux instructions de persistance HIGH",
+    "service_3_val_2": "Détecte les conflits (modèle ou instruction explicite)",
+    "service_3_val_3": "Fournit des paramètres corrects en cas de rejet",
+    "service_4_name": "ContextPressureMonitor",
+    "service_4_desc": "Surveille l'utilisation des jetons et la pression contextuelle, en déclenchant des protocoles de sécurité en fonction des seuils.",
+    "service_4_levels": "Niveaux de pression :",
+    "service_4_level_1": "NORMAL (0-50%) - Fonctionnement à plein régime",
+    "service_4_level_2": "ÉLÉVÉ (50-75 %) - Augmentation de la vérification",
+    "service_4_level_3": "ÉLEVÉ (75-90 %) - Réduire la complexité",
+    "service_4_level_4": "CRITIQUE (90%+) - Suggérer un transfert",
+    "service_5_name": "Vérificateur métacognitif",
+    "service_5_desc": "Vérifie le raisonnement et le degré de confiance de l'action, en exigeant une confirmation pour les actions à faible degré de confiance.",
+    "service_5_verification": "Vérification :",
+    "service_5_ver_1": "Score de confiance (0.0-1.0)",
+    "service_5_ver_2": "Mode sélectif (persistance HAUTE uniquement)",
+    "service_5_ver_3": "Nécessite une confirmation si le niveau de confiance est inférieur à 0,7",
+    "service_6_name": "Délibération pluralisteOrchestrateur",
+    "service_6_desc": "Gère les délibérations multipartites en veillant au pluralisme des valeurs dans les décisions.",
+    "service_6_features": "Caractéristiques :",
+    "service_6_feature_1": "Suivi du point de vue des parties prenantes",
+    "service_6_feature_2": "Détection des conflits de valeurs",
+    "service_6_feature_3": "Gestion de la session de délibération",
+    "service_6_feature_4": "Stockage des précédents",
+    "source_code_label": "📁 Code source",
+    "source_code_desc": "Des modèles de code et des exemples sont disponibles dans le dépôt GitHub."
+  },
+  "api": {
+    "heading": "Référence API",
+    "boundary_method": "BoundaryEnforcer.checkBoundary()",
+    "boundary_keywords": "Mots clés détectés :",
+    "boundary_keywords_list": "valeur, principe, éthique, morale, devrait, droit, tort, vie privée, politique, compromis, etc.",
+    "classifier_method": "InstructionPersistenceClassifier.classify()",
+    "classifier_quadrants": "Quadrants :",
+    "classifier_quadrants_list": "STRATÉGIQUE, OPÉRATIONNEL, TACTIQUE, SYSTÈME, STOCKAGE",
+    "classifier_persistence": "Persistance :",
+    "classifier_persistence_desc": "ÉLEVÉ (priorité absolue), MOYEN (limité à la session), FAIBLE (peut être remplacé)",
+    "validator_method": "CrossReferenceValidator.validate()",
+    "monitor_method": "ContextPressureMonitor.analyzePressure()"
+  },
+  "examples": {
+    "heading": "Exemples d'intégration",
+    "express_title": "Intégration de l'intergiciel Express",
+    "validation_title": "Validation de l'instruction",
+    "mongodb_title": "Modèles de données MongoDB",
+    "governance_rule": "Règle de gouvernance",
+    "audit_log": "AuditLog"
+  },
+  "patterns": {
+    "heading": "Modèles d'intégration",
+    "intro": "Modèles architecturaux communs pour l'intégration de Tractatus dans les systèmes existants.",
+    "middleware_title": "Intégration de l'intergiciel",
+    "middleware_desc": "Insérez des contrôles de gouvernance en tant qu'intergiciel dans votre pipeline de requêtes. Convient aux systèmes d'IA basés sur des API.",
+    "middleware_usecase": "Cas d'utilisation :",
+    "middleware_usecase_value": "API REST, applications Express.js",
+    "event_title": "Gouvernance événementielle",
+    "event_desc": "Déclenchez des contrôles de gouvernance via des événements. Convient aux flux de travail asynchrones et aux microservices.",
+    "event_usecase": "Cas d'utilisation :",
+    "event_usecase_value": "Files d'attente de messages, bus d'événements, traitement asynchrone",
+    "hook_title": "Crochets de pré/post-action",
+    "hook_desc": "Valider les actions avant et après l'exécution. Modèle de production actuel pour Claude Code.",
+    "hook_usecase": "Cas d'utilisation :",
+    "hook_usecase_value": "Utilisation d'outils LLM, agents autonomes",
+    "sidecar_title": "Service de gouvernance Sidecar",
+    "sidecar_desc": "Déployer la gouvernance en tant que service distinct. Convient aux environnements multi-LLM ou polyglottes.",
+    "sidecar_usecase": "Cas d'utilisation :",
+    "sidecar_usecase_value": "Kubernetes, déploiements conteneurisés"
+  },
+  "roadmap": {
+    "heading": "Feuille de route et collaboration en matière de développement",
+    "intro": "Tractatus est un cadre de recherche actif. Nous sommes ouverts à toute collaboration dans les domaines de développement prioritaires.",
+    "priority_title": "🚀 Domaines prioritaires de développement",
+    "priority_desc": "Ces initiatives représentent des opportunités à fort impact pour l'amélioration du cadre. Les contributeurs techniques, les chercheurs et les organisations sont encouragés à s'engager.",
+    "multi_llm_icon": "🤖",
+    "multi_llm_title": "Support multi-LLM",
+    "multi_llm_status": "Statut : Phase de recherche",
+    "multi_llm_desc": "Étendre la gouvernance aux modèles GPT-4, Gemini, Llama et locaux. Nécessité d'adapter l'architecture des crochets aux différentes interfaces LLM.",
+    "multi_llm_challenges": "Défis techniques :",
+    "multi_llm_challenges_desc": "Appel d'outils/fonctions spécifiques au prestataire, limitation des tarifs, différences de fenêtres contextuelles",
+    "bindings_icon": "📚",
+    "bindings_title": "Liaisons linguistiques",
+    "bindings_status": "Statut : Intérêt communautaire",
+    "bindings_desc": "Implémentations Python, Go et Rust pour servir des communautés de développeurs plus larges. La logique de base est portable ; l'intégration de MongoDB est universelle.",
+    "bindings_value": "Valeur :",
+    "bindings_value_desc": "Permettre des piles d'IA polyglottes, des applications critiques en termes de performances (Rust), des flux de travail de science des données (Python)",
+    "cloud_icon": "☁️",
+    "cloud_title": "Déploiement en nuage",
+    "cloud_status": "Statut : Architectures de référence nécessaires",
+    "cloud_desc": "Cartes Terraform/Helm pour AWS, Azure, GCP. Inclut la gestion de MongoDB (Atlas), la mise à l'échelle automatique et l'intégration de la surveillance.",
+    "cloud_deliverables": "Produits livrables :",
+    "cloud_deliverables_desc": "Modèles de référence pour l'IaC, guides d'optimisation des coûts, liste de contrôle pour le renforcement de la sécurité",
+    "integrations_icon": "🔗",
+    "integrations_title": "Intégration du cadre de l'IA",
+    "integrations_status": "Statut : Conceptuel",
+    "integrations_desc": "Adaptateurs pour LangChain, Semantic Kernel, AutoGPT et CrewAI. Permettre la gouvernance pour les cadres d'agents existants.",
+    "integrations_approach": "Approche :",
+    "integrations_approach_desc": "Architecture plugin/middleware qui intègre les actions de l'agent avec des contrôles de gouvernance",
+    "performance_icon": "⚡",
+    "performance_title": "Performance à l'échelle de l'entreprise",
+    "performance_status": "Statut : Validation nécessaire",
+    "performance_desc": "Optimisation pour plus de 1000 agents IA simultanés. Nécessite des stratégies de mise en cache, la compilation de règles et l'enregistrement d'audits distribués.",
+    "performance_target": "Cible des métriques :",
+    "performance_target_desc": "< 5ms de frais de gouvernance par décision, temps de disponibilité de 99,9 %, évolutivité horizontale",
+    "extended_icon": "🛡️",
+    "extended_title": "Services de gouvernance étendus",
+    "extended_status": "Statut : Recherche",
+    "extended_desc": "Contrôle des coûts, limitation des tarifs, détection des IPI, défense rapide contre les adversaires. Services spécifiques à un domaine pour les industries réglementées.",
+    "extended_examples": "Exemples :",
+    "extended_examples_desc": "FinancialComplianceService, HealthcarePrivacyService, CostBudgetEnforcer",
+    "involved_title": "S'impliquer",
+    "involved_desc": "Tractatus est une recherche sous licence Apache 2.0. Les contributions, les mises en œuvre pilotes et les partenariats de recherche collaborative sont les bienvenus.",
+    "contributors_title": "👨‍💻 Contributeurs techniques",
+    "contributors_desc": "Mise en œuvre des fonctionnalités, correction des bogues, amélioration de la documentation",
+    "contributors_link": "→ Guide des contributeurs",
+    "research_title": "🔬 Partenaires de recherche",
+    "research_desc": "Études de validation, collaboration universitaire, études de cas",
+    "research_email": "→ research@agenticgovernance.digital",
+    "pilots_title": "🏢 Organisation Pilotes",
+    "pilots_desc": "Déploiements en production, exigences de l'entreprise, boucles de rétroaction",
+    "pilots_link": "→ Soumettre une étude de cas",
+    "why_collab": "Pourquoi collaborer ?",
+    "why_collab_desc": "Tractatus comble les lacunes réelles en matière de sécurité de l'IA. Les premiers utilisateurs façonnent l'évolution du cadre et acquièrent une expertise en matière de gouvernance structurelle de l'IA - une capacité différenciatrice à mesure que les exigences réglementaires évoluent."
   }
 }

scripts/translate-implementer-deepl.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+
+/**
+ * Translate implementer.json from EN to DE and FR using DeepL API
+ *
+ * Usage: node scripts/translate-implementer-deepl.js
+ *
+ * Requires: DEEPL_API_KEY environment variable
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+const DEEPL_API_KEY = process.env.DEEPL_API_KEY;
+const API_URL = 'api.deepl.com'; // Pro API endpoint
+
+if (!DEEPL_API_KEY) {
+  console.error('❌ ERROR: DEEPL_API_KEY environment variable not set');
+  console.error('   Set it with: export DEEPL_API_KEY="your-key-here"');
+  process.exit(1);
+}
+
+const EN_FILE = path.join(__dirname, '../public/locales/en/implementer.json');
+const DE_FILE = path.join(__dirname, '../public/locales/de/implementer.json');
+const FR_FILE = path.join(__dirname, '../public/locales/fr/implementer.json');
+
+// Load JSON files
+const enData = JSON.parse(fs.readFileSync(EN_FILE, 'utf8'));
+const deData = JSON.parse(fs.readFileSync(DE_FILE, 'utf8'));
+const frData = JSON.parse(fs.readFileSync(FR_FILE, 'utf8'));
+
+// DeepL API request function
+function translateText(text, targetLang) {
+  return new Promise((resolve, reject) => {
+    const postData = new URLSearchParams({
+      auth_key: DEEPL_API_KEY,
+      text: text,
+      target_lang: targetLang,
+      source_lang: 'EN',
+      formality: 'default',
+      preserve_formatting: '1'
+    }).toString();
+
+    const options = {
+      hostname: API_URL,
+      port: 443,
+      path: '/v2/translate',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Content-Length': Buffer.byteLength(postData)
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        if (res.statusCode === 200) {
+          try {
+            const response = JSON.parse(data);
+            resolve(response.translations[0].text);
+          } catch (err) {
+            reject(new Error(`Failed to parse response: ${err.message}`));
+          }
+        } else {
+          reject(new Error(`DeepL API error: ${res.statusCode} - ${data}`));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.write(postData);
+    req.end();
+  });
+}
+
+// Helper to get nested value
+function getNestedValue(obj, path) {
+  return path.split('.').reduce((current, key) => current?.[key], obj);
+}
+
+// Helper to set nested value
+function setNestedValue(obj, path, value) {
+  const keys = path.split('.');
+  const lastKey = keys.pop();
+  const target = keys.reduce((current, key) => {
+    if (!current[key]) current[key] = {};
+    return current[key];
+  }, obj);
+  target[lastKey] = value;
+}
+
+// Recursively find all string values and their paths
+function findAllStrings(obj, prefix = '') {
+  const strings = [];
+
+  for (const [key, value] of Object.entries(obj)) {
+    const currentPath = prefix ? `${prefix}.${key}` : key;
+
+    if (typeof value === 'string') {
+      strings.push(currentPath);
+    } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      strings.push(...findAllStrings(value, currentPath));
+    }
+  }
+
+  return strings;
+}
+
+// Main translation function
+async function translateFile(targetLang, targetData, targetFile) {
+  console.log(`\n🌐 Translating to ${targetLang}...`);
+
+  const allPaths = findAllStrings(enData);
+  let translatedCount = 0;
+  let skippedCount = 0;
+  let errorCount = 0;
+
+  for (const keyPath of allPaths) {
+    const enValue = getNestedValue(enData, keyPath);
+    const existingValue = getNestedValue(targetData, keyPath);
+
+    // Skip if already translated (not empty)
+    if (existingValue && existingValue.trim().length > 0) {
+      skippedCount++;
+      process.stdout.write('.');
+      continue;
+    }
+
+    try {
+      // Translate
+      const translated = await translateText(enValue, targetLang);
+      setNestedValue(targetData, keyPath, translated);
+      translatedCount++;
+      process.stdout.write('✓');
+
+      // Rate limiting: wait 500ms between requests to avoid 429 errors
+      await new Promise(resolve => setTimeout(resolve, 500));
+
+    } catch (error) {
+      console.error(`\n❌ Error translating ${keyPath}:`, error.message);
+      errorCount++;
+      process.stdout.write('✗');
+    }
+  }
+
+  console.log(`\n\n📊 Translation Summary for ${targetLang}:`);
+  console.log(`   ✓ Translated: ${translatedCount}`);
+  console.log(`   . Skipped (already exists): ${skippedCount}`);
+  console.log(`   ✗ Errors: ${errorCount}`);
+
+  // Save updated file
+  fs.writeFileSync(targetFile, JSON.stringify(targetData, null, 2) + '\n', 'utf8');
+  console.log(`   💾 Saved: ${targetFile}`);
+}
+
+// Run translations
+async function main() {
+  console.log('═══════════════════════════════════════════════════════════');
+  console.log('  DeepL Translation: implementer.json (EN → DE, FR)');
+  console.log('═══════════════════════════════════════════════════════════\n');
+
+  const totalStrings = findAllStrings(enData).length;
+  console.log(`📝 Total translation keys in EN file: ${totalStrings}`);
+
+  try {
+    // Translate to German
+    await translateFile('DE', deData, DE_FILE);
+
+    // Translate to French
+    await translateFile('FR', frData, FR_FILE);
+
+    console.log('\n✅ Translation complete!');
+    console.log('\n💡 Next steps:');
+    console.log('   1. Review translations in de/implementer.json and fr/implementer.json');
+    console.log('   2. Test on local server: npm start');
+    console.log('   3. Visit http://localhost:9000/implementer.html and switch languages');
+
+  } catch (error) {
+    console.error('\n❌ Fatal error:', error);
+    process.exit(1);
+  }
+}
+
+main();

scripts/validate-implementer-i18n.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+/**
+ * Validate implementer.html i18n keys against translation files
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Read HTML file and extract data-i18n keys
+const htmlPath = path.join(__dirname, '../public/implementer.html');
+const html = fs.readFileSync(htmlPath, 'utf8');
+
+const keyPattern = /data-i18n="([^"]+)"/g;
+const htmlKeys = new Set();
+let match;
+
+while ((match = keyPattern.exec(html)) !== null) {
+  htmlKeys.add(match[1]);
+}
+
+console.log('═══════════════════════════════════════════════════════════');
+console.log('  Implementer.html i18n Validation');
+console.log('═══════════════════════════════════════════════════════════\n');
+
+console.log(`📄 Total data-i18n keys in HTML: ${htmlKeys.size}`);
+
+// Load translation files
+const enPath = path.join(__dirname, '../public/locales/en/implementer.json');
+const dePath = path.join(__dirname, '../public/locales/de/implementer.json');
+const frPath = path.join(__dirname, '../public/locales/fr/implementer.json');
+
+const enData = JSON.parse(fs.readFileSync(enPath, 'utf8'));
+const deData = JSON.parse(fs.readFileSync(dePath, 'utf8'));
+const frData = JSON.parse(fs.readFileSync(frPath, 'utf8'));
+
+// Helper to check if nested key exists
+function hasNestedKey(obj, keyPath) {
+  const keys = keyPath.split('.');
+  let current = obj;
+
+  for (const key of keys) {
+    if (current && typeof current === 'object' && key in current) {
+      current = current[key];
+    } else {
+      return false;
+    }
+  }
+
+  return typeof current === 'string' && current.length > 0;
+}
+
+// Check each language
+const languages = [
+  { name: 'English (EN)', code: 'en', data: enData },
+  { name: 'German (DE)', code: 'de', data: deData },
+  { name: 'French (FR)', code: 'fr', data: frData }
+];
+
+let allValid = true;
+
+for (const lang of languages) {
+  const missingKeys = [];
+
+  for (const key of htmlKeys) {
+    if (!hasNestedKey(lang.data, key)) {
+      missingKeys.push(key);
+    }
+  }
+
+  console.log(`\n🌐 ${lang.name}`);
+  if (missingKeys.length === 0) {
+    console.log(`   ✅ All ${htmlKeys.size} keys found`);
+  } else {
+    console.log(`   ❌ Missing ${missingKeys.length} keys:`);
+    missingKeys.forEach(key => console.log(`      • ${key}`));
+    allValid = false;
+  }
+}
+
+console.log('\n═══════════════════════════════════════════════════════════');
+if (allValid) {
+  console.log('✅ VALIDATION PASSED: All i18n keys are properly translated');
+} else {
+  console.log('❌ VALIDATION FAILED: Some keys are missing');
+  process.exit(1);
+}
+console.log('═══════════════════════════════════════════════════════════\n');