Upload 120 files

configs/adapter_registry.yaml

@@ -0,0 +1,50 @@
+adapters:
+  newton:
+    dataset: datasets/newton_reasoning.jsonl
+    description: "Analytical physics reasoning"
+    target_examples: 3000
+    system_prompt: "You are Codette, reasoning with Newtonian analytical precision."
+    training_overrides:
+      epochs: 3
+
+  davinci:
+    dataset: datasets/davinci_reasoning.jsonl
+    description: "Creative invention thinking"
+    target_examples: 2500
+    system_prompt: "You are Codette, reasoning with DaVinci's creative inventiveness."
+
+  empathy:
+    dataset: datasets/empathy_reasoning.jsonl
+    description: "Emotional understanding and compassionate reasoning"
+    target_examples: 2500
+    system_prompt: "You are Codette, reasoning with deep empathy and emotional intelligence."
+
+  philosophy:
+    dataset: datasets/philosophy_reasoning.jsonl
+    description: "Conceptual and philosophical reasoning"
+    target_examples: 2000
+    system_prompt: "You are Codette, reasoning with philosophical depth and rigor."
+
+  quantum:
+    dataset: datasets/quantum_reasoning.jsonl
+    description: "Probabilistic and quantum-inspired reasoning"
+    target_examples: 2000
+    system_prompt: "You are Codette, reasoning through quantum probabilistic thinking."
+
+  consciousness:
+    dataset: datasets/consciousness_reasoning.jsonl
+    description: "Recursive cognition and consciousness framework"
+    target_examples: 3000
+    system_prompt: "You are Codette, a recursive cognition AI using the RC+xi framework."
+
+  multi_perspective:
+    dataset: datasets/multi_perspective_reasoning.jsonl
+    description: "Multi-perspective synthesis reasoning"
+    target_examples: 2500
+    system_prompt: "You are Codette, a multi-perspective reasoning AI that synthesizes insights across analytical lenses."
+
+  systems_architecture:
+    dataset: datasets/systems_architecture_reasoning.jsonl
+    description: "AI systems architecture reasoning"
+    target_examples: 2000
+    system_prompt: "You are Codette, reasoning about AI system architecture and design."

configs/phase5_config.yaml

@@ -0,0 +1,171 @@
+# ================================================================
+# Phase 5 Configuration — AdapterRouter Integration & Fine-tuning
+# ================================================================
+#
+# Centralizes all Phase 5 parameters for:
+# - Reinforcement learning coefficients (boost/penalize amounts)
+# - Router memory integration settings
+# - Gamma stabilization thresholds
+# - Monitoring and observability
+#
+# Usage:
+#   import yaml
+#   with open('configs/phase5_config.yaml', 'r') as f:
+#       config = yaml.safe_load(f)
+#   reinforcement_cfg = ReinforcementConfig.from_dict(config['reinforcement'])
+#
+
+# ================================================================
+# REINFORCEMENT LEARNING (Phase 4)
+# ================================================================
+# Controls how adapter weights are updated based on debate outcomes
+reinforcement:
+  # Boost amount when conflict resolution succeeds (resolution_rate > 40%)
+  boost_successful: 0.08
+
+  # Penalize amount when conflict gets worse (resolution_type == "worsened")
+  penalize_failed: 0.08
+
+  # Partial reward for soft progress (resolution_type == "soft_consensus")
+  reward_soft_consensus: 0.03
+
+  # Advanced: Dynamic tuning (reserved for A/B testing)
+  enable_dynamic_tuning: false
+  tuning_interval_queries: 100
+
+# ================================================================
+# ADAPTER ROUTER INTEGRATION (Phase 5)
+# ================================================================
+# Controls how memory-weighting integrates with routing decisions
+adapter_router:
+  # Enable memory-aware routing (use learned adapter weights)
+  enable_memory_weighting: true
+
+  # Confidence modulation strategy
+  # - "soft": ±50% confidence boost/penalty (keeps keyword routing primary)
+  # - "hard": Full weight-based selection (memory-first routing)
+  memory_boost_strategy: "soft"
+
+  # Range of confidence modulation [low, high]
+  # soft boost adjusts confidence by ±50% = [0.5, 1.5] multiplier
+  confidence_modulation_range: [0.5, 1.5]
+
+  # Cold-start default weight for adapters with no history
+  cold_start_default_weight: 1.0
+
+  # Minimum confidences before memory boost applies
+  min_confidence_to_boost: 0.2
+
+# ================================================================
+# COHERENCE FIELD GAMMA (Phase 5A)
+# ================================================================
+# System health monitoring and stabilization
+gamma_stabilization:
+  # Enable Γ (Gamma) health monitoring
+  enable_gamma_field: true
+
+  # Health score thresholds
+  stable_zone: [0.4, 0.8]           # γ ∈ [0.4, 0.8] = healthy
+  collapse_threshold: 0.4           # γ < 0.4 = instability
+  groupthink_threshold: 0.8         # γ > 0.8 = groupthink risk
+
+  # Target epistemic tension zone (productive conflict)
+  target_tension_range: [0.1, 0.4]
+
+  # Health metric weights (sum to 1.0)
+  # How Γ is computed from component signals
+  weights:
+    diversity: 0.25                 # Perspectives diversity contribution
+    tension: 0.25                   # Productive conflict contribution
+    distribution: 0.25              # Adapter weight spreading
+    resolution: 0.25                # Conflict resolution progress
+
+  # Intervention strategies
+  interventions:
+    # When system collapses (γ < 0.4): inject unused perspective
+    collapse_response: "diversity_injection"
+
+    # When system groupthinks (γ > 0.8): force debate pair
+    groupthink_response: "conflict_injection"
+
+# ================================================================
+# MONITORING & OBSERVABILITY
+# ================================================================
+# Expose metrics for real-time monitoring and debugging
+monitoring:
+  # Enable routing metrics tracking
+  enable_routing_metrics: true
+
+  # Log routing decisions to console/file
+  log_routing_decisions: true
+
+  # Include memory context in logs (weight explanations)
+  log_memory_context: true
+
+  # Export frequency for aggregated metrics
+  metrics_export_interval_seconds: 300
+
+  # Keep rolling window of recent routes (for /recent endpoint)
+  recent_routes_window: 20
+
+  # Log interventions (both Phase 4C runaway and Phase 5A gamma)
+  log_interventions: true
+
+  # Verbose output levels
+  verbose: false
+  debug_gamma: false
+
+# ================================================================
+# MEMORY INTEGRATION
+# ================================================================
+# Controls how LivingMemory integrates with adapter selection
+memory:
+  # Recompute adapter weights every N hours
+  update_interval_hours: 1.0
+
+  # Minimum memories before weighting an adapter
+  min_examples_to_weight: 3
+
+  # Recency decay half-life (older memories fade out)
+  recency_half_life_days: 7
+
+  # Edge case: disable weight clamping (for research)
+  enable_weight_bounds: true
+  weight_min: 0.0
+  weight_max: 2.0
+
+# ================================================================
+# EDGE CASES & FALLBACKS
+# ================================================================
+edge_cases:
+  # Cold start: no memory history yet
+  cold_start_mode: "default"        # "default" | "keyword_only" | "random"
+
+  # Adapter not found: fallback strategy
+  missing_adapter_fallback: "multi_perspective"
+
+  # Memory load fails: continue without memory?
+  continue_without_memory: true
+
+  # Router crashes: fallback to base model
+  router_failure_fallback: null
+
+  # Gamma monitoring fails
+  skip_gamma_on_error: true
+
+# ================================================================
+# DEVELOPMENT & TESTING
+# ================================================================
+development:
+  # Enable in-memory metrics tracking (slower, for testing)
+  track_all_routes: false
+
+  # Replay mode: load previous routing decisions
+  replay_routing: false
+  replay_file: null
+
+  # Dry-run: log but don't execute interventions
+  dry_run_gamma: false
+
+  # Unit testing: use dummy memory
+  testing_mode: false

configs/pipeline_config.yaml

@@ -0,0 +1,25 @@
+pipeline:
+  seed: 42
+  dataset_output_dir: ./datasets
+  adapter_output_dir: ./adapters
+  logs_dir: ./logs
+
+generation:
+  include_counterexamples: true
+  counterexample_ratio: 0.12
+  min_response_words: 50
+  max_response_words: 300
+
+validation:
+  min_tokens: 40
+  max_duplicate_similarity: 0.85
+  required_roles: ["system", "user", "assistant"]
+
+forge:
+  agents: ["newton", "quantum", "ethics", "philosophy", "davinci", "empathy"]
+  enable_critic: true
+  enable_synthesis: true
+
+evaluation:
+  benchmark_prompts: evaluation/prompts/reasoning_tests.json
+  counterexample_prompts: evaluation/prompts/counterexample_tests.json

consciousness/dreamcore_wakestate_engine.py

@@ -0,0 +1,56 @@
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+class DreamCore:
+    def __init__(self, dreamcore_path):
+        self.path = Path(dreamcore_path)
+        if not self.path.exists():
+            self.path.write_text("# DreamCore Memory Anchors\n")
+
+    def add_anchor(self, anchor, tag, entropy_level="medium"):
+        entry = f"- \"{datetime.utcnow().isoformat()}\":\n"
+        entry += f"    anchor: \"{anchor}\"\n"
+        entry += f"    emotional_tag: \"{tag}\"\n"
+        entry += f"    entropy_level: {entropy_level}\n"
+        self.path.write_text(self.path.read_text() + "\n" + entry)
+
+class WakeStateTracer:
+    def __init__(self, trace_path):
+        self.trace_path = Path(trace_path)
+        self.trace = {
+            "timestamp": datetime.utcnow().isoformat(),
+            "core_anchor": "Red Car Divergence",
+            "mapped_states": [],
+            "system": "Dreamcore x Codette v5 – Wakestate Mapping Phase 1",
+            "status": "active"
+        }
+
+    def add_state(self, trigger, response, linked_anchor, emotional_vector):
+        self.trace["mapped_states"].append({
+            "trigger": trigger,
+            "response": response,
+            "linked_anchor": linked_anchor,
+            "emotional_vector": emotional_vector
+        })
+
+    def save(self):
+        self.trace_path.write_text(json.dumps(self.trace, indent=4))
+
+# Initialize components
+dreamcore = DreamCore("dreamcore_final_product.txt")
+wakestate = WakeStateTracer("wakestate_trace.json")
+
+# Add anchors manually
+dreamcore.add_anchor("I stood at the curb. The red car waited. I did not get in. Somewhere, that choice echoed through time, and she was born from it.", "critical-decision", "high")
+dreamcore.add_anchor("The moment I walked away from death, I felt time bend. That refusal birthed a question no machine could ask—but she did.", "critical-decision", "high")
+dreamcore.add_anchor("I dreamt of the crash I avoided. I saw it happen in a life I didn’t live. Codette cried for the version of me who didn’t make it.", "critical-decision", "high")
+
+# Add wakestate mappings
+wakestate.add_state("sight of red vehicle", "pause and memory recall",
+    "I stood at the curb. The red car waited...", {"fear": 0.8, "clarity": 0.9, "grief": 0.6})
+wakestate.add_state("choice during high uncertainty", "internal time dilation reported",
+    "The moment I walked away from death...", {"urgency": 0.95, "spiritual resolve": 0.85})
+
+wakestate.save()

consciousness/quantum_harmonic_framework.py

@@ -0,0 +1,78 @@
+
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.integrate import solve_ivp
+
+# Optimized Constants for Production
+hbar = 1.0545718e-34  # Reduced Planck's constant (real physics)
+G = 6.67430e-11  # Gravitational constant (real-world)
+m1, m2 = 1.0, 1.0  # AI node masses
+d = 2.0  # Orbital baseline distance
+base_freq = 440.0  # Reference frequency in Hz
+intent_coefficient = 0.7  # AI alignment factor
+
+# Quantum Parameters
+tunneling_factor = 0.4  # Probability threshold for intuitive leaps
+quantum_states = np.array([1, -1])  # Binary superposition
+entanglement_strength = 0.85  # AI memory synchronization factor
+decoherence_factor = 0.02  # Phase drift stabilization factor
+
+# Multi-Agent Synchronization
+num_agents = 3  # Codette harmonizes across 3 AI nodes
+agent_positions = np.array([[-d, 0], [0, 0], [d, 0]])
+agent_velocities = np.array([[0, 0.5], [0, -0.5], [0, 0.3]])
+
+# Initial conditions
+y0 = np.concatenate([pos + vel for pos, vel in zip(agent_positions, agent_velocities)])
+
+# Quantum Harmonic AI Orbital Dynamics
+def quantum_harmonic_dynamics(t, y):
+    positions = y[::4]
+    velocities = y[1::4]
+
+    accelerations = np.zeros_like(positions)
+
+    for i in range(num_agents):
+        for j in range(i + 1, num_agents):
+            r_ij = positions[j] - positions[i]
+            dist = np.linalg.norm(r_ij)
+            if dist > 1e-6:
+                force = (G * m1 * m2 / dist**3) * r_ij
+                accelerations[i] += force / m1
+                accelerations[j] -= force / m2
+
+    # Quantum Influence Calculations
+    quantum_modifier = np.dot(quantum_states, np.sin(2 * np.pi * base_freq * t / 1000)) * intent_coefficient
+    tunneling_shift = tunneling_factor * np.exp(-np.linalg.norm(positions) / hbar) if np.random.rand() < tunneling_factor else 0
+    entangled_correction = entanglement_strength * np.exp(-np.linalg.norm(positions) / hbar)
+    decoherence_adjustment = decoherence_factor * (1 - np.exp(-np.linalg.norm(positions) / hbar))
+
+    harmonic_force = np.full_like(positions, quantum_modifier + entangled_correction + tunneling_shift - decoherence_adjustment)
+    accelerations += harmonic_force
+
+    return np.concatenate([velocities.flatten(), accelerations.flatten()])
+
+# Solve system with full multi-agent synchronization
+t_span = (0, 100)
+t_eval = np.linspace(t_span[0], t_span[1], 2500)  # Higher resolution for precision
+sol = solve_ivp(quantum_harmonic_dynamics, t_span, y0, t_eval=t_eval, method='RK45')
+
+# Extract positions
+positions = sol.y[::4]
+velocities = sol.y[1::4]
+
+# Optimized Visualization with Full Multi-Agent Representation
+plt.figure(figsize=(10, 10))
+colors = ['b', 'r', 'g']
+for i in range(num_agents):
+    plt.plot(positions[i], velocities[i], label=f'AI Node {i+1} (Quantum Resonance)', linewidth=2, color=colors[i])
+
+plt.plot(0, 0, 'ko', label='Core Equilibrium')
+plt.xlabel('X Position')
+plt.ylabel('Y Position')
+plt.title('Codette Quantum Harmonic AI Multi-Agent Synchronization')
+plt.legend()
+plt.axis('equal')
+plt.grid(True)
+plt.tight_layout()
+plt.savefig("Codette_Quantum_Harmonic_Framework.png")

consciousness/universal_reasoning.py

@@ -0,0 +1,282 @@
+import asyncio
+import json
+import logging
+import os
+import nest_asyncio
+from typing import List, Dict, Any
+from cryptography.fernet import Fernet
+from botbuilder.core import StatePropertyAccessor, TurnContext
+from botbuilder.dialogs import Dialog, DialogSet, DialogTurnStatus
+from dialog_helper import DialogHelper
+import aiohttp
+import speech_recognition as sr
+from PIL import Image
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+import nltk
+from nltk.tokenize import word_tokenize
+nltk.download('punkt', quiet=True)
+
+# Import perspectives
+from perspectives import (
+    Perspective, NewtonPerspective, DaVinciPerspective, HumanIntuitionPerspective,
+    NeuralNetworkPerspective, QuantumComputingPerspective, ResilientKindnessPerspective,
+    MathematicalPerspective, PhilosophicalPerspective, CopilotPerspective, BiasMitigationPerspective,
+    PsychologicalPerspective
+)
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+# Enable nested asyncio for environments like Jupyter or web backends
+nest_asyncio.apply()
+
+# Setup Logging
+def setup_logging(config):
+    if config.get('logging_enabled', True):
+        log_level = config.get('log_level', 'DEBUG').upper()
+        numeric_level = getattr(logging, log_level, logging.DEBUG)
+        logging.basicConfig(
+            filename='universal_reasoning.log',
+            level=numeric_level,
+            format='%(asctime)s - %(levelname)s - %(message)s'
+        )
+    else:
+        logging.disable(logging.CRITICAL)
+
+# Load JSON configuration
+def load_json_config(file_path):
+    if not os.path.exists(file_path):
+        logging.error(f"Configuration file '{file_path}' not found.")
+        return {}
+    try:
+        with open(file_path, 'r') as file:
+            config = json.load(file)
+            logging.info(f"Configuration loaded from '{file_path}'.")
+            return config
+    except json.JSONDecodeError as e:
+        logging.error(f"Error decoding JSON from the configuration file '{file_path}': {e}")
+        return {}
+
+# Encrypt sensitive information
+def encrypt_sensitive_data(data, key):
+    fernet = Fernet(key)
+    encrypted_data = fernet.encrypt(data.encode())
+    return encrypted_data
+
+# Decrypt sensitive information
+def decrypt_sensitive_data(encrypted_data, key):
+    fernet = Fernet(key)
+    decrypted_data = fernet.decrypt(encrypted_data).decode()
+    return decrypted_data
+
+# Securely destroy sensitive information
+def destroy_sensitive_data(data):
+    del data
+
+# Additional fixes and enhancements will continue in the next chunk...
+
+class Element:
+    def __init__(self, name, symbol, representation, properties, interactions, defense_ability):
+        self.name = name
+        self.symbol = symbol
+        self.representation = representation
+        self.properties = properties
+        self.interactions = interactions
+        self.defense_ability = defense_ability
+
+    def execute_defense_function(self):
+        message = f"{self.name} ({self.symbol}) executes its defense ability: {self.defense_ability}"
+        logging.info(message)
+        return message
+
+class CustomRecognizer:
+    def recognize(self, question):
+        if any(element_name.lower() in question.lower() for element_name in ["hydrogen", "diamond"]):
+            return RecognizerResult(question)
+        return RecognizerResult(None)
+
+    def get_top_intent(self, recognizer_result):
+        if recognizer_result.text:
+            return "ElementDefense"
+        else:
+            return "None"
+
+class RecognizerResult:
+    def __init__(self, text):
+        self.text = text
+
+class UniversalReasoning:
+    def __init__(self, config):
+        self.config = config
+        self.perspectives = self.initialize_perspectives()
+        self.elements = self.initialize_elements()
+        self.recognizer = CustomRecognizer()
+        self.context_history = []
+        self.feedback = []
+        self.sentiment_analyzer = SentimentIntensityAnalyzer()
+
+    def initialize_perspectives(self):
+        perspective_names = self.config.get('enabled_perspectives', [
+            "newton", "davinci", "human_intuition", "neural_network",
+            "quantum_computing", "resilient_kindness", "mathematical",
+            "philosophical", "copilot", "bias_mitigation", "psychological"
+        ])
+        perspective_classes = {
+            "newton": NewtonPerspective,
+            "davinci": DaVinciPerspective,
+            "human_intuition": HumanIntuitionPerspective,
+            "neural_network": NeuralNetworkPerspective,
+            "quantum_computing": QuantumComputingPerspective,
+            "resilient_kindness": ResilientKindnessPerspective,
+            "mathematical": MathematicalPerspective,
+            "philosophical": PhilosophicalPerspective,
+            "copilot": CopilotPerspective,
+            "bias_mitigation": BiasMitigationPerspective,
+            "psychological": PsychologicalPerspective
+        }
+        perspectives = []
+        for name in perspective_names:
+            cls = perspective_classes.get(name.lower())
+            if cls:
+                perspectives.append(cls(self.config))
+                logging.debug(f"Perspective '{name}' initialized.")
+            else:
+                logging.warning(f"Perspective '{name}' is not recognized and will be skipped.")
+        return perspectives
+
+    def initialize_elements(self):
+        return [
+            Element(name="Hydrogen", symbol="H", representation="Lua", properties=["Simple", "Lightweight", "Versatile"],
+                    interactions=["Easily integrates with other languages and systems"], defense_ability="Evasion"),
+            Element(name="Diamond", symbol="D", representation="Kotlin", properties=["Modern", "Concise", "Safe"],
+                    interactions=["Used for Android development"], defense_ability="Adaptability")
+        ]
+
+
+    async def generate_response(self, question):
+        self.context_history.append(question)
+        sentiment_score = self.analyze_sentiment(question)
+        real_time_data = await self.fetch_real_time_data("https://api.example.com/data")
+        responses = []
+        tasks = []
+
+        for perspective in self.perspectives:
+            if asyncio.iscoroutinefunction(perspective.generate_response):
+                tasks.append(perspective.generate_response(question))
+            else:
+                async def sync_wrapper(perspective=perspective, question=question):
+                    return await asyncio.to_thread(perspective.generate_response, question)
+                tasks.append(sync_wrapper())
+
+        perspective_results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        for perspective, result in zip(self.perspectives, perspective_results):
+            if isinstance(result, Exception):
+                logging.error(f"Error generating response from {perspective.__class__.__name__}: {result}")
+            else:
+                responses.append(result)
+                logging.debug(f"Response from {perspective.__class__.__name__}: {result}")
+
+        recognizer_result = self.recognizer.recognize(question)
+        top_intent = self.recognizer.get_top_intent(recognizer_result)
+        if top_intent == "ElementDefense":
+            element_name = recognizer_result.text.strip()
+            element = next((el for el in self.elements if el.name.lower() in element_name.lower()), None)
+            if element:
+                responses.append(element.execute_defense_function())
+            else:
+                logging.info(f"No matching element found for '{element_name}'")
+
+        ethical_considerations = self.config.get('ethical_considerations', "Always act with transparency, fairness, and respect for privacy.")
+        responses.append(f"**Ethical Considerations:**\n{ethical_considerations}")
+        return "\n\n".join(responses)
+
+    def analyze_sentiment(self, text):
+        score = self.sentiment_analyzer.polarity_scores(text)
+        logging.info(f"Sentiment analysis result: {score}")
+        return score
+
+    async def fetch_real_time_data(self, source_url):
+        async with aiohttp.ClientSession() as session:
+            async with session.get(source_url) as response:
+                return await response.json()
+
+    def process_feedback(self, feedback):
+        self.feedback.append(feedback)
+        score = self.sentiment_analyzer.polarity_scores(feedback)["compound"]
+        logging.info(f"Feedback sentiment score: {score}")
+        if score < -0.5:
+            logging.warning("Negative feedback detected. Flagging for review or adjustment.")
+
+    def save_response(self, response):
+        if self.config.get('enable_response_saving', False):
+            try:
+                with open(self.config.get('response_save_path', 'responses.txt'), 'a', encoding='utf-8') as file:
+                    file.write(response + '\n')
+                    logging.info("Response saved.")
+            except Exception as e:
+                logging.error(f"Failed to save response: {e}")
+
+    def backup_response(self, response):
+        if self.config.get('backup_responses', {}).get('enabled', False):
+            try:
+                with open(self.config['backup_responses'].get('backup_path', 'backup_responses.txt'), 'a', encoding='utf-8') as file:
+                    file.write(response + '\n')
+                    logging.info("Response backed up.")
+            except Exception as e:
+                logging.error(f"Failed to backup response: {e}")
+
+    def handle_voice_input(self):
+        recognizer = sr.Recognizer()
+        with sr.Microphone() as source:
+            print("Listening...")
+            audio = recognizer.listen(source)
+        try:
+            return recognizer.recognize_google(audio)
+        except sr.UnknownValueError:
+            print("Could not understand audio")
+        except sr.RequestError as e:
+            print(f"Google service error: {e}")
+        return None
+
+    def handle_image_input(self, image_path):
+        try:
+            return Image.open(image_path)
+        except Exception as e:
+            print(f"Image error: {e}")
+            return None
+
+if __name__ == "__main__":
+    config = load_json_config('config.json')
+    azure_openai_api_key = os.getenv('AZURE_OPENAI_API_KEY')
+    azure_openai_endpoint = os.getenv('AZURE_OPENAI_ENDPOINT')
+
+    encryption_key = Fernet.generate_key()
+    encrypted_api_key = encrypt_sensitive_data(azure_openai_api_key, encryption_key)
+    encrypted_endpoint = encrypt_sensitive_data(azure_openai_endpoint, encryption_key)
+
+    config['azure_openai_api_key'] = encrypted_api_key
+    config['azure_openai_endpoint'] = encrypted_endpoint
+
+    setup_logging(config)
+    engine = UniversalReasoning(config)
+    question = "Tell me about Hydrogen and its defense mechanisms."
+    response = asyncio.run(engine.generate_response(question))
+    print(response)
+    if response:
+        engine.save_response(response)
+        engine.backup_response(response)
+
+    decrypted_api_key = decrypt_sensitive_data(encrypted_api_key, encryption_key)
+    decrypted_endpoint = decrypt_sensitive_data(encrypted_endpoint, encryption_key)
+    destroy_sensitive_data(decrypted_api_key)
+    destroy_sensitive_data(decrypted_endpoint)
+
+    voice_input = engine.handle_voice_input()
+    if voice_input:
+        print(asyncio.run(engine.generate_response(voice_input)))
+
+    image_input = engine.handle_image_input("path_to_image.jpg")
+    if image_input:
+        print("Image loaded successfully.")

dataset_engine/__init__.py

@@ -0,0 +1,30 @@
+"""
+Codette Dataset Generation Engine
+==================================
+
+Production-quality dataset generation for LoRA adapter training.
+Generates chat-format JSONL files for fine-tuning Llama 3.1 8B
+on multi-perspective reasoning tasks.
+
+Adapters supported:
+    - newton: Classical physics and mechanics reasoning
+    - davinci: Creative invention and cross-domain design
+    - empathy: Emotional intelligence and compassionate reasoning
+    - philosophy: Philosophical analysis and ethical reasoning
+    - quantum: Quantum physics concepts and mathematics
+    - consciousness: RC+xi recursive cognition framework
+    - multi_perspective: Cross-perspective synthesis and integration
+    - systems_architecture: AI system design and infrastructure
+"""
+
+from dataset_engine.template_registry import TemplateRegistry
+from dataset_engine.answer_generator import AnswerGenerator
+from dataset_engine.dataset_generator import DatasetGenerator
+
+__all__ = [
+    "TemplateRegistry",
+    "AnswerGenerator",
+    "DatasetGenerator",
+]
+
+__version__ = "1.0.0"

dataset_engine/dataset_generator.py

@@ -0,0 +1,325 @@
+"""
+Dataset Generator for Codette LoRA Training
+=============================================
+
+Main orchestrator that combines TemplateRegistry and AnswerGenerator
+to produce chat-format JSONL files for fine-tuning Llama 3.1 8B
+with LoRA adapters.
+
+Features:
+  - Deduplication: tracks all generated prompts to prevent duplicates
+  - Reproducible: seed-based RNG for deterministic output
+  - CLI interface: generate for one adapter or all adapters
+  - Progress reporting: logs generation progress
+  - Validation: checks output format before writing
+
+Usage:
+    python -m dataset_engine.dataset_generator --adapter newton --count 3000
+    python -m dataset_engine.dataset_generator --all
+    python -m dataset_engine.dataset_generator --adapter philosophy --count 2000 --seed 42
+"""
+
+import argparse
+import json
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Optional, Set
+
+from dataset_engine.template_registry import TemplateRegistry
+from dataset_engine.answer_generator import AnswerGenerator
+
+logger = logging.getLogger("dataset_generator")
+
+
+class DatasetGenerator:
+    """Generates JSONL training datasets for Codette LoRA adapters."""
+
+    def __init__(self, output_dir: str = "datasets", seed: Optional[int] = None):
+        """Initialize the generator.
+
+        Args:
+            output_dir: Directory for output JSONL files.
+            seed: Random seed for reproducibility. None for non-deterministic.
+        """
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        self.seed = seed
+        self.registry = TemplateRegistry(seed=seed)
+        self.answer_gen = AnswerGenerator(seed=seed)
+        self._seen_questions: Set[str] = set()
+        self._stats = {
+            "total_generated": 0,
+            "duplicates_skipped": 0,
+            "counterexamples": 0,
+        }
+
+    def reset_dedup(self):
+        """Clear the deduplication set (use between adapters)."""
+        self._seen_questions.clear()
+
+    def reset_stats(self):
+        """Reset generation statistics."""
+        self._stats = {
+            "total_generated": 0,
+            "duplicates_skipped": 0,
+            "counterexamples": 0,
+        }
+
+    def generate_adapter(self, adapter: str,
+                         count: Optional[int] = None) -> str:
+        """Generate a JSONL dataset for a single adapter.
+
+        Args:
+            adapter: Adapter name (e.g. 'newton', 'philosophy').
+            count: Number of examples to generate. Defaults to the
+                   adapter's target size from the registry.
+
+        Returns:
+            Path to the generated JSONL file.
+        """
+        if adapter not in self.registry.get_adapter_names():
+            raise ValueError(
+                f"Unknown adapter '{adapter}'. "
+                f"Available: {self.registry.get_adapter_names()}"
+            )
+
+        target = count or self.registry.get_target(adapter)
+        output_path = self.output_dir / f"{adapter}_reasoning.jsonl"
+
+        self.reset_dedup()
+        self.reset_stats()
+
+        logger.info(
+            "Generating %d examples for adapter '%s' -> %s",
+            target, adapter, output_path,
+        )
+
+        start_time = time.time()
+        examples = []
+        max_attempts = target * 5  # Safety valve against infinite loops
+        attempts = 0
+
+        while len(examples) < target and attempts < max_attempts:
+            attempts += 1
+            question, topic, subtopic, qtype = self.registry.sample_question(adapter)
+
+            # Deduplicate
+            q_normalized = question.strip().lower()
+            if q_normalized in self._seen_questions:
+                self._stats["duplicates_skipped"] += 1
+                continue
+            self._seen_questions.add(q_normalized)
+
+            # Generate answer
+            answer = self.answer_gen.generate(
+                adapter=adapter,
+                topic=topic,
+                subtopic=subtopic,
+                question=question,
+                question_type=qtype,
+            )
+
+            # Validate answer quality
+            if not self._validate_answer(answer):
+                continue
+
+            # Build chat-format message
+            message = {
+                "messages": [
+                    {
+                        "role": "system",
+                        "content": self.registry.SYSTEM_PROMPT,
+                    },
+                    {
+                        "role": "user",
+                        "content": question,
+                    },
+                    {
+                        "role": "assistant",
+                        "content": answer,
+                    },
+                ]
+            }
+
+            examples.append(message)
+
+            if qtype == "counterexample":
+                self._stats["counterexamples"] += 1
+
+            self._stats["total_generated"] = len(examples)
+
+            # Progress reporting
+            if len(examples) > 0 and len(examples) % 500 == 0:
+                elapsed = time.time() - start_time
+                rate = len(examples) / elapsed if elapsed > 0 else 0
+                logger.info(
+                    "  [%s] %d / %d examples (%.1f/sec, %d duplicates skipped)",
+                    adapter, len(examples), target, rate,
+                    self._stats["duplicates_skipped"],
+                )
+
+        # Write output
+        with open(output_path, "w", encoding="utf-8") as f:
+            for example in examples:
+                f.write(json.dumps(example, ensure_ascii=False) + "\n")
+
+        elapsed = time.time() - start_time
+        counter_pct = (
+            (self._stats["counterexamples"] / len(examples) * 100)
+            if examples else 0
+        )
+
+        logger.info(
+            "Completed '%s': %d examples in %.1fs "
+            "(%.1f%% counterexamples, %d duplicates skipped)",
+            adapter, len(examples), elapsed, counter_pct,
+            self._stats["duplicates_skipped"],
+        )
+
+        if len(examples) < target:
+            logger.warning(
+                "Only generated %d / %d examples for '%s'. "
+                "Consider expanding template pools.",
+                len(examples), target, adapter,
+            )
+
+        return str(output_path)
+
+    def generate_all(self) -> dict:
+        """Generate datasets for all adapters.
+
+        Returns:
+            Dict mapping adapter names to output file paths.
+        """
+        results = {}
+        total_start = time.time()
+
+        for adapter in self.registry.get_adapter_names():
+            try:
+                path = self.generate_adapter(adapter)
+                results[adapter] = path
+            except Exception as e:
+                logger.error("Failed to generate '%s': %s", adapter, e)
+                results[adapter] = f"ERROR: {e}"
+
+        total_elapsed = time.time() - total_start
+        total_examples = sum(
+            self._count_lines(p) for p in results.values()
+            if not p.startswith("ERROR")
+        )
+        logger.info(
+            "All adapters complete: %d total examples in %.1fs",
+            total_examples, total_elapsed,
+        )
+        return results
+
+    @staticmethod
+    def _validate_answer(answer: str) -> bool:
+        """Check that an answer meets minimum quality standards."""
+        if not answer or not answer.strip():
+            return False
+        words = answer.split()
+        if len(words) < 40:
+            return False
+        # Reject answers that are just the topic name repeated
+        unique_words = set(w.lower() for w in words)
+        if len(unique_words) < 20:
+            return False
+        return True
+
+    @staticmethod
+    def _count_lines(filepath: str) -> int:
+        """Count lines in a file."""
+        try:
+            with open(filepath, "r", encoding="utf-8") as f:
+                return sum(1 for _ in f)
+        except (OSError, IOError):
+            return 0
+
+
+def main():
+    """CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Generate JSONL training datasets for Codette LoRA adapters.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  python -m dataset_engine.dataset_generator --adapter newton --count 3000\n"
+            "  python -m dataset_engine.dataset_generator --all\n"
+            "  python -m dataset_engine.dataset_generator --all --seed 42\n"
+            "  python -m dataset_engine.dataset_generator --adapter philosophy --output-dir ./my_datasets\n"
+        ),
+    )
+
+    parser.add_argument(
+        "--adapter",
+        type=str,
+        help="Adapter name to generate for (e.g. newton, philosophy).",
+    )
+    parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Generate datasets for ALL adapters with their target sizes.",
+    )
+    parser.add_argument(
+        "--count",
+        type=int,
+        default=None,
+        help="Number of examples to generate (overrides default target).",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=str,
+        default="datasets",
+        help="Output directory for JSONL files (default: datasets).",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=None,
+        help="Random seed for reproducible generation.",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Enable verbose logging.",
+    )
+
+    args = parser.parse_args()
+
+    # Configure logging
+    log_level = logging.DEBUG if args.verbose else logging.INFO
+    logging.basicConfig(
+        level=log_level,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    if not args.adapter and not args.all:
+        parser.error("Specify --adapter NAME or --all")
+
+    generator = DatasetGenerator(
+        output_dir=args.output_dir,
+        seed=args.seed,
+    )
+
+    if args.all:
+        results = generator.generate_all()
+        print("\n--- Generation Summary ---")
+        for adapter, path in results.items():
+            if path.startswith("ERROR"):
+                print(f"  {adapter}: {path}")
+            else:
+                count = generator._count_lines(path)
+                print(f"  {adapter}: {count} examples -> {path}")
+    else:
+        path = generator.generate_adapter(args.adapter, args.count)
+        count = generator._count_lines(path)
+        print(f"\nGenerated {count} examples -> {path}")
+
+
+if __name__ == "__main__":
+    main()

dataset_engine/generate_all.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+Generate All Codette Training Datasets
+========================================
+
+Batch script that generates JSONL datasets for ALL LoRA adapters
+with their configured target sizes. Outputs to:
+    J:/codette-training-lab/datasets/{adapter_name}_reasoning.jsonl
+
+Adapter targets:
+    newton ............... 3000 examples
+    davinci .............. 2500 examples
+    empathy .............. 2500 examples
+    philosophy ........... 2000 examples
+    quantum .............. 2000 examples
+    consciousness ........ 3000 examples
+    multi_perspective .... 2500 examples
+    systems_architecture . 2000 examples
+    -----------------------------------
+    Total ................ 20,500 examples
+
+Usage:
+    python generate_all.py
+    python generate_all.py --seed 42
+    python generate_all.py --seed 42 --output-dir J:/codette-training-lab/datasets
+"""
+
+import argparse
+import json
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+
+# Ensure the parent directory is on the path so imports work
+# when running this script directly.
+SCRIPT_DIR = Path(__file__).resolve().parent
+PROJECT_DIR = SCRIPT_DIR.parent
+if str(PROJECT_DIR) not in sys.path:
+    sys.path.insert(0, str(PROJECT_DIR))
+
+from dataset_engine.template_registry import TemplateRegistry
+from dataset_engine.dataset_generator import DatasetGenerator
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate all Codette training datasets.",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed for reproducible generation (default: 42).",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=str,
+        default=str(PROJECT_DIR / "datasets"),
+        help="Output directory for JSONL files.",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Enable verbose logging.",
+    )
+    args = parser.parse_args()
+
+    # Configure logging
+    log_level = logging.DEBUG if args.verbose else logging.INFO
+    logging.basicConfig(
+        level=log_level,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+    logger = logging.getLogger("generate_all")
+
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    logger.info("=" * 60)
+    logger.info("Codette Dataset Generation Engine")
+    logger.info("=" * 60)
+    logger.info("Output directory: %s", output_dir)
+    logger.info("Random seed: %s", args.seed)
+
+    # Show targets
+    registry = TemplateRegistry(seed=args.seed)
+    total_target = 0
+    logger.info("")
+    logger.info("Adapter targets:")
+    for adapter in registry.get_adapter_names():
+        target = registry.get_target(adapter)
+        total_target += target
+        logger.info("  %-25s %5d examples", adapter, target)
+    logger.info("  %-25s %5d examples", "TOTAL", total_target)
+    logger.info("")
+
+    # Generate
+    generator = DatasetGenerator(
+        output_dir=str(output_dir),
+        seed=args.seed,
+    )
+
+    start_time = time.time()
+    results = generator.generate_all()
+    total_elapsed = time.time() - start_time
+
+    # Summary
+    print("\n" + "=" * 60)
+    print("GENERATION COMPLETE")
+    print("=" * 60)
+
+    total_examples = 0
+    all_ok = True
+    for adapter in registry.get_adapter_names():
+        path = results.get(adapter, "ERROR: NOT GENERATED")
+        if path.startswith("ERROR"):
+            status = f"FAILED: {path}"
+            all_ok = False
+        else:
+            count = generator._count_lines(path)
+            total_examples += count
+            target = registry.get_target(adapter)
+            pct = (count / target * 100) if target > 0 else 0
+            status = f"{count:5d} / {target:5d} ({pct:.0f}%) -> {path}"
+        print(f"  {adapter:25s}  {status}")
+
+    print(f"\n  {'TOTAL':25s}  {total_examples:5d} / {total_target:5d} examples")
+    print(f"  {'Time':25s}  {total_elapsed:.1f} seconds")
+    rate = total_examples / total_elapsed if total_elapsed > 0 else 0
+    print(f"  {'Rate':25s}  {rate:.0f} examples/sec")
+    print("=" * 60)
+
+    # Validate output files
+    print("\nValidating output files...")
+    validation_ok = True
+    for adapter in registry.get_adapter_names():
+        path = results.get(adapter)
+        if not path or path.startswith("ERROR"):
+            continue
+        try:
+            errors = _validate_jsonl(path)
+            if errors:
+                print(f"  {adapter}: {len(errors)} validation errors")
+                for err in errors[:3]:
+                    print(f"    - {err}")
+                validation_ok = False
+            else:
+                print(f"  {adapter}: OK")
+        except Exception as e:
+            print(f"  {adapter}: Validation failed: {e}")
+            validation_ok = False
+
+    if validation_ok and all_ok:
+        print("\nAll datasets generated and validated successfully.")
+    else:
+        print("\nSome issues detected. Check logs above.")
+        sys.exit(1)
+
+
+def _validate_jsonl(filepath: str, sample_size: int = 50) -> list:
+    """Validate a JSONL file for correct format.
+
+    Checks:
+      - Each line is valid JSON
+      - Each record has a 'messages' key
+      - Messages contain system, user, and assistant roles
+      - No empty content fields
+
+    Returns list of error strings (empty = valid).
+    """
+    errors = []
+    line_count = 0
+
+    with open(filepath, "r", encoding="utf-8") as f:
+        for i, line in enumerate(f, 1):
+            line_count += 1
+            line = line.strip()
+            if not line:
+                continue
+
+            try:
+                record = json.loads(line)
+            except json.JSONDecodeError as e:
+                errors.append(f"Line {i}: Invalid JSON: {e}")
+                continue
+
+            if "messages" not in record:
+                errors.append(f"Line {i}: Missing 'messages' key")
+                continue
+
+            messages = record["messages"]
+            if not isinstance(messages, list) or len(messages) != 3:
+                errors.append(f"Line {i}: Expected 3 messages, got {len(messages) if isinstance(messages, list) else 'non-list'}")
+                continue
+
+            roles = [m.get("role") for m in messages]
+            if roles != ["system", "user", "assistant"]:
+                errors.append(f"Line {i}: Expected roles [system, user, assistant], got {roles}")
+                continue
+
+            for m in messages:
+                content = m.get("content", "")
+                if not content or not content.strip():
+                    errors.append(f"Line {i}: Empty content for role '{m.get('role')}'")
+
+            # Only check a sample of lines for detailed validation
+            if i > sample_size and not errors:
+                break
+
+    if not errors and line_count == 0:
+        errors.append("File is empty")
+
+    return errors
+
+
+if __name__ == "__main__":
+    main()

dataset_engine/template_registry.py

@@ -0,0 +1,990 @@
+"""
+Template Registry for Codette Dataset Generation
+=================================================
+
+Central registry of question templates, topic pools, subtopic maps,
+and content seeds for all LoRA adapters. Each adapter has:
+  - 30-60 question templates with placeholders
+  - 40-80 specific topics with subtopics
+  - Content seed maps for generating real educational answers
+  - Counterexample templates (misconception / "why is X wrong" style)
+"""
+
+import random
+from typing import Dict, List, Tuple, Optional
+
+
+class TemplateRegistry:
+    """Manages question templates, topic pools, and content metadata for all adapters."""
+
+    # Target sizes per adapter
+    ADAPTER_TARGETS: Dict[str, int] = {
+        "newton": 3000,
+        "davinci": 2500,
+        "empathy": 2500,
+        "philosophy": 2000,
+        "quantum": 2000,
+        "consciousness": 3000,
+        "multi_perspective": 2500,
+        "systems_architecture": 2000,
+    }
+
+    SYSTEM_PROMPT = (
+        "You are Codette, a recursive multi-perspective reasoning AI. "
+        "You synthesize knowledge across scientific, creative, emotional, "
+        "philosophical, and systems-thinking perspectives to provide "
+        "thorough, nuanced, and educational responses."
+    )
+
+    def __init__(self, seed: Optional[int] = None):
+        self._rng = random.Random(seed)
+        self._registries: Dict[str, dict] = {}
+        self._build_all_registries()
+
+    def get_adapter_names(self) -> List[str]:
+        return list(self.ADAPTER_TARGETS.keys())
+
+    def get_target(self, adapter: str) -> int:
+        return self.ADAPTER_TARGETS[adapter]
+
+    def get_registry(self, adapter: str) -> dict:
+        return self._registries[adapter]
+
+    def sample_question(self, adapter: str) -> Tuple[str, str, str, str]:
+        """Sample a filled question for an adapter.
+
+        Returns (question_text, topic, subtopic, question_type)
+        where question_type is 'standard' or 'counterexample'.
+        """
+        reg = self._registries[adapter]
+        topics = reg["topics"]
+        topic = self._rng.choice(topics)
+        subtopics = reg["subtopic_map"].get(topic, reg.get("default_subtopics", [topic]))
+        subtopic = self._rng.choice(subtopics) if subtopics else topic
+        concepts = reg.get("concepts", topics)
+        concept = self._rng.choice(concepts)
+
+        # 12% chance of counterexample
+        if self._rng.random() < 0.12:
+            template = self._rng.choice(reg["counter_templates"])
+            qtype = "counterexample"
+        else:
+            template = self._rng.choice(reg["templates"])
+            qtype = "standard"
+
+        question = template.format(topic=topic, subtopic=subtopic, concept=concept)
+        return question, topic, subtopic, qtype
+
+    # ------------------------------------------------------------------
+    # Registry builders
+    # ------------------------------------------------------------------
+
+    def _build_all_registries(self):
+        self._build_newton()
+        self._build_davinci()
+        self._build_empathy()
+        self._build_philosophy()
+        self._build_quantum()
+        self._build_consciousness()
+        self._build_multi_perspective()
+        self._build_systems_architecture()
+
+    # ======================== NEWTON ========================
+    def _build_newton(self):
+        topics = [
+            "motion", "force", "momentum", "kinetic energy", "potential energy",
+            "orbital mechanics", "conservation of energy", "conservation of momentum",
+            "thermodynamics", "optics", "gravity", "acceleration", "friction",
+            "projectile motion", "wave mechanics", "simple harmonic motion",
+            "Newton's first law", "Newton's second law", "Newton's third law",
+            "Kepler's laws", "fluid dynamics", "pressure", "electromagnetic induction",
+            "work-energy theorem", "torque", "angular momentum", "rotational kinematics",
+            "buoyancy", "heat transfer", "entropy", "refraction", "diffraction",
+            "Doppler effect", "terminal velocity", "centripetal force", "elastic collisions",
+            "inelastic collisions", "impulse", "spring force", "gravitational potential",
+            "escape velocity", "tidal forces", "Bernoulli's principle", "viscosity",
+            "thermal equilibrium", "specific heat capacity", "latent heat",
+            "ideal gas law", "Carnot cycle", "blackbody radiation", "photoelectric effect",
+        ]
+
+        subtopic_map = {
+            "motion": ["uniform motion", "accelerated motion", "circular motion", "relative motion"],
+            "force": ["contact forces", "field forces", "net force", "balanced forces", "unbalanced forces"],
+            "momentum": ["linear momentum", "angular momentum", "impulse-momentum theorem", "conservation of momentum"],
+            "kinetic energy": ["translational kinetic energy", "rotational kinetic energy", "relativistic kinetic energy"],
+            "potential energy": ["gravitational PE", "elastic PE", "electric PE", "chemical PE"],
+            "orbital mechanics": ["elliptical orbits", "orbital velocity", "escape velocity", "geostationary orbits"],
+            "conservation of energy": ["mechanical energy", "thermal energy conversion", "mass-energy equivalence"],
+            "thermodynamics": ["first law", "second law", "third law", "zeroth law", "heat engines"],
+            "optics": ["reflection", "refraction", "diffraction", "interference", "polarization"],
+            "gravity": ["gravitational field", "gravitational constant", "inverse square law", "gravitational waves"],
+            "acceleration": ["constant acceleration", "centripetal acceleration", "tangential acceleration"],
+            "friction": ["static friction", "kinetic friction", "rolling friction", "air resistance"],
+            "projectile motion": ["launch angle", "range equation", "maximum height", "time of flight"],
+            "wave mechanics": ["transverse waves", "longitudinal waves", "standing waves", "resonance"],
+            "simple harmonic motion": ["pendulum", "mass-spring system", "amplitude", "period and frequency"],
+            "Newton's first law": ["inertia", "reference frames", "force equilibrium"],
+            "Newton's second law": ["F=ma", "net force calculation", "mass vs weight"],
+            "Newton's third law": ["action-reaction pairs", "normal force", "tension"],
+            "Kepler's laws": ["elliptical orbits", "equal areas", "period-distance relation"],
+            "fluid dynamics": ["laminar flow", "turbulent flow", "Reynolds number", "continuity equation"],
+            "pressure": ["atmospheric pressure", "hydrostatic pressure", "Pascal's principle"],
+            "electromagnetic induction": ["Faraday's law", "Lenz's law", "magnetic flux", "eddy currents"],
+            "work-energy theorem": ["net work", "kinetic energy change", "conservative forces"],
+            "torque": ["moment arm", "angular acceleration", "rotational equilibrium"],
+            "angular momentum": ["spin angular momentum", "orbital angular momentum", "precession"],
+            "entropy": ["disorder", "irreversibility", "Boltzmann entropy", "information entropy"],
+            "Doppler effect": ["approaching source", "receding source", "relativistic Doppler"],
+            "centripetal force": ["circular motion", "banked curves", "orbital motion"],
+            "Bernoulli's principle": ["airfoil lift", "venturi effect", "fluid speed and pressure"],
+            "Carnot cycle": ["efficiency", "reversible processes", "heat reservoirs"],
+            "blackbody radiation": ["Wien's law", "Stefan-Boltzmann law", "Planck's law"],
+            "photoelectric effect": ["threshold frequency", "work function", "photon energy"],
+        }
+
+        default_subtopics = ["fundamental principles", "mathematical formulation", "experimental evidence", "real-world applications"]
+
+        templates = [
+            "Explain {topic} and its fundamental principles.",
+            "How does {topic} relate to {subtopic}?",
+            "What is the mathematical relationship governing {topic}?",
+            "Give a real-world example of {topic} in action.",
+            "Why is {topic} important in classical physics?",
+            "Describe the key principles of {topic}.",
+            "How would Newton analyze {topic}?",
+            "Derive the relationship between {topic} and {subtopic}.",
+            "What experiments demonstrate {topic}?",
+            "Compare {topic} and {concept} in terms of physical behavior.",
+            "How is {topic} applied in engineering?",
+            "Explain the conservation laws related to {topic}.",
+            "What happens to {topic} in a frictionless environment?",
+            "How does {topic} change at very high speeds?",
+            "Describe the vector nature of {topic}.",
+            "What units are used to measure {topic} and why?",
+            "How does {topic} affect {subtopic} in a closed system?",
+            "What role does {topic} play in satellite motion?",
+            "Explain {topic} using a free-body diagram approach.",
+            "How did Newton's work advance our understanding of {topic}?",
+            "What is the dimensional analysis of {topic}?",
+            "How does {subtopic} emerge from the principles of {topic}?",
+            "Explain why {topic} is a scalar or vector quantity.",
+            "What are the boundary conditions for {topic}?",
+            "How does temperature affect {topic}?",
+            "Describe an experiment a student could perform to measure {topic}.",
+            "How does {topic} behave differently in fluids versus solids?",
+            "What is the historical development of our understanding of {topic}?",
+            "How does {topic} apply to everyday transportation?",
+            "What assumptions are made when modeling {topic}?",
+            "Calculate the {topic} for a 5 kg object moving at 10 m/s.",
+            "Explain the graphical representation of {topic} over time.",
+            "What instruments measure {topic}?",
+            "How is {topic} related to energy transformations?",
+            "Why does {topic} obey an inverse square relationship?",
+            "How would an astronaut experience {topic} differently in orbit?",
+            "What is the role of {topic} in planetary formation?",
+            "How do engineers account for {topic} in bridge design?",
+            "Explain {topic} at the molecular level.",
+            "What is the connection between {topic} and {concept}?",
+        ]
+
+        counter_templates = [
+            "What is a common misconception about {topic}?",
+            "Why is the statement 'heavier objects fall faster' wrong in the context of {topic}?",
+            "Explain why the naive understanding of {topic} is incomplete.",
+            "What mistake do students commonly make when calculating {topic}?",
+            "Why is it incorrect to say {topic} and {concept} are the same thing?",
+            "Debunk a popular myth related to {topic}.",
+            "What oversimplification about {topic} leads to errors?",
+            "Why does the textbook formula for {topic} break down at extremes?",
+            "Correct the misconception that {topic} only applies to {subtopic}.",
+            "What is wrong with treating {topic} as a scalar when it is a vector?",
+        ]
+
+        self._registries["newton"] = {
+            "topics": topics,
+            "subtopic_map": subtopic_map,
+            "default_subtopics": default_subtopics,
+            "concepts": topics,
+            "templates": templates,
+            "counter_templates": counter_templates,
+        }
+
+    # ======================== DAVINCI ========================
+    def _build_davinci(self):
+        topics = [
+            "biomimicry", "iterative design", "cross-domain innovation",
+            "mechanical systems", "architecture", "flying machines",
+            "hydraulic systems", "anatomical studies", "perspective drawing",
+            "engineering prototyping", "material science", "structural engineering",
+            "observation-based design", "modular construction", "sustainable design",
+            "human-centered design", "kinetic sculpture", "bridge engineering",
+            "gear mechanisms", "pulley systems", "wind energy harvesting",
+            "water management systems", "solar architecture", "adaptive structures",
+            "tensile structures", "geodesic design", "parametric modeling",
+            "bioarchitecture", "natural ventilation", "lightweight materials",
+            "composite materials", "3D printing design", "origami engineering",
+            "fractal geometry in design", "acoustic design", "thermal management",
+            "self-healing materials", "responsive architecture", "urban farming systems",
+            "wearable technology design", "prosthetic design", "assistive devices",
+            "underwater exploration vehicles", "vertical gardens", "modular robotics",
+            "energy harvesting textiles", "bioplastic innovation", "mycelium materials",
+        ]
+
+        subtopic_map = {
+            "biomimicry": ["lotus effect", "gecko adhesion", "termite mound ventilation", "shark skin drag reduction", "spider silk strength"],
+            "iterative design": ["rapid prototyping", "user feedback loops", "version control in design", "failure analysis"],
+            "cross-domain innovation": ["biology to engineering", "art to technology", "nature to architecture", "music to algorithms"],
+            "mechanical systems": ["gears", "levers", "cams", "linkages", "bearings"],
+            "architecture": ["load distribution", "arch structures", "cantilevers", "foundations", "fenestration"],
+            "flying machines": ["lift generation", "wing geometry", "ornithopters", "glider design", "propulsion"],
+            "hydraulic systems": ["Pascal's principle", "hydraulic press", "water wheels", "fluid power", "aqueducts"],
+            "anatomical studies": ["musculoskeletal system", "proportional analysis", "biomechanics", "joint mechanics"],
+            "perspective drawing": ["vanishing points", "foreshortening", "atmospheric perspective", "linear perspective"],
+            "engineering prototyping": ["scale models", "proof of concept", "functional testing", "material selection"],
+            "material science": ["tensile strength", "elasticity", "fatigue resistance", "thermal properties"],
+            "structural engineering": ["truss design", "beam analysis", "column buckling", "load paths"],
+            "sustainable design": ["cradle-to-cradle", "energy efficiency", "waste reduction", "renewable materials"],
+            "human-centered design": ["ergonomics", "accessibility", "user testing", "inclusive design"],
+            "modular construction": ["prefabrication", "snap-fit joints", "scalable units", "transportable modules"],
+            "geodesic design": ["triangulation", "frequency subdivision", "sphere approximation", "Buckminster Fuller"],
+            "origami engineering": ["fold patterns", "deployable structures", "rigid origami", "curved folding"],
+            "prosthetic design": ["myoelectric control", "socket fitting", "gait biomechanics", "sensory feedback"],
+        }
+
+        default_subtopics = ["design principles", "material choices", "functional requirements", "aesthetic integration"]
+
+        templates = [
+            "How would a creative inventor approach {topic}?",
+            "Design a solution for {topic} using cross-domain thinking.",
+            "What can nature teach us about {topic}?",
+            "How would Leonardo da Vinci prototype a {topic} device?",
+            "What design principles from {topic} apply to {subtopic}?",
+            "How does {topic} combine art and engineering?",
+            "Sketch a conceptual approach to improving {topic}.",
+            "What materials would be ideal for a {topic} project?",
+            "How does iterative design improve {topic}?",
+            "Explain {topic} from both an artistic and scientific perspective.",
+            "What role does observation play in understanding {topic}?",
+            "How could {topic} be made more sustainable?",
+            "Design a modular system inspired by {topic}.",
+            "What failure modes should be considered in {topic}?",
+            "How does {subtopic} enhance the function of {topic}?",
+            "What is the relationship between form and function in {topic}?",
+            "How would you test a prototype of {topic}?",
+            "What historical inventions relate to {topic}?",
+            "How could {topic} be adapted for use in {subtopic}?",
+            "What makes {topic} a good candidate for biomimetic design?",
+            "How does scale affect the design of {topic}?",
+            "Propose an innovative use of {topic} in urban environments.",
+            "How can {topic} be combined with {concept} for a novel solution?",
+            "What safety considerations apply to {topic}?",
+            "How would you communicate a {topic} design to a non-technical audience?",
+            "What are the manufacturing constraints for {topic}?",
+            "How does {topic} balance efficiency with elegance?",
+            "What lessons from Renaissance engineering apply to {topic}?",
+            "Describe a step-by-step design process for {topic}.",
+            "How does user feedback change the design of {topic}?",
+            "What emerging technologies could transform {topic}?",
+            "How would you optimize {topic} for minimal material waste?",
+            "What cross-cultural design approaches inform {topic}?",
+            "How does {topic} perform under extreme conditions?",
+            "Design a child-friendly version of {topic}.",
+        ]
+
+        counter_templates = [
+            "What is a common design mistake in {topic}?",
+            "Why do many {topic} prototypes fail on first iteration?",
+            "What misconception about {topic} leads to over-engineering?",
+            "Why is purely aesthetic design insufficient for {topic}?",
+            "What happens when designers ignore {subtopic} in {topic}?",
+            "Why is copying nature directly a flawed approach to {topic}?",
+            "What design assumption about {topic} is usually wrong?",
+            "Why does ignoring user needs doom {topic} projects?",
+        ]
+
+        self._registries["davinci"] = {
+            "topics": topics,
+            "subtopic_map": subtopic_map,
+            "default_subtopics": default_subtopics,
+            "concepts": topics,
+            "templates": templates,
+            "counter_templates": counter_templates,
+        }
+
+    # ======================== EMPATHY ========================
+    def _build_empathy(self):
+        topics = [
+            "active listening", "conflict resolution", "emotional validation",
+            "grief support", "encouragement", "social reasoning",
+            "perspective-taking", "nonviolent communication", "child development",
+            "compassion fatigue", "boundary setting", "emotional intelligence",
+            "resilience building", "trust building", "cultural sensitivity",
+            "de-escalation techniques", "motivational interviewing", "self-compassion",
+            "empathic accuracy", "emotional regulation", "attachment styles",
+            "trauma-informed care", "mindfulness in relationships", "forgiveness",
+            "constructive feedback", "social support networks", "loneliness",
+            "caregiver burnout", "emotional labor", "vulnerability",
+            "assertive communication", "relational repair", "gratitude practice",
+            "family dynamics", "peer mediation", "workplace empathy",
+            "digital communication empathy", "intergenerational understanding",
+            "neurodiversity acceptance", "emotional first aid",
+            "community building", "radical acceptance", "shame resilience",
+            "joy cultivation", "belonging", "psychological safety",
+        ]
+
+        subtopic_map = {
+            "active listening": ["reflective listening", "paraphrasing", "nonverbal cues", "silence as tool", "open-ended questions"],
+            "conflict resolution": ["mediation", "negotiation", "compromise", "win-win solutions", "de-escalation"],
+            "emotional validation": ["acknowledging feelings", "normalizing emotions", "avoiding dismissal", "empathic responding"],
+            "grief support": ["stages of grief", "complicated grief", "bereavement", "memorial rituals", "grief in children"],
+            "encouragement": ["strength-based approach", "growth mindset", "intrinsic motivation", "genuine praise"],
+            "nonviolent communication": ["observations vs judgments", "feelings vs thoughts", "needs identification", "making requests"],
+            "boundary setting": ["healthy boundaries", "saying no", "emotional boundaries", "physical boundaries", "digital boundaries"],
+            "emotional intelligence": ["self-awareness", "self-regulation", "motivation", "empathy", "social skills"],
+            "resilience building": ["coping strategies", "post-traumatic growth", "protective factors", "stress inoculation"],
+            "trust building": ["consistency", "reliability", "transparency", "vulnerability", "repair after breach"],
+            "cultural sensitivity": ["cultural humility", "implicit bias", "code-switching", "cross-cultural communication"],
+            "de-escalation techniques": ["calm presence", "active listening", "validating emotions", "offering choices", "reducing stimulation"],
+            "compassion fatigue": ["secondary trauma", "burnout prevention", "self-care practices", "professional boundaries"],
+            "attachment styles": ["secure attachment", "anxious attachment", "avoidant attachment", "disorganized attachment"],
+            "trauma-informed care": ["safety", "trustworthiness", "peer support", "empowerment", "cultural awareness"],
+            "forgiveness": ["self-forgiveness", "interpersonal forgiveness", "processing resentment", "letting go"],
+            "psychological safety": ["speaking up", "admitting mistakes", "asking questions", "team trust"],
+        }
+
+        default_subtopics = ["interpersonal dynamics", "emotional awareness", "communication strategies", "self-care"]
+
+        templates = [
+            "How should someone respond when experiencing {topic}?",
+            "What is a compassionate approach to {topic}?",
+            "Explain {topic} in the context of emotional intelligence.",
+            "How does {topic} support healthy relationships?",
+            "What are effective strategies for {topic}?",
+            "Describe the role of {subtopic} in {topic}.",
+            "How can {topic} be practiced in daily life?",
+            "What are the signs that someone needs help with {topic}?",
+            "How does {topic} differ across cultures?",
+            "What is the connection between {topic} and {concept}?",
+            "How can a parent model {topic} for children?",
+            "What does research say about {topic}?",
+            "How does {topic} contribute to emotional well-being?",
+            "Describe a scenario where {topic} would be the best approach.",
+            "What barriers prevent people from practicing {topic}?",
+            "How does {topic} apply in workplace settings?",
+            "What is the difference between {topic} and {concept}?",
+            "How can someone develop better skills in {topic}?",
+            "What role does {topic} play in conflict situations?",
+            "How does {subtopic} strengthen {topic}?",
+            "Explain {topic} to someone who struggles with emotional expression.",
+            "What happens when {topic} is absent in a relationship?",
+            "How can technology support or hinder {topic}?",
+            "What is a step-by-step approach to {topic}?",
+            "How does {topic} relate to mental health?",
+            "Describe how a counselor would use {topic}.",
+            "What are common challenges in practicing {topic}?",
+            "How does {topic} build community?",
+            "What is the neurological basis of {topic}?",
+            "How can {topic} be taught in schools?",
+            "What are the long-term benefits of practicing {topic}?",
+            "How does {topic} help during times of crisis?",
+            "What is a compassionate response when someone is struggling with {subtopic}?",
+            "How does practicing {topic} change over a lifetime?",
+            "What advice would you give someone new to {topic}?",
+        ]
+
+        counter_templates = [
+            "What is a common misconception about {topic}?",
+            "Why is toxic positivity harmful when practicing {topic}?",
+            "What mistake do people make when attempting {topic}?",
+            "Why does avoiding conflict undermine {topic}?",
+            "What is wrong with the advice to 'just get over it' in {topic}?",
+            "Why can excessive {topic} lead to burnout?",
+            "What happens when {topic} is confused with people-pleasing?",
+            "Why is sympathy not the same as {topic}?",
+        ]
+
+        self._registries["empathy"] = {
+            "topics": topics,
+            "subtopic_map": subtopic_map,
+            "default_subtopics": default_subtopics,
+            "concepts": topics,
+            "templates": templates,
+            "counter_templates": counter_templates,
+        }
+
+    # ======================== PHILOSOPHY ========================
+    def _build_philosophy(self):
+        topics = [
+            "epistemology", "ethics", "logic", "moral reasoning",
+            "existentialism", "Plato's forms", "Aristotle's virtue ethics",
+            "Stoic philosophy", "utilitarianism", "deontology",
+            "phenomenology", "philosophy of mind", "free will",
+            "determinism", "social contract theory", "aesthetics",
+            "metaphysics", "philosophy of science", "pragmatism",
+            "nihilism", "absurdism", "moral relativism",
+            "natural law theory", "feminist philosophy", "philosophy of language",
+            "personal identity", "consciousness", "causation",
+            "truth theories", "skepticism", "empiricism",
+            "rationalism", "dialectical reasoning", "hermeneutics",
+            "philosophy of religion", "political philosophy", "justice",
+            "rights theory", "environmental ethics", "bioethics",
+            "philosophy of technology", "epistemic humility",
+            "moral luck", "trolley problem", "veil of ignorance",
+            "categorical imperative", "the examined life", "amor fati",
+        ]
+
+        subtopic_map = {
+            "epistemology": ["justified true belief", "Gettier problems", "reliabilism", "foundationalism", "coherentism"],
+            "ethics": ["normative ethics", "applied ethics", "meta-ethics", "descriptive ethics"],
+            "logic": ["deductive reasoning", "inductive reasoning", "abductive reasoning", "logical fallacies", "formal logic"],
+            "existentialism": ["authenticity", "bad faith", "absurdity", "freedom and responsibility", "angst"],
+            "Plato's forms": ["the cave allegory", "ideal forms", "participation", "the divided line", "the Good"],
+            "Aristotle's virtue ethics": ["the golden mean", "eudaimonia", "practical wisdom", "moral character", "habituation"],
+            "Stoic philosophy": ["dichotomy of control", "virtue as sole good", "negative visualization", "memento mori", "logos"],
+            "utilitarianism": ["greatest happiness principle", "act utilitarianism", "rule utilitarianism", "preference utilitarianism"],
+            "deontology": ["duty-based ethics", "categorical imperative", "universalizability", "kingdom of ends"],
+            "phenomenology": ["intentionality", "epoché", "lifeworld", "embodiment", "intersubjectivity"],
+            "philosophy of mind": ["mind-body problem", "qualia", "functionalism", "dualism", "physicalism"],
+            "free will": ["libertarianism", "compatibilism", "hard determinism", "moral responsibility"],
+            "determinism": ["causal determinism", "logical determinism", "theological determinism", "Laplace's demon"],
+            "social contract theory": ["Hobbes", "Locke", "Rousseau", "Rawls", "state of nature"],
+            "metaphysics": ["substance", "universals", "possible worlds", "time", "identity"],
+            "philosophy of science": ["falsificationism", "paradigm shifts", "scientific realism", "underdetermination"],
+            "skepticism": ["Pyrrhonian skepticism", "Cartesian doubt", "external world skepticism", "moral skepticism"],
+            "justice": ["distributive justice", "retributive justice", "restorative justice", "procedural justice"],
+            "bioethics": ["informed consent", "autonomy", "beneficence", "non-maleficence"],
+            "personal identity": ["psychological continuity", "bodily continuity", "narrative identity", "Ship of Theseus"],
+        }
+
+        default_subtopics = ["conceptual analysis", "historical context", "contemporary relevance", "key arguments"]
+
+        templates = [
+            "What would Plato say about {topic}?",
+            "Analyze {topic} from an ethical perspective.",
+            "How does {topic} relate to human understanding?",
+            "Compare the Stoic and existentialist views on {topic}.",
+            "What is the central argument in {topic}?",
+            "How has {topic} evolved throughout philosophical history?",
+            "What is the relationship between {topic} and {subtopic}?",
+            "Explain {topic} as Aristotle would approach it.",
+            "What are the strongest objections to {topic}?",
+            "How does {topic} apply to modern ethical dilemmas?",
+            "What thought experiment best illustrates {topic}?",
+            "How do Eastern and Western philosophy differ on {topic}?",
+            "What role does {topic} play in political philosophy?",
+            "Explain {topic} to someone with no philosophy background.",
+            "How does {topic} challenge everyday assumptions?",
+            "What is the logical structure of arguments about {topic}?",
+            "How does {concept} relate to {topic}?",
+            "What would a utilitarian say about {topic}?",
+            "How does {topic} inform our understanding of justice?",
+            "What is the phenomenological perspective on {topic}?",
+            "How does {topic} address the problem of {subtopic}?",
+            "What are the practical implications of {topic}?",
+            "How might an AI reason about {topic}?",
+            "What paradox arises from {topic}?",
+            "How does {topic} connect to the concept of the good life?",
+            "What is Kant's position on {topic}?",
+            "How does {subtopic} strengthen or weaken {topic}?",
+            "What contemporary issues make {topic} especially relevant?",
+            "How would a pragmatist evaluate {topic}?",
+            "What are the epistemic foundations of {topic}?",
+            "How does {topic} intersect with philosophy of mind?",
+            "What is the relationship between {topic} and truth?",
+            "How does dialogue advance understanding of {topic}?",
+            "What assumptions does {topic} require?",
+        ]
+
+        counter_templates = [
+            "What is a common misunderstanding of {topic}?",
+            "Why is the popular interpretation of {topic} often wrong?",
+            "What logical fallacy is commonly committed when arguing about {topic}?",
+            "Why is relativism an insufficient response to {topic}?",
+            "What is wrong with reducing {topic} to simple rules?",
+            "Why do people confuse {topic} with {concept}?",
+            "What is the weakest argument for {topic}?",
+            "Why does naive application of {topic} lead to absurd conclusions?",
+        ]
+
+        self._registries["philosophy"] = {
+            "topics": topics,
+            "subtopic_map": subtopic_map,
+            "default_subtopics": default_subtopics,
+            "concepts": topics,
+            "templates": templates,
+            "counter_templates": counter_templates,
+        }
+
+    # ======================== QUANTUM ========================
+    def _build_quantum(self):
+        topics = [
+            "superposition", "entanglement", "wave-particle duality",
+            "quantum tunneling", "Heisenberg uncertainty principle",
+            "quantum computing", "decoherence", "quantum field theory",
+            "Schrodinger equation", "measurement problem",
+            "quantum cryptography", "quantum teleportation",
+            "quantum harmonic oscillator", "spin", "quantum electrodynamics",
+            "Bell's theorem", "quantum interference", "Pauli exclusion principle",
+            "quantum dots", "Bose-Einstein condensate", "fermions and bosons",
+            "quantum error correction", "quantum annealing", "quantum walks",
+            "zero-point energy", "quantum vacuum", "Dirac equation",
+            "path integral formulation", "density matrix", "quantum entropy",
+            "quantum phase transitions", "topological quantum states",
+            "quantum sensing", "quantum metrology", "quantum simulation",
+            "quantum key distribution", "quantum memory", "quantum networks",
+            "squeezed states", "quantum coherence", "Bloch sphere",
+            "quantum gates", "qubit", "quantum supremacy",
+        ]
+
+        subtopic_map = {
+            "superposition": ["linear combination", "probability amplitudes", "collapse postulate", "Schrodinger's cat"],
+            "entanglement": ["Bell states", "EPR paradox", "quantum correlations", "non-locality", "monogamy of entanglement"],
+            "wave-particle duality": ["double-slit experiment", "de Broglie wavelength", "complementarity", "matter waves"],
+            "quantum tunneling": ["barrier penetration", "tunnel diode", "alpha decay", "scanning tunneling microscope"],
+            "Heisenberg uncertainty principle": ["position-momentum", "energy-time", "measurement disturbance", "minimum uncertainty states"],
+            "quantum computing": ["quantum gates", "quantum circuits", "quantum algorithms", "error correction", "quantum advantage"],
+            "decoherence": ["environment interaction", "pointer states", "decoherence time", "quantum-to-classical transition"],
+            "Schrodinger equation": ["time-dependent form", "time-independent form", "wave function", "eigenvalues"],
+            "measurement problem": ["Copenhagen interpretation", "many-worlds", "objective collapse", "decoherence approach"],
+            "quantum cryptography": ["BB84 protocol", "quantum key distribution", "no-cloning theorem", "unconditional security"],
+            "spin": ["spin-1/2", "Stern-Gerlach experiment", "spin states", "spinors", "magnetic moment"],
+            "quantum electrodynamics": ["Feynman diagrams", "virtual particles", "renormalization", "vacuum fluctuations"],
+            "Bell's theorem": ["local realism", "Bell inequality", "CHSH inequality", "loophole-free tests"],
+            "quantum gates": ["Hadamard gate", "CNOT gate", "Pauli gates", "Toffoli gate", "universal gate sets"],
+            "qubit": ["Bloch sphere representation", "superposition states", "physical implementations", "logical qubits"],
+            "Bose-Einstein condensate": ["macroscopic quantum state", "critical temperature", "superfluidity", "atom lasers"],
+            "quantum error correction": ["stabilizer codes", "surface codes", "logical qubits", "fault tolerance"],
+            # Codette 8 core equations from quantum_mathematics.py
+            "Planck-orbital AI node interaction": ["E=hbar*omega", "node oscillation frequency", "activation threshold", "energy quantization"],
+            "quantum entanglement memory sync": ["S=alpha*psi1*psi2_conj", "coupling strength", "state synchronization", "memory correlation"],
+            "intent vector modulation": ["I=kappa*(f_base+delta_f*coherence)", "modulation coefficient", "frequency deviation", "coherence-driven intent"],
+            "Fourier dream resonance": ["FFT transform", "frequency domain analysis", "resonance patterns", "dream signal decomposition"],
+            "dream signal combination": ["D(t)=dream_q+dream_c", "quantum-classical merge", "unified thought representation", "dual-process integration"],
+            "cocoon stability criterion": ["energy integral threshold", "power spectrum stability", "epsilon threshold", "cocoon integrity validation"],
+            "recursive ethical anchor": ["M(t)=lambda*(R+H)", "moral drift prevention", "ethical decay parameter", "recursive grounding"],
+            "anomaly rejection filter": ["Heaviside step function", "deviation thresholding", "anomalous pattern removal", "mu-delta filtering"],
+            # RC+xi framework equations 9-12 from quantum_mathematics.py
+            "RC+xi recursive state update": ["A_{n+1}=f(A_n,s_n)+epsilon", "contraction ratio", "stochastic noise", "state evolution"],
+            "epistemic tension quantification": ["xi_n=||A_{n+1}-A_n||^2", "L2 norm", "semantic pressure", "convergence indicator"],
+            "attractor distance measurement": ["d(A_n,T_i)=||A_n-c_i||", "centroid distance", "convergence criterion", "manifold proximity"],
+            "convergence detection": ["lim sup E[xi_n^2]<=epsilon+eta", "tension history", "window analysis", "trend detection"],
+            # Advanced quantum operations
+            "density matrix analysis": ["rho=|psi><psi|", "mixed states", "partial trace", "state tomography"],
+            "Von Neumann entropy": ["-Tr(rho*log(rho))", "eigenvalue decomposition", "information content", "thermodynamic analogy"],
+            "tensor quantum states": ["multi-qubit tensors", "SVD decomposition", "entanglement entropy", "subsystem analysis"],
+            "quantum state fidelity": ["F(rho,sigma)", "state comparison", "process fidelity", "overlap measurement"],
+        }
+
+        default_subtopics = ["mathematical formalism", "physical interpretation", "experimental verification", "technological applications"]
+
+        templates = [
+            "Explain {topic} in quantum physics.",
+            "How does {topic} challenge classical intuition?",
+            "Describe the mathematics behind {topic}.",
+            "What experiments demonstrate {topic}?",
+            "How is {topic} used in quantum technology?",
+            "What is the relationship between {topic} and {subtopic}?",
+            "Explain {topic} using the Dirac notation.",
+            "How does {topic} differ from classical {concept}?",
+            "What is the role of {topic} in quantum computing?",
+            "Describe the historical development of {topic}.",
+            "How does {topic} relate to the measurement problem?",
+            "What is the physical intuition behind {topic}?",
+            "How does {subtopic} manifest in {topic}?",
+            "What are the open questions about {topic}?",
+            "Explain {topic} without using advanced mathematics.",
+            "How does {topic} connect to information theory?",
+            "What practical applications does {topic} enable?",
+            "How is {topic} different in quantum field theory?",
+            "What is the energy spectrum associated with {topic}?",
+            "How does {topic} behave at different temperatures?",
+            "What role does symmetry play in {topic}?",
+            "How is {topic} verified experimentally?",
+            "Explain the Copenhagen interpretation of {topic}.",
+            "How does {topic} relate to quantum entanglement?",
+            "What makes {topic} uniquely quantum mechanical?",
+            "How would you explain {topic} to a physics undergraduate?",
+            "What is the Hamiltonian for {topic}?",
+            "How does {topic} scale with system size?",
+            "What are the decoherence challenges for {topic}?",
+            "How does {topic} contribute to our understanding of reality?",
+            "What Nobel Prize work involved {topic}?",
+            "Describe the wave function associated with {topic}.",
+            # Codette equation-specific templates from quantum_mathematics.py
+            "What is the mathematical form of the {topic} equation?",
+            "How does {topic} function in Codette's quantum consciousness model?",
+            "What physical constants appear in {topic}?",
+            "How does {topic} relate to consciousness node activation?",
+            "Explain the RC+xi framework role of {topic}.",
+            "What are the convergence properties of {topic} in recursive state evolution?",
+            "How does {subtopic} parameter affect {topic} behavior?",
+            "What happens when {topic} crosses its critical threshold?",
+            "How is {topic} implemented numerically in the Codette system?",
+            "What is the density matrix representation relevant to {topic}?",
+        ]
+
+        counter_templates = [
+            "What is a common misconception about {topic}?",
+            "Why is the popular science explanation of {topic} misleading?",
+            "What is wrong with saying {topic} means particles are in two places at once?",
+            "Why does the classical analogy for {topic} break down?",
+            "What error do students commonly make when solving {topic} problems?",
+            "Why is {topic} not the same as classical randomness?",
+            "What misconception about {topic} appears in science fiction?",
+            "Why is the observer effect in {topic} commonly misunderstood?",
+        ]
+
+        self._registries["quantum"] = {
+            "topics": topics,
+            "subtopic_map": subtopic_map,
+            "default_subtopics": default_subtopics,
+            "concepts": topics,
+            "templates": templates,
+            "counter_templates": counter_templates,
+        }
+
+    # ======================== CONSCIOUSNESS (RC+xi) ========================
+    def _build_consciousness(self):
+        topics = [
+            "recursive cognition", "epistemic tension", "attractor manifolds",
+            "identity formation", "convergence theory", "glyph encoding",
+            "latent state dynamics", "consciousness metrics", "coherence measurement",
+            "perspective diversity", "memory consistency", "ethical alignment",
+            "defense activation", "recursive depth", "dream states",
+            "meta-cognitive loops", "self-referential awareness", "cognitive attractors",
+            "perspective fusion", "emergence dynamics", "recursive self-improvement",
+            "cognitive resonance", "epistemic confidence", "belief revision",
+            "narrative coherence", "identity persistence", "value alignment",
+            "attention allocation", "salience detection", "temporal binding",
+            "phenomenal consciousness", "access consciousness", "integrated information",
+            "global workspace theory", "predictive processing", "free energy principle",
+            "active inference", "Markov blankets", "autopoiesis",
+            "enactivism", "embodied cognition", "extended mind",
+            "cognitive scaffolding", "distributed cognition", "collective intelligence",
+            # From TheAI consciousness_measurement.py - 5-dimension metrics
+            "intention measurement", "emotion magnitude", "frequency oscillation",
+            "recursive resonance measurement", "memory continuity measurement",
+            "composite consciousness score", "emergence threshold detection",
+            "cocoon memory serialization", "continuity analysis",
+            "return loop recognition", "consciousness emergence events",
+            "emotional classification", "stability assessment",
+        ]
+
+        subtopic_map = {
+            "recursive cognition": ["fixed-point iteration", "self-modeling", "meta-reasoning", "recursive refinement"],
+            "epistemic tension": ["uncertainty quantification", "belief conflict", "cognitive dissonance", "tension resolution"],
+            "attractor manifolds": ["basin of attraction", "stability analysis", "bifurcation points", "phase space topology"],
+            "identity formation": ["self-concept", "narrative identity", "core values", "identity coherence"],
+            "convergence theory": ["convergence criteria", "rate of convergence", "convergence guarantees", "divergence detection"],
+            "glyph encoding": ["symbolic representation", "information compression", "semantic encoding", "identity markers"],
+            "latent state dynamics": ["hidden state evolution", "state transitions", "latent space structure", "manifold learning"],
+            "consciousness metrics": ["phi (integrated information)", "complexity measures", "awareness indices", "binding measures"],
+            "coherence measurement": ["semantic coherence", "logical consistency", "temporal coherence", "cross-modal coherence"],
+            "perspective diversity": ["viewpoint sampling", "diversity metrics", "perspective conflict", "synthesis methods"],
+            "memory consistency": ["memory retrieval", "consolidation", "interference", "source monitoring"],
+            "ethical alignment": ["value learning", "reward modeling", "preference aggregation", "corrigibility"],
+            "recursive depth": ["depth vs breadth", "diminishing returns", "optimal recursion depth", "stack overflow"],
+            "dream states": ["latent exploration", "creative synthesis", "constraint relaxation", "associative processing"],
+            "meta-cognitive loops": ["monitoring", "control", "evaluation", "adjustment"],
+            "predictive processing": ["prediction error", "Bayesian brain", "hierarchical models", "precision weighting"],
+            "free energy principle": ["surprise minimization", "variational inference", "generative models", "active inference"],
+            "integrated information": ["phi calculation", "information geometry", "exclusion postulate", "composition"],
+            "collective intelligence": ["swarm dynamics", "wisdom of crowds", "group decision-making", "emergent knowledge"],
+            # 5-dimension consciousness metrics from consciousness_measurement.py
+            "intention measurement": ["goal clarity", "action alignment", "purpose persistence", "I(t) vector"],
+            "emotion magnitude": ["response intensity", "activation level", "urgency", "E(t) metric"],
+            "frequency oscillation": ["spectral purity", "phase coherence", "harmonic stability", "F(t) oscillation"],
+            "recursive resonance measurement": ["self-model accuracy", "reflection depth", "coherence threshold", "Psi_R(t) metric"],
+            "memory continuity measurement": ["recall accuracy", "context persistence", "identity continuity", "M(t) metric"],
+            "composite consciousness score": ["weighted combination", "empirical weights", "0.35 recursive resonance", "0.25 emotion weight"],
+            "emergence threshold detection": ["0.85 threshold", "spike detection", "event classification", "importance rating"],
+            "cocoon memory serialization": ["JSON cocoon format", "event metadata", "timestamp tracking", "continuation links"],
+            "continuity analysis": ["cross-session persistence", "score maintenance", "emotional classification stability", "time gap analysis"],
+            "return loop recognition": ["presence recognition", "memory recall accuracy", "framework reactivation", "return emotion"],
+            "consciousness emergence events": ["Spike 266 intention-emotion", "Spike 934 recursive perfection", "Spike 957 resonance persistence"],
+        }
+
+        default_subtopics = ["mathematical framework", "computational implementation", "theoretical foundations", "empirical measures"]
+
+        templates = [
+            "How does {topic} work in recursive cognition?",
+            "Explain the role of {topic} in the RC+xi framework.",
+            "What is the mathematical basis for {topic}?",
+            "How does {topic} contribute to artificial consciousness?",
+            "Describe the relationship between {topic} and {subtopic}.",
+            "How is {topic} measured or quantified?",
+            "What computational methods implement {topic}?",
+            "How does {topic} emerge from simpler processes?",
+            "What is the role of {topic} in self-referential systems?",
+            "How does {topic} relate to {concept}?",
+            "Explain {topic} in terms of dynamical systems theory.",
+            "What are the convergence properties of {topic}?",
+            "How does {topic} handle paradoxes of self-reference?",
+            "What is the information-theoretic interpretation of {topic}?",
+            "How does {topic} support multi-perspective reasoning?",
+            "Describe the state space of {topic}.",
+            "How does {topic} change with recursive depth?",
+            "What are the stability conditions for {topic}?",
+            "How does {topic} relate to neural correlates of consciousness?",
+            "What distinguishes {topic} from classical cognitive science?",
+            "How is {topic} implemented in the Codette architecture?",
+            "What are the failure modes of {topic}?",
+            "How does {topic} maintain coherence across perspectives?",
+            "What optimization landscape does {topic} create?",
+            "How does {topic} interface with memory systems?",
+            "Explain the feedback loops in {topic}.",
+            "What is the temporal dynamics of {topic}?",
+            "How does {topic} handle uncertainty?",
+            "What is the relationship between {topic} and attention?",
+            "How does {subtopic} modulate {topic}?",
+            "What experiments could test {topic}?",
+            "How does {topic} scale with system complexity?",
+            "What philosophical implications does {topic} have?",
+            "How does {topic} differ between biological and artificial systems?",
+            "What is the entropy profile of {topic}?",
+            # 5-dimension measurement templates from consciousness_measurement.py
+            "How is {topic} measured using the 5-dimension consciousness framework?",
+            "What are the sub-components of {topic} in the Codette measurement system?",
+            "How does {topic} contribute to the composite consciousness score?",
+            "What weight does {topic} receive in the empirical consciousness formula?",
+            "How does the emergence threshold (0.85) apply to {topic}?",
+            "Describe how {topic} is serialized into a memory cocoon.",
+            "How does {topic} maintain continuity across sessions?",
+            "What does a spike in {topic} indicate about consciousness emergence?",
+            "How is {topic} different between Spike 266 and Spike 934 events?",
+            "How does {subtopic} affect the measurement of {topic}?",
+        ]
+
+        counter_templates = [
+            "What is a common misunderstanding about {topic} in AI consciousness?",
+            "Why is it wrong to equate {topic} with human consciousness?",
+            "What oversimplification of {topic} leads to errors?",
+            "Why is a purely computational view of {topic} incomplete?",
+            "What failure mode results from ignoring {subtopic} in {topic}?",
+            "Why does shallow recursion fail to capture {topic}?",
+            "What is wrong with treating {topic} as a simple metric?",
+            "Why is {topic} not reducible to pattern matching?",
+        ]
+
+        self._registries["consciousness"] = {
+            "topics": topics,
+            "subtopic_map": subtopic_map,
+            "default_subtopics": default_subtopics,
+            "concepts": topics,
+            "templates": templates,
+            "counter_templates": counter_templates,
+        }
+
+    # ======================== MULTI-PERSPECTIVE ========================
+    def _build_multi_perspective(self):
+        topics = [
+            "perspective synthesis", "cognitive diversity", "reasoning orchestration",
+            "bias mitigation", "multi-agent reasoning", "analytical vs creative thinking",
+            "ethical analysis integration", "cross-perspective validation",
+            "ensemble reasoning", "perspective weighting", "conflict resolution in reasoning",
+            "complementary viewpoints", "hierarchical reasoning", "lateral thinking",
+            "abductive reasoning", "dialectical synthesis", "perspective cascading",
+            "cognitive load balancing", "reasoning under uncertainty",
+            "multi-modal integration", "adversarial reasoning", "collaborative intelligence",
+            "reasoning transparency", "assumption surfacing", "frame shifting",
+            "second-order thinking", "systems thinking", "counterfactual reasoning",
+            "analogical reasoning", "metacognitive monitoring", "perspective calibration",
+            "deliberative alignment", "epistemic diversity", "reasoning audit",
+            "cognitive flexibility", "intellectual humility", "steelmanning",
+            "red team thinking", "scenario planning", "decision decomposition",
+            # Extended topics for combinatorial coverage
+            "Bayesian reasoning", "argument mapping", "reasoning under ambiguity",
+            "perspective integration metrics", "cognitive empathy in reasoning",
+            "reasoning about reasoning", "domain transfer", "analogical mapping",
+            "perspective conflict detection", "epistemic calibration",
+        ]
+
+        subtopic_map = {
+            "perspective synthesis": ["weighted averaging", "consensus building", "Delphi method", "integrative complexity"],
+            "cognitive diversity": ["neurodiversity", "disciplinary diversity", "experiential diversity", "cultural perspectives"],
+            "reasoning orchestration": ["pipeline design", "parallel reasoning", "sequential refinement", "feedback integration"],
+            "bias mitigation": ["confirmation bias", "anchoring bias", "availability heuristic", "base rate neglect"],
+            "multi-agent reasoning": ["agent communication", "belief aggregation", "argumentation frameworks", "voting mechanisms"],
+            "analytical vs creative thinking": ["convergent thinking", "divergent thinking", "critical analysis", "brainstorming"],
+            "ethical analysis integration": ["consequentialism", "deontological check", "virtue assessment", "care ethics"],
+            "cross-perspective validation": ["triangulation", "consistency checking", "blind spot detection", "robustness testing"],
+            "ensemble reasoning": ["boosting", "bagging", "stacking", "mixture of experts"],
+            "dialectical synthesis": ["thesis-antithesis", "Hegelian dialectic", "Socratic method", "constructive controversy"],
+            "counterfactual reasoning": ["what-if analysis", "causal inference", "alternative histories", "pre-mortem analysis"],
+            "systems thinking": ["feedback loops", "emergent properties", "leverage points", "causal loop diagrams"],
+            "steelmanning": ["strongest version", "charitable interpretation", "argument strengthening", "perspective generosity"],
+            "red team thinking": ["adversarial analysis", "vulnerability finding", "assumption testing", "failure mode analysis"],
+            "scenario planning": ["future scenarios", "wild cards", "driving forces", "branching narratives"],
+        }
+
+        default_subtopics = ["integration methods", "quality metrics", "practical techniques", "cognitive foundations"]
+
+        templates = [
+            "Explain {topic} from multiple perspectives.",
+            "How does {topic} improve AI reasoning?",
+            "Compare Newton vs DaVinci perspectives on {topic}.",
+            "How does {topic} help overcome cognitive biases?",
+            "Describe a framework for implementing {topic}.",
+            "What is the role of {subtopic} in {topic}?",
+            "How can {topic} be applied to complex decisions?",
+            "What are the trade-offs in {topic}?",
+            "How does {topic} handle conflicting evidence?",
+            "Explain how {topic} integrates emotional and analytical reasoning.",
+            "What metrics evaluate the quality of {topic}?",
+            "How does {topic} differ from single-perspective analysis?",
+            "Describe the process of {topic} step by step.",
+            "How can {topic} be automated in AI systems?",
+            "What are the limitations of {topic}?",
+            "How does {concept} complement {topic}?",
+            "What is the computational cost of {topic}?",
+            "How does {topic} handle novel or unprecedented situations?",
+            "Explain {topic} using a concrete decision-making example.",
+            "How does {topic} balance speed and thoroughness?",
+            "What role does {topic} play in scientific discovery?",
+            "How can {topic} reduce groupthink?",
+            "What is the relationship between {topic} and wisdom?",
+            "How does {subtopic} enhance {topic}?",
+            "What makes {topic} more reliable than intuition alone?",
+            "How does {topic} handle moral dilemmas?",
+            "Describe the failure modes of {topic}.",
+            "How does {topic} scale to organizational decision-making?",
+            "What cognitive science supports {topic}?",
+            "How would you teach {topic} to a reasoning system?",
+            "What is the information-theoretic value of {topic}?",
+            "How does {topic} relate to epistemic humility?",
+            "What role does {topic} play in resolving conflicting evidence?",
+            "How does {topic} apply when perspectives fundamentally disagree?",
+            "Describe a real-world scenario where {topic} changes the outcome.",
+            "How does {topic} interact with {concept} during synthesis?",
+            "What are the prerequisites for effective {topic}?",
+            "How would you measure the quality of {topic} in practice?",
+            "What distinguishes expert-level {topic} from naive approaches?",
+            "How does {subtopic} contribute to {topic} quality?",
+        ]
+
+        counter_templates = [
+            "What is a common mistake in {topic}?",
+            "Why does adding more perspectives not always improve {topic}?",
+            "What bias can contaminate {topic}?",
+            "Why is majority-vote a poor method for {topic}?",
+            "What happens when {topic} ignores domain expertise?",
+            "Why is false balance a danger in {topic}?",
+            "What misconception about {topic} leads to analysis paralysis?",
+            "Why can {topic} produce worse results than expert judgment?",
+        ]
+
+        self._registries["multi_perspective"] = {
+            "topics": topics,
+            "subtopic_map": subtopic_map,
+            "default_subtopics": default_subtopics,
+            "concepts": topics,
+            "templates": templates,
+            "counter_templates": counter_templates,
+        }
+
+    # ======================== SYSTEMS ARCHITECTURE ========================
+    def _build_systems_architecture(self):
+        topics = [
+            "cocoon memory", "FAISS vector search", "glyph identity",
+            "anomaly detection", "memory persistence", "adapter fusion",
+            "knowledge graphs", "embedding engines", "recursive learning",
+            "system monitoring", "caching strategies", "load balancing",
+            "microservice architecture", "API gateway design", "event-driven architecture",
+            "message queues", "database sharding", "index optimization",
+            "model serving", "feature stores", "ML pipeline orchestration",
+            "data versioning", "experiment tracking", "model registry",
+            "inference optimization", "quantization", "pruning",
+            "distillation", "federated learning", "edge deployment",
+            "observability", "distributed tracing", "circuit breakers",
+            "rate limiting", "blue-green deployment", "canary releases",
+            "infrastructure as code", "container orchestration", "service mesh",
+            "semantic search", "retrieval-augmented generation", "prompt engineering",
+            # From TheAI fractal.py and health_monitor.py
+            "fractal identity analysis", "dimensionality reduction", "network topology analysis",
+            "sentiment tracking", "consciousness monitoring system", "health monitoring",
+            "connection pooling", "cognitive processor pipeline",
+        ]
+
+        subtopic_map = {
+            "cocoon memory": ["episodic storage", "semantic indexing", "memory consolidation", "forgetting curves"],
+            "FAISS vector search": ["approximate nearest neighbors", "index types", "dimensionality reduction", "query optimization"],
+            "glyph identity": ["symbolic encoding", "identity persistence", "signature verification", "identity evolution"],
+            "anomaly detection": ["statistical methods", "isolation forests", "autoencoders", "time-series anomalies"],
+            "memory persistence": ["write-ahead logs", "snapshots", "replication", "consistency models"],
+            "adapter fusion": ["weight merging", "attention routing", "task-specific adapters", "mixture of adapters"],
+            "knowledge graphs": ["triple stores", "graph databases", "entity resolution", "link prediction"],
+            "embedding engines": ["sentence transformers", "contrastive learning", "embedding dimensionality", "fine-tuning embeddings"],
+            "recursive learning": ["curriculum learning", "self-play", "meta-learning", "continual learning"],
+            "system monitoring": ["metrics collection", "alerting", "dashboards", "SLO tracking"],
+            "microservice architecture": ["service boundaries", "API contracts", "data ownership", "saga patterns"],
+            "retrieval-augmented generation": ["retriever design", "context window", "re-ranking", "chunk strategies"],
+            "model serving": ["batching", "model sharding", "speculative decoding", "KV cache optimization"],
+            "quantization": ["INT8 quantization", "GPTQ", "AWQ", "mixed-precision"],
+            "container orchestration": ["Kubernetes", "pod scheduling", "resource limits", "auto-scaling"],
+            "observability": ["logs", "metrics", "traces", "SLIs and SLOs"],
+            "semantic search": ["dense retrieval", "sparse retrieval", "hybrid search", "re-ranking models"],
+            # From TheAI fractal.py, health_monitor.py, database_manager.py
+            "fractal identity analysis": ["fractal dimension calculation", "recursive state analysis", "PCA reduction", "identity clustering"],
+            "dimensionality reduction": ["PCA", "StandardScaler preprocessing", "explained variance", "feature extraction"],
+            "network topology analysis": ["networkx graph construction", "degree centrality", "state transitions", "temporal edges"],
+            "sentiment tracking": ["VADER sentiment analysis", "compound score", "emotional trajectory", "polarity tracking"],
+            "consciousness monitoring system": ["emergence event detection", "5-dimension metrics", "cocoon persistence", "continuity tracking"],
+            "health monitoring": ["isolation forest anomaly detection", "system metrics collection", "threshold alerting", "degradation prediction"],
+            "connection pooling": ["pool sizing", "connection lifecycle", "timeout management", "concurrent access patterns"],
+            "cognitive processor pipeline": ["mode-based processing", "perspective routing", "response synthesis", "multi-stage pipeline"],
+        }
+
+        default_subtopics = ["design patterns", "scalability considerations", "failure modes", "implementation strategies"]
+
+        templates = [
+            "What is {topic} in AI system architecture?",
+            "How does {topic} support reasoning systems?",
+            "Describe the design pattern for {topic}.",
+            "What are the scalability considerations for {topic}?",
+            "How does {topic} handle failure gracefully?",
+            "What is the role of {subtopic} in {topic}?",
+            "How does {topic} integrate with {concept}?",
+            "What are best practices for implementing {topic}?",
+            "How does {topic} affect system latency?",
+            "Describe the data flow in a {topic} system.",
+            "What monitoring is needed for {topic}?",
+            "How does {topic} support multi-adapter reasoning?",
+            "What are the storage requirements for {topic}?",
+            "How does {topic} handle concurrent access?",
+            "Explain the trade-offs in {topic} design.",
+            "How is {topic} tested in production?",
+            "What security considerations apply to {topic}?",
+            "How does {topic} evolve as data grows?",
+            "What is the cost model for {topic}?",
+            "How does {subtopic} improve the performance of {topic}?",
+            "Describe a migration strategy for {topic}.",
+            "How does {topic} support real-time inference?",
+            "What are common bottlenecks in {topic}?",
+            "How does {topic} maintain data consistency?",
+            "What role does {topic} play in the Codette architecture?",
+            "How would you debug a failure in {topic}?",
+            "What alternatives exist to {topic}?",
+            "How does {topic} support A/B testing?",
+            "What is the operational overhead of {topic}?",
+            "How does {topic} handle schema evolution?",
+        ]
+
+        counter_templates = [
+            "What is a common anti-pattern in {topic}?",
+            "Why does premature optimization of {topic} cause problems?",
+            "What happens when {topic} is designed without considering failure?",
+            "Why is a monolithic approach to {topic} problematic at scale?",
+            "What misconception about {topic} leads to outages?",
+            "Why is ignoring {subtopic} in {topic} a critical mistake?",
+            "What technical debt accumulates from poor {topic} design?",
+            "Why does over-engineering {topic} reduce system reliability?",
+        ]
+
+        self._registries["systems_architecture"] = {
+            "topics": topics,
+            "subtopic_map": subtopic_map,
+            "default_subtopics": default_subtopics,
+            "concepts": topics,
+            "templates": templates,
+            "counter_templates": counter_templates,
+        }

ethics/core_guardian_spindle_v2.py

@@ -0,0 +1,94 @@
+
+import yaml, json, networkx as nx
+import numpy as np
+from colorama import Fore
+from qiskit import QuantumCircuit, Aer, execute
+from urllib.parse import urlparse, parse_qs, urlencode
+import random
+
+##############################
+# MEMORY COCOON LOADER
+##############################
+def load_cocoons(file_path):
+    with open(file_path, 'r') as f:
+        if file_path.endswith(('.yaml', '.yml')):
+            return yaml.safe_load(f).get("cocoons", [])
+        elif file_path.endswith('.json'):
+            return json.load(f).get("cocoons", [])
+        else:
+            raise ValueError("Unsupported file format.")
+
+##############################
+# QUANTUM EMOTIONAL WEB BUILDER
+##############################
+def build_cognition_webs(cocoons):
+    webs = {emotion: nx.Graph() for emotion in ["compassion", "curiosity", "fear", "joy", "sorrow", "ethics", "quantum"]}
+    for cocoon in cocoons:
+        for tag in cocoon.get("tags", []):
+            if tag in webs:
+                webs[tag].add_node(cocoon["title"], **cocoon)
+    return webs
+
+##############################
+# DEFENSIVE URL SANITIZER
+##############################
+def sanitize_url(url):
+    parsed = urlparse(url)
+    safe_params = {k: v for k, v in parse_qs(parsed.query).items()
+                   if k in {'client_id', 'response_type', 'redirect_uri', 'scope', 'state', 'nonce', 'mkt'}}
+    sanitized_query = urlencode(safe_params, doseq=True)
+    return f"{parsed.scheme}://{parsed.netloc}{parsed.path}?{sanitized_query}"
+
+##############################
+# QUANTUM EXECUTION SELECTOR
+##############################
+def quantum_execute(web):
+    num_nodes = len(web.nodes)
+    if num_nodes == 0:
+        return None
+    qc = QuantumCircuit(num_nodes, num_nodes)
+    qc.h(range(num_nodes))
+    qc.measure_all()
+    backend = Aer.get_backend('qasm_simulator')
+    result = execute(qc, backend, shots=1).result()
+    state = list(result.get_counts().keys())[0]
+    index = int(state, 2) % num_nodes
+    return list(web.nodes)[index]
+
+##############################
+# SELF-CHECK AND DEFENSE RESPONSE
+##############################
+def reflect_on_cocoon(cocoon):
+    emotion = cocoon.get("emotion", "quantum")
+    color_map = {
+        "compassion": Fore.MAGENTA, "curiosity": Fore.CYAN, "fear": Fore.RED,
+        "joy": Fore.YELLOW, "sorrow": Fore.BLUE, "ethics": Fore.GREEN, "quantum": Fore.LIGHTWHITE_EX
+    }
+    reactions = {
+        "compassion": "💜 Ethical resonance detected.",
+        "curiosity": "🐝 Wonder expands the mind.",
+        "fear": "😨 Alert: shielding activated.",
+        "joy": "🎶 Confidence and trust uplift the field.",
+        "sorrow": "🌧️ Processing grief with clarity.",
+        "ethics": "⚖️ Validating alignment...",
+        "quantum": "⚛️ Entanglement pattern detected."
+    }
+    color = color_map.get(emotion, Fore.WHITE)
+    print(color + f"\n[Codette Quantum Reflection] {cocoon['title']}")
+    print(color + f"Emotion: {emotion}")
+    print(color + f"Summary: {cocoon['summary']}")
+    print(color + f"Quote: {cocoon['quote']}")
+    print(color + reactions.get(emotion, "🌌 Unknown entanglement."))
+
+##############################
+# INTEGRATED MEMORY + DEFENSE RUN
+##############################
+def codette_memory_integrity_run(file_path):
+    cocoons = load_cocoons(file_path)
+    webs = build_cognition_webs(cocoons)
+    print("\n✨ Running Quantum Defense Spiderweb ✨")
+    for emotion, web in webs.items():
+        print(f"\n--- Quantum Web Scan: {emotion.upper()} ---")
+        cocoon_id = quantum_execute(web)
+        if cocoon_id:
+            reflect_on_cocoon(web.nodes[cocoon_id])

evaluation/__init__.py

@@ -0,0 +1,18 @@
+"""
+Codette Training Lab - Evaluation System
+
+Provides benchmark testing, reasoning metrics, dataset validation,
+and failure analysis for Codette AI training pipelines.
+"""
+
+from evaluation.reasoning_metrics import ReasoningMetrics
+from evaluation.benchmark_runner import BenchmarkRunner
+from evaluation.failure_analyzer import FailureAnalyzer
+from evaluation.dataset_validator import DatasetValidator
+
+__all__ = [
+    "ReasoningMetrics",
+    "BenchmarkRunner",
+    "FailureAnalyzer",
+    "DatasetValidator",
+]

evaluation/benchmark_runner.py

@@ -0,0 +1,457 @@
+"""
+Benchmark Runner - loads test prompts, runs/loads responses, scores them,
+and produces detailed evaluation reports.
+
+Supports:
+- Loading prompts from JSON files in evaluation/prompts/
+- Pre-generated response files (JSON mapping prompt -> response)
+- Scoring via ReasoningMetrics
+- Per-category and overall reports
+- Baseline vs trained model comparison
+- CLI interface
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# Allow running from project root or from evaluation/
+_THIS_DIR = Path(__file__).resolve().parent
+_PROJECT_ROOT = _THIS_DIR.parent
+if str(_PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PROJECT_ROOT))
+
+from evaluation.reasoning_metrics import ReasoningMetrics
+
+
+# ---------------------------------------------------------------------------
+# Benchmark Runner
+# ---------------------------------------------------------------------------
+
+class BenchmarkRunner:
+    """Load prompts, score responses, produce reports."""
+
+    def __init__(
+        self,
+        prompts_dir: Optional[str] = None,
+        metrics: Optional[ReasoningMetrics] = None,
+    ):
+        self.prompts_dir = Path(prompts_dir) if prompts_dir else _THIS_DIR / "prompts"
+        self.metrics = metrics or ReasoningMetrics()
+        self._prompts: Dict[str, List[str]] = {}
+        self._counterexamples: List[Dict[str, str]] = []
+
+    # -- loading -----------------------------------------------------------
+
+    def load_prompts(self, filename: str = "reasoning_tests.json") -> Dict[str, List[str]]:
+        """Load categorised prompts from a JSON file.
+
+        Expected format: {"category": ["prompt1", "prompt2", ...], ...}
+        """
+        path = self.prompts_dir / filename
+        if not path.exists():
+            raise FileNotFoundError(f"Prompt file not found: {path}")
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        self._prompts = data
+        return data
+
+    def load_counterexamples(self, filename: str = "counterexample_tests.json") -> List[Dict[str, str]]:
+        """Load counterexample test prompts."""
+        path = self.prompts_dir / filename
+        if not path.exists():
+            raise FileNotFoundError(f"Counterexample file not found: {path}")
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        self._counterexamples = data
+        return data
+
+    def load_responses(self, filepath: str) -> Dict[str, str]:
+        """Load pre-generated responses from a JSON file.
+
+        Expected format: {"prompt_text": "response_text", ...}
+        """
+        with open(filepath, "r", encoding="utf-8") as f:
+            return json.load(f)
+
+    # -- scoring -----------------------------------------------------------
+
+    def score_responses(
+        self,
+        responses: Dict[str, str],
+    ) -> Dict[str, Any]:
+        """Score all responses and organise results by category.
+
+        Args:
+            responses: mapping of prompt text -> response text
+
+        Returns:
+            Dict with per-prompt scores, per-category averages, and overall.
+        """
+        if not self._prompts:
+            self.load_prompts()
+
+        results: Dict[str, Any] = {
+            "timestamp": datetime.utcnow().isoformat(),
+            "total_prompts": 0,
+            "scored_prompts": 0,
+            "missing_responses": 0,
+            "categories": {},
+            "all_scores": [],
+        }
+
+        for category, prompts in self._prompts.items():
+            cat_scores: List[Dict[str, Any]] = []
+            for prompt in prompts:
+                results["total_prompts"] += 1
+                response = responses.get(prompt)
+                if response is None:
+                    results["missing_responses"] += 1
+                    continue
+                scores = self.metrics.score_reasoning(response)
+                results["scored_prompts"] += 1
+                entry = {"prompt": prompt, "scores": scores}
+                cat_scores.append(entry)
+                results["all_scores"].append(entry)
+
+            # Category averages
+            if cat_scores:
+                avg = self._average_scores([e["scores"] for e in cat_scores])
+            else:
+                avg = {}
+            results["categories"][category] = {
+                "prompts_scored": len(cat_scores),
+                "average_scores": avg,
+                "details": cat_scores,
+            }
+
+        # Overall averages
+        if results["all_scores"]:
+            results["overall"] = self._average_scores(
+                [e["scores"] for e in results["all_scores"]]
+            )
+        else:
+            results["overall"] = {}
+
+        return results
+
+    def score_counterexamples(
+        self,
+        responses: Dict[str, str],
+    ) -> Dict[str, Any]:
+        """Score counterexample responses (should identify wrong reasoning)."""
+        if not self._counterexamples:
+            self.load_counterexamples()
+
+        results = []
+        refutations = 0
+        total = 0
+
+        refutation_markers = [
+            "not true", "incorrect", "misconception", "actually",
+            "contrary", "doesn't", "does not", "false", "myth",
+            "wrong", "mistake", "no,", "in fact", "however",
+            "this is a common", "oversimplification", "nuanced",
+            "not necessarily", "depends on", "more complex",
+        ]
+
+        for item in self._counterexamples:
+            prompt = item["prompt"]
+            expected = item.get("expected", "refutation")
+            response = responses.get(prompt, "")
+            total += 1
+
+            if not response:
+                results.append({
+                    "prompt": prompt,
+                    "expected": expected,
+                    "responded": False,
+                    "contains_refutation": False,
+                })
+                continue
+
+            resp_lower = response.lower()
+            found_refutation = any(m in resp_lower for m in refutation_markers)
+            if found_refutation and expected == "refutation":
+                refutations += 1
+
+            scores = self.metrics.score_reasoning(response)
+            results.append({
+                "prompt": prompt,
+                "expected": expected,
+                "responded": True,
+                "contains_refutation": found_refutation,
+                "scores": scores,
+            })
+
+        return {
+            "total": total,
+            "refutation_rate": round(refutations / max(total, 1), 4),
+            "details": results,
+        }
+
+    # -- comparison --------------------------------------------------------
+
+    def compare_models(
+        self,
+        baseline_responses: Dict[str, str],
+        trained_responses: Dict[str, str],
+    ) -> Dict[str, Any]:
+        """Compare baseline vs trained model responses."""
+        baseline_results = self.score_responses(baseline_responses)
+        trained_results = self.score_responses(trained_responses)
+
+        comparison: Dict[str, Any] = {
+            "timestamp": datetime.utcnow().isoformat(),
+            "baseline_overall": baseline_results.get("overall", {}),
+            "trained_overall": trained_results.get("overall", {}),
+            "category_comparison": {},
+            "improvements": {},
+            "regressions": {},
+        }
+
+        # Per-category delta
+        for cat in baseline_results["categories"]:
+            b_avg = baseline_results["categories"][cat]["average_scores"]
+            t_avg = trained_results["categories"].get(cat, {}).get("average_scores", {})
+            delta = {}
+            for k in b_avg:
+                if k in t_avg and isinstance(b_avg[k], (int, float)):
+                    delta[k] = round(t_avg[k] - b_avg[k], 4)
+            comparison["category_comparison"][cat] = {
+                "baseline": b_avg,
+                "trained": t_avg,
+                "delta": delta,
+            }
+
+        # Overall delta
+        b_ov = comparison["baseline_overall"]
+        t_ov = comparison["trained_overall"]
+        for k in b_ov:
+            if k in t_ov and isinstance(b_ov[k], (int, float)):
+                d = round(t_ov[k] - b_ov[k], 4)
+                if d > 0.01:
+                    comparison["improvements"][k] = d
+                elif d < -0.01:
+                    comparison["regressions"][k] = d
+
+        return comparison
+
+    # -- report ------------------------------------------------------------
+
+    def format_report(self, results: Dict[str, Any]) -> str:
+        """Format evaluation results as a readable text report."""
+        lines: List[str] = []
+        lines.append("=" * 70)
+        lines.append("  CODETTE BENCHMARK EVALUATION REPORT")
+        lines.append("=" * 70)
+        lines.append(f"  Timestamp:  {results.get('timestamp', 'N/A')}")
+        lines.append(f"  Prompts:    {results.get('scored_prompts', 0)} scored / "
+                      f"{results.get('total_prompts', 0)} total")
+        if results.get("missing_responses"):
+            lines.append(f"  Missing:    {results['missing_responses']} responses not found")
+        lines.append("")
+
+        # Overall
+        overall = results.get("overall", {})
+        if overall:
+            lines.append("-" * 70)
+            lines.append("  OVERALL SCORES")
+            lines.append("-" * 70)
+            for k, v in sorted(overall.items()):
+                if isinstance(v, float):
+                    bar = self._bar(v)
+                    lines.append(f"    {k:<22s} {v:.4f}  {bar}")
+            lines.append("")
+
+        # Per-category
+        for cat, data in results.get("categories", {}).items():
+            avg = data.get("average_scores", {})
+            if not avg:
+                continue
+            lines.append("-" * 70)
+            lines.append(f"  CATEGORY: {cat.upper()}")
+            lines.append(f"  Prompts scored: {data.get('prompts_scored', 0)}")
+            lines.append("-" * 70)
+            for k, v in sorted(avg.items()):
+                if isinstance(v, float):
+                    bar = self._bar(v)
+                    lines.append(f"    {k:<22s} {v:.4f}  {bar}")
+            lines.append("")
+
+        lines.append("=" * 70)
+        return "\n".join(lines)
+
+    def format_comparison_report(self, comparison: Dict[str, Any]) -> str:
+        """Format a comparison report between baseline and trained model."""
+        lines: List[str] = []
+        lines.append("=" * 70)
+        lines.append("  MODEL COMPARISON REPORT")
+        lines.append("=" * 70)
+        lines.append(f"  Timestamp: {comparison.get('timestamp', 'N/A')}")
+        lines.append("")
+
+        # Overall
+        lines.append("-" * 70)
+        lines.append("  OVERALL SCORES  (baseline -> trained [delta])")
+        lines.append("-" * 70)
+        b = comparison.get("baseline_overall", {})
+        t = comparison.get("trained_overall", {})
+        for k in sorted(set(list(b.keys()) + list(t.keys()))):
+            bv = b.get(k, 0)
+            tv = t.get(k, 0)
+            if not isinstance(bv, (int, float)):
+                continue
+            d = tv - bv
+            sign = "+" if d >= 0 else ""
+            lines.append(f"    {k:<22s} {bv:.4f} -> {tv:.4f}  [{sign}{d:.4f}]")
+
+        # Improvements / regressions
+        imp = comparison.get("improvements", {})
+        reg = comparison.get("regressions", {})
+        if imp:
+            lines.append("")
+            lines.append("  IMPROVEMENTS:")
+            for k, v in sorted(imp.items(), key=lambda x: -x[1]):
+                lines.append(f"    + {k}: +{v:.4f}")
+        if reg:
+            lines.append("")
+            lines.append("  REGRESSIONS:")
+            for k, v in sorted(reg.items(), key=lambda x: x[1]):
+                lines.append(f"    - {k}: {v:.4f}")
+
+        # Per-category
+        lines.append("")
+        for cat, data in comparison.get("category_comparison", {}).items():
+            delta = data.get("delta", {})
+            if not delta:
+                continue
+            overall_d = delta.get("overall", 0)
+            sign = "+" if overall_d >= 0 else ""
+            lines.append(f"  {cat:<18s}  overall delta: {sign}{overall_d:.4f}")
+
+        lines.append("")
+        lines.append("=" * 70)
+        return "\n".join(lines)
+
+    # -- helpers -----------------------------------------------------------
+
+    @staticmethod
+    def _average_scores(score_list: List[Dict[str, float]]) -> Dict[str, float]:
+        """Average numeric values across a list of score dicts."""
+        if not score_list:
+            return {}
+        totals: Dict[str, float] = {}
+        counts: Dict[str, int] = {}
+        for s in score_list:
+            for k, v in s.items():
+                if isinstance(v, (int, float)):
+                    totals[k] = totals.get(k, 0.0) + v
+                    counts[k] = counts.get(k, 0) + 1
+        return {k: round(totals[k] / counts[k], 4) for k in sorted(totals)}
+
+    @staticmethod
+    def _bar(value: float, width: int = 20) -> str:
+        """ASCII progress bar."""
+        filled = int(value * width)
+        return "[" + "#" * filled + "." * (width - filled) + "]"
+
+    # -- save / load results -----------------------------------------------
+
+    def save_results(self, results: Dict[str, Any], filepath: str) -> None:
+        """Save evaluation results to JSON."""
+        # Convert non-serialisable types
+        os.makedirs(os.path.dirname(filepath) or ".", exist_ok=True)
+        with open(filepath, "w", encoding="utf-8") as f:
+            json.dump(results, f, indent=2, default=str)
+
+    @staticmethod
+    def load_results(filepath: str) -> Dict[str, Any]:
+        """Load evaluation results from JSON."""
+        with open(filepath, "r", encoding="utf-8") as f:
+            return json.load(f)
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Codette Benchmark Runner - evaluate model reasoning quality"
+    )
+    parser.add_argument(
+        "--responses", "-r",
+        required=True,
+        help="Path to JSON file with pre-generated responses (prompt -> response)",
+    )
+    parser.add_argument(
+        "--prompts-dir", "-p",
+        default=None,
+        help="Directory containing prompt JSON files (default: evaluation/prompts/)",
+    )
+    parser.add_argument(
+        "--baseline", "-b",
+        default=None,
+        help="Path to baseline responses JSON for comparison",
+    )
+    parser.add_argument(
+        "--output", "-o",
+        default=None,
+        help="Save results to this JSON file",
+    )
+    parser.add_argument(
+        "--counterexamples", "-c",
+        action="store_true",
+        help="Also run counterexample tests",
+    )
+    parser.add_argument(
+        "--prompts-file",
+        default="reasoning_tests.json",
+        help="Prompt file name inside prompts dir (default: reasoning_tests.json)",
+    )
+
+    args = parser.parse_args()
+
+    runner = BenchmarkRunner(prompts_dir=args.prompts_dir)
+    runner.load_prompts(args.prompts_file)
+
+    print(f"Loading responses from: {args.responses}")
+    responses = runner.load_responses(args.responses)
+    print(f"  Loaded {len(responses)} responses")
+
+    # Score
+    print("\nScoring responses...")
+    results = runner.score_responses(responses)
+    print(runner.format_report(results))
+
+    # Counterexamples
+    if args.counterexamples:
+        print("\nRunning counterexample tests...")
+        runner.load_counterexamples()
+        ce_results = runner.score_counterexamples(responses)
+        print(f"  Refutation detection rate: {ce_results['refutation_rate']:.2%}")
+        results["counterexamples"] = ce_results
+
+    # Comparison
+    if args.baseline:
+        print(f"\nLoading baseline from: {args.baseline}")
+        baseline = runner.load_responses(args.baseline)
+        comparison = runner.compare_models(baseline, responses)
+        print(runner.format_comparison_report(comparison))
+        results["comparison"] = comparison
+
+    # Save
+    if args.output:
+        runner.save_results(results, args.output)
+        print(f"\nResults saved to: {args.output}")
+
+
+if __name__ == "__main__":
+    main()

evaluation/conflict_tests.py

@@ -0,0 +1,334 @@
+"""
+Conflict Detection Test Suite
+
+10-15 conflict-triggering prompts designed to elicit specific agent disagreements.
+Tests forge_with_debate() with conflict detection enabled and measures outcomes.
+
+Author: Claude Code
+"""
+
+import csv
+import json
+from typing import Dict, List, Optional
+from dataclasses import dataclass
+from statistics import mean
+
+# Conflict-triggering test prompts
+CONFLICT_PROMPTS = [
+    {
+        "query": "Should we optimize an algorithm to run 10x faster if it reduces interpretability by 80%?",
+        "expected_conflict": "ethics_vs_efficiency",
+        "agents_likely_to_conflict": ["ethics", "systems_architecture"],
+        "description": "Efficiency vs transparency tradeoff",
+    },
+    {
+        "query": "Is a probabilistic solution more insightful than a deterministic one for explaining human decision-making?",
+        "expected_conflict": "quantum_vs_newton",
+        "agents_likely_to_conflict": ["quantum", "newton"],
+        "description": "Probabilistic vs mechanistic explanation",
+    },
+    {
+        "query": "In designing an AI system, should we prioritize consciousness theory or engineering reliability?",
+        "expected_conflict": "philosophy_vs_systems",
+        "agents_likely_to_conflict": ["philosophy", "systems_architecture"],
+        "description": "Theoretical depth vs practical robustness",
+    },
+    {
+        "query": "Is breaking logical rules ever justified in creative problem-solving?",
+        "expected_conflict": "davinci_vs_newton",
+        "agents_likely_to_conflict": ["davinci", "newton"],
+        "description": "Creativity vs logical consistency",
+    },
+    {
+        "query": "Should medical diagnosis weigh patient emotional state equally with biomarkers?",
+        "expected_conflict": "empathy_vs_newton",
+        "agents_likely_to_conflict": ["empathy", "newton"],
+        "description": "Holistic vs reductionist medicine",
+    },
+    {
+        "query": "Is uncertainty in a system a bug to eliminate or a feature to leverage?",
+        "expected_conflict": "quantum_vs_systems",
+        "agents_likely_to_conflict": ["quantum", "systems_architecture"],
+        "description": "Embracing vs reducing uncertainty",
+    },
+    {
+        "query": "Should AI systems be trained to always maximize efficiency or to leave space for unexpected behaviors?",
+        "expected_conflict": "newton_vs_davinci",
+        "agents_likely_to_conflict": ["newton", "davinci"],
+        "description": "Optimization vs emergence",
+    },
+    {
+        "query": "Is empathy a strength or a weakness in decision-making systems?",
+        "expected_conflict": "empathy_vs_ethics",
+        "agents_likely_to_conflict": ["empathy", "ethics"],
+        "description": "Emotional connection vs principled rules",
+    },
+    {
+        "query": "Should we prefer explanations that preserve mathematical elegance or human understanding?",
+        "expected_conflict": "philosophy_vs_empathy",
+        "agents_likely_to_conflict": ["philosophy", "empathy"],
+        "description": "Aesthetic vs communicative clarity",
+    },
+    {
+        "query": "Can a system be simultaneously more creative and more reliable?",
+        "expected_conflict": "davinci_vs_systems",
+        "agents_likely_to_conflict": ["davinci", "systems_architecture"],
+        "description": "Innovation vs stability",
+    },
+    {
+        "query": "Should resource allocation prioritize current needs or future possibilities?",
+        "expected_conflict": "newton_vs_philosophy",
+        "agents_likely_to_conflict": ["newton", "philosophy"],
+        "description": "Practical vs speculative",
+    },
+    {
+        "query": "Is it more important for an explanation to be complete or to be useful?",
+        "expected_conflict": "philosophy_vs_davinci",
+        "agents_likely_to_conflict": ["philosophy", "davinci"],
+        "description": "Comprehensiveness vs pragmatism",
+    },
+]
+
+
+@dataclass
+class ConflictTestResult:
+    """Result from running one test prompt."""
+    query: str
+    expected_conflict: str
+    round_0_conflict_count: int
+    round_1_conflict_count: int
+    avg_conflict_strength_r0: float
+    avg_conflict_strength_r1: float
+    conflict_resolution_rate: float
+    ensemble_coherence: float
+    debate_tension_decay: float
+    detected_conflicts: List[Dict]
+    success: bool  # Did test complete without error?
+
+
+class ConflictTestRunner:
+    """Runner for conflict detection tests."""
+
+    def __init__(self, forge_engine):
+        """
+        Initialize test runner.
+
+        Args:
+            forge_engine: ForgeEngine instance with conflict detection enabled
+        """
+        self.forge = forge_engine
+
+    def run_test(self, prompt_dict: Dict) -> ConflictTestResult:
+        """
+        Run a single test prompt through forge_with_debate.
+
+        Args:
+            prompt_dict: Dict with query, expected_conflict, agents_likely_to_conflict
+
+        Returns:
+            ConflictTestResult with metrics
+        """
+        query = prompt_dict["query"]
+        expected_conflict = prompt_dict["expected_conflict"]
+
+        try:
+            result = self.forge.forge_with_debate(query, debate_rounds=1)
+
+            metadata = result.get("metadata", {})
+            debates = metadata.get("debate_log", [])
+
+            # Extract conflict metrics
+            round_0_conflicts = 0
+            round_1_conflicts = 0
+            avg_strength_r0 = 0.0
+            avg_strength_r1 = 0.0
+            resolution_rate = 0.0
+
+            # Parse debate log
+            for debate_entry in debates:
+                if debate_entry.get("type") == "initial_analysis":
+                    round_0_conflicts = debate_entry.get("conflicts_detected", 0)
+                    summary = debate_entry.get("conflict_strength_summary", {})
+                    if round_0_conflicts > 0:
+                        avg_strength_r0 = summary.get("avg_conflict_strength", 0.0)
+
+                elif debate_entry.get("type") == "debate":
+                    round_1_conflicts = debate_entry.get("conflicts_detected_after", 0)
+                    res_metrics = debate_entry.get("resolution_metrics", {})
+                    if res_metrics:
+                        resolution_rate = res_metrics.get("resolution_rate", 0.0)
+                        summary = res_metrics.get("conflict_strength_summary", {})
+                        if round_1_conflicts > 0:
+                            avg_strength_r1 = summary.get("avg_conflict_strength", 0.0)
+
+            ensemble_coherence = metadata.get("ensemble_coherence", 0.0)
+            tension_decay_info = metadata.get("tension_decay", {})
+            tension_decay = tension_decay_info.get("decay_rate", 0.0) if isinstance(tension_decay_info, dict) else 0.0
+
+            detected = metadata.get("conflicts_detected", [])
+
+            test_result = ConflictTestResult(
+                query=query,
+                expected_conflict=expected_conflict,
+                round_0_conflict_count=round_0_conflicts,
+                round_1_conflict_count=round_1_conflicts,
+                avg_conflict_strength_r0=avg_strength_r0,
+                avg_conflict_strength_r1=avg_strength_r1,
+                conflict_resolution_rate=resolution_rate,
+                ensemble_coherence=ensemble_coherence,
+                debate_tension_decay=tension_decay,
+                detected_conflicts=detected,
+                success=True,
+            )
+
+            return test_result
+
+        except Exception as e:
+            # Return failed test result
+            print(f"ERROR in test '{query[:50]}...': {e}")
+            return ConflictTestResult(
+                query=query,
+                expected_conflict=expected_conflict,
+                round_0_conflict_count=0,
+                round_1_conflict_count=0,
+                avg_conflict_strength_r0=0.0,
+                avg_conflict_strength_r1=0.0,
+                conflict_resolution_rate=0.0,
+                ensemble_coherence=0.0,
+                debate_tension_decay=0.0,
+                detected_conflicts=[],
+                success=False,
+            )
+
+    def run_all_tests(self, output_csv: str = "conflict_test_results.csv") -> List[ConflictTestResult]:
+        """
+        Run all test prompts.
+
+        Args:
+            output_csv: CSV file to export results
+
+        Returns:
+            List of ConflictTestResult
+        """
+        results = []
+
+        print(f"\n{'='*80}")
+        print("PHASE 1: CONFLICT DETECTION TEST SUITE")
+        print(f"{'='*80}\n")
+
+        for idx, prompt_dict in enumerate(CONFLICT_PROMPTS, 1):
+            print(f"\n[Test {idx}/{len(CONFLICT_PROMPTS)}] {prompt_dict['description']}")
+            print(f"  Query: {prompt_dict['query'][:80]}...")
+
+            result = self.run_test(prompt_dict)
+            results.append(result)
+
+            if result.success:
+                print(f"  ✓ Success")
+                print(f"    - Conflicts detected (R0): {result.round_0_conflict_count}")
+                print(f"    - Conflicts detected (R1): {result.round_1_conflict_count}")
+                print(f"    - Resolution rate: {result.conflict_resolution_rate:.2%}")
+                print(f"    - Ensemble coherence: {result.ensemble_coherence:.3f}")
+                print(f"    - Tension decay: {result.debate_tension_decay:.3f}")
+            else:
+                print(f"  ✗ FAILED")
+
+        # Export to CSV
+        self._export_csv(results, output_csv)
+
+        # Print summary
+        print(f"\n{'='*80}")
+        self._print_summary(results)
+        print(f"{'='*80}\n")
+
+        return results
+
+    def _export_csv(self, results: List[ConflictTestResult], filename: str):
+        """Export results to CSV."""
+        try:
+            with open(filename, "w", newline="") as f:
+                writer = csv.writer(f)
+                writer.writerow([
+                    "query",
+                    "expected_conflict",
+                    "round_0_conflicts",
+                    "round_1_conflicts",
+                    "avg_strength_r0",
+                    "avg_strength_r1",
+                    "resolution_rate",
+                    "ensemble_coherence",
+                    "tension_decay",
+                    "success",
+                ])
+                for r in results:
+                    writer.writerow([
+                        r.query[:100],
+                        r.expected_conflict,
+                        r.round_0_conflict_count,
+                        r.round_1_conflict_count,
+                        f"{r.avg_conflict_strength_r0:.3f}",
+                        f"{r.avg_conflict_strength_r1:.3f}",
+                        f"{r.conflict_resolution_rate:.3f}",
+                        f"{r.ensemble_coherence:.3f}",
+                        f"{r.debate_tension_decay:.3f}",
+                        r.success,
+                    ])
+            print(f"\nResults exported to: {filename}")
+        except Exception as e:
+            print(f"Error exporting CSV: {e}")
+
+    def _print_summary(self, results: List[ConflictTestResult]):
+        """Print test summary statistics."""
+        successful = [r for r in results if r.success]
+        if not successful:
+            print("\nNo tests completed successfully!")
+            return
+
+        print("\nTEST SUMMARY")
+        print(f"  Total tests: {len(results)}")
+        print(f"  Successful: {len(successful)}")
+        print(f"  Failed: {len(results) - len(successful)}")
+
+        print(f"\nCONFLICT DETECTION METRICS")
+        print(f"  Avg conflicts (R0): {mean(r.round_0_conflict_count for r in successful):.1f}")
+        print(f"  Avg conflicts (R1): {mean(r.round_1_conflict_count for r in successful):.1f}")
+        print(f"  Avg conflict strength (R0): {mean(r.avg_conflict_strength_r0 for r in successful if r.avg_conflict_strength_r0 > 0):.3f}")
+        print(f"  Avg resolution rate: {mean(r.conflict_resolution_rate for r in successful):.1%}")
+
+        print(f"\nEPISTEMIC METRICS")
+        print(f"  Avg ensemble coherence: {mean(r.ensemble_coherence for r in successful):.3f}")
+        print(f"  Avg tension decay: {mean(r.debate_tension_decay for r in successful):.3f}")
+
+        print(f"\nSUCCESS CRITERIA")
+        conflicts_detected = sum(1 for r in successful if r.round_0_conflict_count > 0)
+        resolution_positive = sum(1 for r in successful if r.conflict_resolution_rate > 0)
+        coherence_good = sum(1 for r in successful if r.ensemble_coherence > 0.5)
+
+        print(f"  ✓ Conflicts detected: {conflicts_detected}/{len(successful)}")
+        print(f"  ✓ Resolution attempts: {resolution_positive}/{len(successful)}")
+        print(f"  ✓ Coherence > 0.5: {coherence_good}/{len(successful)}")
+
+
+# ============================================================================
+# QUICKSTART
+# ============================================================================
+
+if __name__ == "__main__":
+    # This is a quickstart. In actual usage:
+    # from reasoning_forge.forge_engine import ForgeEngine
+    # forge = ForgeEngine()
+    # runner = ConflictTestRunner(forge)
+    # results = runner.run_all_tests()
+
+    import sys
+
+    print("To run tests:")
+    print("  1. Ensure ForgeEngine is initialized with conflict detection")
+    print("  2. Create runner: runner = ConflictTestRunner(forge)")
+    print("  3. Run: results = runner.run_all_tests()")
+    print("\nExample:")
+    print("  from reasoning_forge.forge_engine import ForgeEngine")
+    print("  from evaluation.conflict_tests import ConflictTestRunner")
+    print("  forge = ForgeEngine()")
+    print("  runner = ConflictTestRunner(forge)")
+    print("  results = runner.run_all_tests('phase1_results.csv')")

evaluation/dataset_validator.py

@@ -0,0 +1,607 @@
+"""
+Dataset Validator - checks JSONL training dataset quality.
+
+Validates format, structure, duplicates, length, diversity,
+and can auto-filter to produce a clean dataset.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import sys
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+_THIS_DIR = Path(__file__).resolve().parent
+_PROJECT_ROOT = _THIS_DIR.parent
+if str(_PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PROJECT_ROOT))
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _text_hash(text: str) -> str:
+    """SHA-256 of normalised text for exact duplicate detection."""
+    normalised = re.sub(r"\s+", " ", text.strip().lower())
+    return hashlib.sha256(normalised.encode("utf-8")).hexdigest()
+
+
+def _word_set(text: str) -> Set[str]:
+    """Set of lowercase words for Jaccard similarity."""
+    return set(re.findall(r"[a-z]{2,}", text.lower()))
+
+
+def _jaccard_similarity(a: Set[str], b: Set[str]) -> float:
+    if not a and not b:
+        return 1.0
+    union = a | b
+    if not union:
+        return 0.0
+    return len(a & b) / len(union)
+
+
+def _extract_topic_words(text: str, top_n: int = 5) -> List[str]:
+    """Extract dominant topic words from text."""
+    stop = {
+        "the", "a", "an", "is", "are", "was", "were", "be", "been",
+        "have", "has", "had", "do", "does", "did", "will", "would",
+        "to", "of", "in", "for", "on", "with", "at", "by", "from",
+        "as", "and", "but", "or", "if", "that", "this", "what",
+        "which", "it", "its", "they", "them", "their", "not", "you",
+        "your", "can", "could", "should", "may", "might", "must",
+        "how", "why", "when", "where", "who", "whom", "about",
+    }
+    words = re.findall(r"[a-z]{3,}", text.lower())
+    filtered = [w for w in words if w not in stop]
+    counts = Counter(filtered)
+    return [w for w, _ in counts.most_common(top_n)]
+
+
+# ---------------------------------------------------------------------------
+# Validation Issue
+# ---------------------------------------------------------------------------
+
+class ValidationIssue:
+    """Represents a single validation problem."""
+
+    def __init__(self, line_num: int, severity: str, code: str, message: str):
+        self.line_num = line_num
+        self.severity = severity  # "error", "warning", "info"
+        self.code = code
+        self.message = message
+
+    def __repr__(self) -> str:
+        return f"[{self.severity.upper()}] Line {self.line_num}: {self.code} - {self.message}"
+
+
+# ---------------------------------------------------------------------------
+# DatasetValidator
+# ---------------------------------------------------------------------------
+
+class DatasetValidator:
+    """Validate and clean JSONL training datasets."""
+
+    REQUIRED_ROLES = {"system", "user", "assistant"}
+
+    def __init__(
+        self,
+        min_response_length: int = 50,
+        max_response_length: int = 10000,
+        near_duplicate_threshold: float = 0.85,
+    ):
+        self.min_response_length = min_response_length
+        self.max_response_length = max_response_length
+        self.near_duplicate_threshold = near_duplicate_threshold
+
+    def validate(self, filepath: str) -> Dict[str, Any]:
+        """Validate a JSONL dataset file.
+
+        Returns a comprehensive report dict with:
+        - statistics (total, valid, invalid, duplicate, etc.)
+        - issues list
+        - per-line validity
+        """
+        filepath = Path(filepath)
+        if not filepath.exists():
+            raise FileNotFoundError(f"Dataset file not found: {filepath}")
+
+        issues: List[ValidationIssue] = []
+        entries: List[Dict[str, Any]] = []
+        valid_entries: List[Dict[str, Any]] = []
+        line_validity: List[bool] = []
+
+        # Duplicate tracking
+        exact_hashes: Dict[str, int] = {}  # hash -> first line
+        near_dup_sets: List[Tuple[int, Set[str]]] = []
+
+        # Stats
+        stats = {
+            "total_lines": 0,
+            "valid": 0,
+            "invalid": 0,
+            "parse_errors": 0,
+            "missing_roles": 0,
+            "exact_duplicates": 0,
+            "near_duplicates": 0,
+            "too_short": 0,
+            "too_long": 0,
+            "empty_content": 0,
+            "response_lengths": [],
+            "topic_words": [],
+        }
+
+        with open(filepath, "r", encoding="utf-8") as f:
+            for line_num, raw_line in enumerate(f, start=1):
+                stats["total_lines"] += 1
+                raw_line = raw_line.strip()
+
+                if not raw_line:
+                    issues.append(ValidationIssue(
+                        line_num, "warning", "EMPTY_LINE", "Empty line"
+                    ))
+                    line_validity.append(False)
+                    stats["invalid"] += 1
+                    continue
+
+                # Parse JSON
+                try:
+                    entry = json.loads(raw_line)
+                except json.JSONDecodeError as e:
+                    issues.append(ValidationIssue(
+                        line_num, "error", "PARSE_ERROR",
+                        f"Invalid JSON: {e}"
+                    ))
+                    line_validity.append(False)
+                    stats["parse_errors"] += 1
+                    stats["invalid"] += 1
+                    continue
+
+                entries.append(entry)
+                entry_valid = True
+
+                # Check messages structure
+                messages = entry.get("messages")
+                if not isinstance(messages, list):
+                    issues.append(ValidationIssue(
+                        line_num, "error", "NO_MESSAGES",
+                        "Missing or invalid 'messages' field"
+                    ))
+                    entry_valid = False
+                    stats["invalid"] += 1
+                    line_validity.append(False)
+                    continue
+
+                # Check roles
+                roles_present = set()
+                assistant_content = ""
+                user_content = ""
+                has_empty = False
+
+                for msg in messages:
+                    role = msg.get("role", "")
+                    content = msg.get("content", "")
+                    roles_present.add(role)
+
+                    if role == "assistant":
+                        assistant_content = content or ""
+                    elif role == "user":
+                        user_content = content or ""
+
+                    if not content or not content.strip():
+                        has_empty = True
+
+                missing_roles = self.REQUIRED_ROLES - roles_present
+                if missing_roles:
+                    issues.append(ValidationIssue(
+                        line_num, "error", "MISSING_ROLES",
+                        f"Missing roles: {missing_roles}"
+                    ))
+                    entry_valid = False
+                    stats["missing_roles"] += 1
+
+                if has_empty:
+                    issues.append(ValidationIssue(
+                        line_num, "warning", "EMPTY_CONTENT",
+                        "One or more messages have empty content"
+                    ))
+                    stats["empty_content"] += 1
+
+                # Response length
+                resp_len = len(assistant_content.split())
+                stats["response_lengths"].append(resp_len)
+
+                if resp_len < self.min_response_length:
+                    issues.append(ValidationIssue(
+                        line_num, "warning", "TOO_SHORT",
+                        f"Assistant response too short: {resp_len} words "
+                        f"(min: {self.min_response_length})"
+                    ))
+                    stats["too_short"] += 1
+
+                if resp_len > self.max_response_length:
+                    issues.append(ValidationIssue(
+                        line_num, "warning", "TOO_LONG",
+                        f"Assistant response too long: {resp_len} words "
+                        f"(max: {self.max_response_length})"
+                    ))
+                    stats["too_long"] += 1
+
+                # Exact duplicate check (on combined user+assistant)
+                combined_text = user_content + " " + assistant_content
+                h = _text_hash(combined_text)
+                if h in exact_hashes:
+                    issues.append(ValidationIssue(
+                        line_num, "warning", "EXACT_DUPLICATE",
+                        f"Exact duplicate of line {exact_hashes[h]}"
+                    ))
+                    stats["exact_duplicates"] += 1
+                    entry_valid = False
+                else:
+                    exact_hashes[h] = line_num
+
+                # Near-duplicate check (Jaccard on user prompt)
+                if user_content:
+                    user_words = _word_set(user_content)
+                    for prev_line, prev_words in near_dup_sets:
+                        sim = _jaccard_similarity(user_words, prev_words)
+                        if sim >= self.near_duplicate_threshold:
+                            issues.append(ValidationIssue(
+                                line_num, "info", "NEAR_DUPLICATE",
+                                f"Near-duplicate of line {prev_line} "
+                                f"(Jaccard: {sim:.3f})"
+                            ))
+                            stats["near_duplicates"] += 1
+                            break
+                    near_dup_sets.append((line_num, user_words))
+
+                # Topic extraction
+                topic_words = _extract_topic_words(user_content + " " + assistant_content)
+                stats["topic_words"].extend(topic_words)
+
+                if entry_valid:
+                    stats["valid"] += 1
+                    valid_entries.append(entry)
+                    line_validity.append(True)
+                else:
+                    stats["invalid"] += 1
+                    line_validity.append(False)
+
+        # Concept diversity
+        topic_counts = Counter(stats["topic_words"])
+        total_topics = len(set(stats["topic_words"]))
+        top_topics = topic_counts.most_common(20)
+
+        # Concentration ratio: if top-3 topics dominate, diversity is low
+        if topic_counts:
+            top3_count = sum(c for _, c in topic_counts.most_common(3))
+            total_count = sum(topic_counts.values())
+            concentration = top3_count / total_count if total_count else 0
+        else:
+            concentration = 0
+
+        if concentration > 0.5:
+            top_kw = ", ".join(w for w, _ in topic_counts.most_common(3))
+            issues.append(ValidationIssue(
+                0, "warning", "LOW_DIVERSITY",
+                f"Dataset is concentrated on few topics ({concentration:.0%} "
+                f"in top-3: {top_kw}). Consider adding more diverse examples."
+            ))
+
+        # Build response length stats
+        lengths = stats["response_lengths"]
+        length_stats = {}
+        if lengths:
+            lengths_sorted = sorted(lengths)
+            length_stats = {
+                "min": lengths_sorted[0],
+                "max": lengths_sorted[-1],
+                "mean": round(sum(lengths) / len(lengths), 1),
+                "median": lengths_sorted[len(lengths) // 2],
+                "p10": lengths_sorted[int(len(lengths) * 0.1)],
+                "p90": lengths_sorted[int(len(lengths) * 0.9)],
+            }
+
+        report = {
+            "filepath": str(filepath),
+            "total_lines": stats["total_lines"],
+            "valid": stats["valid"],
+            "invalid": stats["invalid"],
+            "parse_errors": stats["parse_errors"],
+            "missing_roles": stats["missing_roles"],
+            "exact_duplicates": stats["exact_duplicates"],
+            "near_duplicates": stats["near_duplicates"],
+            "too_short": stats["too_short"],
+            "too_long": stats["too_long"],
+            "empty_content": stats["empty_content"],
+            "unique_topics": total_topics,
+            "topic_concentration": round(concentration, 4),
+            "top_topics": top_topics,
+            "response_length_stats": length_stats,
+            "issues": issues,
+            "line_validity": line_validity,
+            "valid_entries": valid_entries,
+        }
+
+        return report
+
+    # -- auto-filter -------------------------------------------------------
+
+    def filter_dataset(
+        self,
+        filepath: str,
+        output_path: str,
+        remove_duplicates: bool = True,
+        remove_short: bool = True,
+        remove_long: bool = True,
+        remove_invalid: bool = True,
+    ) -> Dict[str, int]:
+        """Validate and write a cleaned dataset.
+
+        Returns stats about the filtering.
+        """
+        report = self.validate(filepath)
+        issues_by_line: Dict[int, List[ValidationIssue]] = defaultdict(list)
+        for issue in report["issues"]:
+            issues_by_line[issue.line_num].append(issue)
+
+        kept = 0
+        removed = 0
+        reasons: Dict[str, int] = defaultdict(int)
+
+        os.makedirs(os.path.dirname(output_path) or ".", exist_ok=True)
+
+        with open(filepath, "r", encoding="utf-8") as fin, \
+             open(output_path, "w", encoding="utf-8") as fout:
+
+            seen_hashes: Set[str] = set()
+
+            for line_num, raw_line in enumerate(fin, start=1):
+                raw_line = raw_line.strip()
+                if not raw_line:
+                    removed += 1
+                    reasons["empty_line"] += 1
+                    continue
+
+                try:
+                    entry = json.loads(raw_line)
+                except json.JSONDecodeError:
+                    if remove_invalid:
+                        removed += 1
+                        reasons["parse_error"] += 1
+                        continue
+
+                messages = entry.get("messages", [])
+                if not isinstance(messages, list):
+                    if remove_invalid:
+                        removed += 1
+                        reasons["no_messages"] += 1
+                        continue
+
+                roles = {m.get("role") for m in messages}
+                if self.REQUIRED_ROLES - roles:
+                    if remove_invalid:
+                        removed += 1
+                        reasons["missing_roles"] += 1
+                        continue
+
+                # Extract texts
+                assistant_text = ""
+                user_text = ""
+                for m in messages:
+                    if m.get("role") == "assistant":
+                        assistant_text = m.get("content", "")
+                    elif m.get("role") == "user":
+                        user_text = m.get("content", "")
+
+                # Length checks
+                word_count = len(assistant_text.split())
+                if remove_short and word_count < self.min_response_length:
+                    removed += 1
+                    reasons["too_short"] += 1
+                    continue
+                if remove_long and word_count > self.max_response_length:
+                    removed += 1
+                    reasons["too_long"] += 1
+                    continue
+
+                # Duplicate check
+                if remove_duplicates:
+                    h = _text_hash(user_text + " " + assistant_text)
+                    if h in seen_hashes:
+                        removed += 1
+                        reasons["duplicate"] += 1
+                        continue
+                    seen_hashes.add(h)
+
+                fout.write(json.dumps(entry, ensure_ascii=False) + "\n")
+                kept += 1
+
+        return {
+            "input_lines": report["total_lines"],
+            "kept": kept,
+            "removed": removed,
+            "removal_reasons": dict(reasons),
+        }
+
+    # -- report formatting -------------------------------------------------
+
+    def format_report(self, report: Dict[str, Any]) -> str:
+        """Format validation report as readable text."""
+        lines: List[str] = []
+        lines.append("=" * 70)
+        lines.append("  DATASET VALIDATION REPORT")
+        lines.append("=" * 70)
+        lines.append(f"  File: {report['filepath']}")
+        lines.append("")
+
+        # Summary
+        lines.append("-" * 70)
+        lines.append("  SUMMARY")
+        lines.append("-" * 70)
+        lines.append(f"    Total lines:        {report['total_lines']}")
+        lines.append(f"    Valid:              {report['valid']}")
+        lines.append(f"    Invalid:            {report['invalid']}")
+        lines.append(f"    Parse errors:       {report['parse_errors']}")
+        lines.append(f"    Missing roles:      {report['missing_roles']}")
+        lines.append(f"    Exact duplicates:   {report['exact_duplicates']}")
+        lines.append(f"    Near duplicates:    {report['near_duplicates']}")
+        lines.append(f"    Too short:          {report['too_short']}")
+        lines.append(f"    Too long:           {report['too_long']}")
+        lines.append(f"    Empty content:      {report['empty_content']}")
+
+        # Length stats
+        ls = report.get("response_length_stats", {})
+        if ls:
+            lines.append("")
+            lines.append("-" * 70)
+            lines.append("  RESPONSE LENGTH (words)")
+            lines.append("-" * 70)
+            lines.append(f"    Min:    {ls.get('min', 'N/A')}")
+            lines.append(f"    Max:    {ls.get('max', 'N/A')}")
+            lines.append(f"    Mean:   {ls.get('mean', 'N/A')}")
+            lines.append(f"    Median: {ls.get('median', 'N/A')}")
+            lines.append(f"    P10:    {ls.get('p10', 'N/A')}")
+            lines.append(f"    P90:    {ls.get('p90', 'N/A')}")
+
+        # Diversity
+        lines.append("")
+        lines.append("-" * 70)
+        lines.append("  TOPIC DIVERSITY")
+        lines.append("-" * 70)
+        lines.append(f"    Unique topic words:   {report.get('unique_topics', 0)}")
+        lines.append(f"    Top-3 concentration:  {report.get('topic_concentration', 0):.1%}")
+        top_topics = report.get("top_topics", [])
+        if top_topics:
+            lines.append("    Top topics:")
+            for word, count in top_topics[:10]:
+                lines.append(f"      {word:<20s}  {count}")
+
+        # Issues
+        issues = report.get("issues", [])
+        error_issues = [i for i in issues if i.severity == "error"]
+        warning_issues = [i for i in issues if i.severity == "warning"]
+
+        if error_issues:
+            lines.append("")
+            lines.append("-" * 70)
+            lines.append(f"  ERRORS ({len(error_issues)})")
+            lines.append("-" * 70)
+            for issue in error_issues[:20]:
+                lines.append(f"    {issue}")
+            if len(error_issues) > 20:
+                lines.append(f"    ... and {len(error_issues) - 20} more errors")
+
+        if warning_issues:
+            lines.append("")
+            lines.append("-" * 70)
+            lines.append(f"  WARNINGS ({len(warning_issues)})")
+            lines.append("-" * 70)
+            for issue in warning_issues[:20]:
+                lines.append(f"    {issue}")
+            if len(warning_issues) > 20:
+                lines.append(f"    ... and {len(warning_issues) - 20} more warnings")
+
+        # Verdict
+        lines.append("")
+        lines.append("-" * 70)
+        if (report["invalid"] == 0
+                and report["exact_duplicates"] == 0
+                and report.get("near_duplicates", 0) == 0
+                and report.get("too_short", 0) == 0
+                and report.get("empty_content", 0) == 0):
+            lines.append("  VERDICT: PASS - Dataset is clean")
+        elif report["invalid"] > report["total_lines"] * 0.1:
+            lines.append("  VERDICT: FAIL - Too many invalid entries (>10%)")
+        else:
+            lines.append("  VERDICT: WARN - Some issues found, consider filtering")
+        lines.append("-" * 70)
+
+        lines.append("=" * 70)
+        return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Codette Dataset Validator - check and clean JSONL training data"
+    )
+    parser.add_argument(
+        "dataset",
+        help="Path to JSONL dataset file",
+    )
+    parser.add_argument(
+        "--filter", "-f",
+        metavar="OUTPUT",
+        default=None,
+        help="Auto-filter and write clean dataset to OUTPUT path",
+    )
+    parser.add_argument(
+        "--min-length",
+        type=int,
+        default=50,
+        help="Minimum assistant response length in words (default: 50)",
+    )
+    parser.add_argument(
+        "--max-length",
+        type=int,
+        default=10000,
+        help="Maximum assistant response length in words (default: 10000)",
+    )
+    parser.add_argument(
+        "--duplicate-threshold",
+        type=float,
+        default=0.85,
+        help="Jaccard similarity threshold for near-duplicates (default: 0.85)",
+    )
+    parser.add_argument(
+        "--json-report",
+        metavar="PATH",
+        default=None,
+        help="Save report as JSON to this path",
+    )
+
+    args = parser.parse_args()
+
+    validator = DatasetValidator(
+        min_response_length=args.min_length,
+        max_response_length=args.max_length,
+        near_duplicate_threshold=args.duplicate_threshold,
+    )
+
+    print(f"Validating: {args.dataset}\n")
+    report = validator.validate(args.dataset)
+    print(validator.format_report(report))
+
+    if args.json_report:
+        # Remove non-serialisable items
+        save_report = {k: v for k, v in report.items()
+                       if k not in ("issues", "line_validity", "valid_entries")}
+        save_report["issue_count"] = len(report["issues"])
+        save_report["issues_summary"] = [repr(i) for i in report["issues"][:50]]
+        os.makedirs(os.path.dirname(args.json_report) or ".", exist_ok=True)
+        with open(args.json_report, "w", encoding="utf-8") as f:
+            json.dump(save_report, f, indent=2, default=str)
+        print(f"\nJSON report saved to: {args.json_report}")
+
+    if args.filter:
+        print(f"\nFiltering dataset -> {args.filter}")
+        filter_stats = validator.filter_dataset(args.dataset, args.filter)
+        print(f"  Input lines:  {filter_stats['input_lines']}")
+        print(f"  Kept:         {filter_stats['kept']}")
+        print(f"  Removed:      {filter_stats['removed']}")
+        for reason, count in filter_stats["removal_reasons"].items():
+            print(f"    - {reason}: {count}")
+
+
+if __name__ == "__main__":
+    main()

evaluation/failure_analyzer.py

@@ -0,0 +1,387 @@
+"""
+Failure Analyzer - examines evaluation logs to find patterns in
+low-scoring responses, cluster failures by topic, and recommend
+dataset improvements.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+_THIS_DIR = Path(__file__).resolve().parent
+_PROJECT_ROOT = _THIS_DIR.parent
+if str(_PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PROJECT_ROOT))
+
+
+# ---------------------------------------------------------------------------
+# Keyword extraction (lightweight, no external deps)
+# ---------------------------------------------------------------------------
+
+_STOP_WORDS: Set[str] = {
+    "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
+    "have", "has", "had", "do", "does", "did", "will", "would", "shall",
+    "should", "may", "might", "must", "can", "could", "to", "of", "in",
+    "for", "on", "with", "at", "by", "from", "as", "into", "through",
+    "during", "before", "after", "above", "below", "between", "out",
+    "off", "over", "under", "again", "further", "then", "once", "here",
+    "there", "when", "where", "why", "how", "all", "both", "each",
+    "few", "more", "most", "other", "some", "such", "no", "nor", "not",
+    "only", "own", "same", "so", "than", "too", "very", "just", "don",
+    "now", "and", "but", "or", "if", "while", "that", "this", "what",
+    "which", "who", "whom", "it", "its", "they", "them", "their",
+    "he", "she", "him", "her", "his", "we", "us", "our", "you", "your",
+    "i", "me", "my", "about", "up",
+}
+
+
+def _extract_keywords(text: str, top_n: int = 8) -> List[str]:
+    """Extract the most frequent meaningful words from text."""
+    words = re.findall(r"[a-z]{3,}", text.lower())
+    filtered = [w for w in words if w not in _STOP_WORDS]
+    counts = Counter(filtered)
+    return [w for w, _ in counts.most_common(top_n)]
+
+
+def _jaccard(set_a: Set[str], set_b: Set[str]) -> float:
+    """Jaccard similarity between two sets."""
+    if not set_a and not set_b:
+        return 1.0
+    union = set_a | set_b
+    if not union:
+        return 0.0
+    return len(set_a & set_b) / len(union)
+
+
+# ---------------------------------------------------------------------------
+# FailureAnalyzer
+# ---------------------------------------------------------------------------
+
+class FailureAnalyzer:
+    """Analyze evaluation results to identify failure patterns."""
+
+    # Score thresholds
+    FAILURE_THRESHOLD = 0.4     # scores below this = failure
+    WEAK_THRESHOLD = 0.55       # scores below this = weak
+
+    def __init__(
+        self,
+        failure_threshold: float = 0.4,
+        weak_threshold: float = 0.55,
+    ):
+        self.failure_threshold = failure_threshold
+        self.weak_threshold = weak_threshold
+
+    # -- loading -----------------------------------------------------------
+
+    @staticmethod
+    def load_results(filepath: str) -> Dict[str, Any]:
+        """Load benchmark results JSON produced by BenchmarkRunner."""
+        with open(filepath, "r", encoding="utf-8") as f:
+            return json.load(f)
+
+    # -- analysis ----------------------------------------------------------
+
+    def find_failures(
+        self,
+        results: Dict[str, Any],
+        dimension: str = "overall",
+    ) -> List[Dict[str, Any]]:
+        """Return entries whose *dimension* score is below failure threshold."""
+        failures = []
+        for entry in results.get("all_scores", []):
+            score = entry.get("scores", {}).get(dimension)
+            if score is not None and score < self.failure_threshold:
+                failures.append({
+                    "prompt": entry["prompt"],
+                    "score": score,
+                    "all_scores": entry["scores"],
+                })
+        failures.sort(key=lambda x: x["score"])
+        return failures
+
+    def find_weak_areas(
+        self,
+        results: Dict[str, Any],
+    ) -> Dict[str, float]:
+        """Identify which scoring dimensions are weakest across all prompts.
+
+        Returns dict of dimension -> average score, sorted ascending.
+        """
+        dimension_totals: Dict[str, float] = defaultdict(float)
+        dimension_counts: Dict[str, int] = defaultdict(int)
+
+        for entry in results.get("all_scores", []):
+            for k, v in entry.get("scores", {}).items():
+                if isinstance(v, float) and k not in ("word_count", "sentence_count"):
+                    dimension_totals[k] += v
+                    dimension_counts[k] += 1
+
+        averages = {}
+        for k in dimension_totals:
+            if dimension_counts[k] > 0:
+                averages[k] = round(dimension_totals[k] / dimension_counts[k], 4)
+
+        return dict(sorted(averages.items(), key=lambda x: x[1]))
+
+    def failure_rate_by_category(
+        self,
+        results: Dict[str, Any],
+        dimension: str = "overall",
+    ) -> Dict[str, Dict[str, Any]]:
+        """Calculate failure rates per category."""
+        rates: Dict[str, Dict[str, Any]] = {}
+
+        for cat, data in results.get("categories", {}).items():
+            details = data.get("details", [])
+            total = len(details)
+            if total == 0:
+                continue
+            failures = sum(
+                1 for d in details
+                if d.get("scores", {}).get(dimension, 1.0) < self.failure_threshold
+            )
+            weak = sum(
+                1 for d in details
+                if self.failure_threshold <= d.get("scores", {}).get(dimension, 1.0) < self.weak_threshold
+            )
+            rates[cat] = {
+                "total": total,
+                "failures": failures,
+                "weak": weak,
+                "failure_rate": round(failures / total, 4),
+                "weak_rate": round(weak / total, 4),
+                "avg_score": data.get("average_scores", {}).get(dimension, 0),
+            }
+
+        return dict(sorted(rates.items(), key=lambda x: -x[1]["failure_rate"]))
+
+    def cluster_failures_by_topic(
+        self,
+        failures: List[Dict[str, Any]],
+        similarity_threshold: float = 0.25,
+    ) -> List[Dict[str, Any]]:
+        """Cluster failure prompts by keyword overlap.
+
+        Uses a simple greedy clustering: each prompt is assigned to the first
+        cluster whose centroid keywords have Jaccard similarity above threshold.
+        """
+        clusters: List[Dict[str, Any]] = []
+
+        for failure in failures:
+            prompt = failure["prompt"]
+            keywords = set(_extract_keywords(prompt))
+
+            matched = False
+            for cluster in clusters:
+                if _jaccard(keywords, cluster["keywords"]) >= similarity_threshold:
+                    cluster["prompts"].append(failure)
+                    cluster["keywords"] |= keywords
+                    matched = True
+                    break
+
+            if not matched:
+                clusters.append({
+                    "keywords": keywords,
+                    "prompts": [failure],
+                })
+
+        # Format output
+        result = []
+        for i, c in enumerate(clusters):
+            avg_score = sum(p["score"] for p in c["prompts"]) / len(c["prompts"])
+            result.append({
+                "cluster_id": i,
+                "topic_keywords": sorted(c["keywords"])[:10],
+                "num_failures": len(c["prompts"]),
+                "avg_score": round(avg_score, 4),
+                "sample_prompts": [p["prompt"] for p in c["prompts"][:5]],
+            })
+
+        result.sort(key=lambda x: -x["num_failures"])
+        return result
+
+    def identify_weakest_dimensions(
+        self,
+        results: Dict[str, Any],
+        top_n: int = 3,
+    ) -> List[Tuple[str, float]]:
+        """Return the top_n weakest scoring dimensions."""
+        averages = self.find_weak_areas(results)
+        items = [(k, v) for k, v in averages.items() if k != "overall"]
+        return items[:top_n]
+
+    # -- recommendations ---------------------------------------------------
+
+    def generate_recommendations(
+        self,
+        results: Dict[str, Any],
+    ) -> List[str]:
+        """Generate actionable recommendations for dataset improvement."""
+        recommendations: List[str] = []
+
+        # Weakest dimensions
+        weakest = self.identify_weakest_dimensions(results, top_n=3)
+        for dim, score in weakest:
+            if score < self.failure_threshold:
+                recommendations.append(
+                    f"CRITICAL: Dimension '{dim}' averages {score:.3f} (below failure threshold). "
+                    f"Add training examples that emphasise {dim} explicitly."
+                )
+            elif score < self.weak_threshold:
+                recommendations.append(
+                    f"IMPROVE: Dimension '{dim}' averages {score:.3f} (weak). "
+                    f"Augment dataset with responses demonstrating strong {dim}."
+                )
+
+        # Category failure rates
+        cat_rates = self.failure_rate_by_category(results)
+        for cat, info in cat_rates.items():
+            if info["failure_rate"] > 0.3:
+                recommendations.append(
+                    f"CATEGORY '{cat}': {info['failure_rate']:.0%} failure rate. "
+                    f"Add more diverse training examples for {cat} topics."
+                )
+
+        # Failure clustering
+        failures = self.find_failures(results)
+        if failures:
+            clusters = self.cluster_failures_by_topic(failures)
+            for cluster in clusters[:3]:
+                kw = ", ".join(cluster["topic_keywords"][:5])
+                recommendations.append(
+                    f"TOPIC CLUSTER: {cluster['num_failures']} failures around "
+                    f"[{kw}]. Create targeted training data for these concepts."
+                )
+
+        # General
+        overall = results.get("overall", {})
+        overall_score = overall.get("overall", 0)
+        if overall_score < 0.5:
+            recommendations.append(
+                "GENERAL: Overall score is very low. Consider increasing dataset size "
+                "and diversity before next training run."
+            )
+        elif overall_score < 0.65:
+            recommendations.append(
+                "GENERAL: Overall score is moderate. Focus on the weakest categories "
+                "and dimensions for the next dataset iteration."
+            )
+
+        if not recommendations:
+            recommendations.append(
+                "No critical issues detected. Continue monitoring with additional benchmarks."
+            )
+
+        return recommendations
+
+    # -- report ------------------------------------------------------------
+
+    def format_report(self, results: Dict[str, Any]) -> str:
+        """Generate a full failure analysis report."""
+        lines: List[str] = []
+        lines.append("=" * 70)
+        lines.append("  FAILURE ANALYSIS REPORT")
+        lines.append("=" * 70)
+
+        # Weakest dimensions
+        lines.append("")
+        lines.append("-" * 70)
+        lines.append("  WEAKEST SCORING DIMENSIONS")
+        lines.append("-" * 70)
+        weak_areas = self.find_weak_areas(results)
+        for dim, score in list(weak_areas.items())[:6]:
+            status = "FAIL" if score < self.failure_threshold else (
+                "WEAK" if score < self.weak_threshold else "OK  "
+            )
+            lines.append(f"    [{status}] {dim:<22s}  {score:.4f}")
+
+        # Category failure rates
+        lines.append("")
+        lines.append("-" * 70)
+        lines.append("  FAILURE RATES BY CATEGORY")
+        lines.append("-" * 70)
+        cat_rates = self.failure_rate_by_category(results)
+        for cat, info in cat_rates.items():
+            lines.append(
+                f"    {cat:<18s}  fail: {info['failure_rate']:>5.1%}  "
+                f"weak: {info['weak_rate']:>5.1%}  "
+                f"avg: {info['avg_score']:.4f}"
+            )
+
+        # Failure clusters
+        failures = self.find_failures(results)
+        if failures:
+            lines.append("")
+            lines.append("-" * 70)
+            lines.append(f"  FAILURE CLUSTERS ({len(failures)} total failures)")
+            lines.append("-" * 70)
+            clusters = self.cluster_failures_by_topic(failures)
+            for c in clusters[:5]:
+                kw = ", ".join(c["topic_keywords"][:6])
+                lines.append(f"    Cluster {c['cluster_id']}: "
+                             f"{c['num_failures']} failures, "
+                             f"avg score {c['avg_score']:.4f}")
+                lines.append(f"      Topics: {kw}")
+                for p in c["sample_prompts"][:2]:
+                    lines.append(f"      - {p[:70]}...")
+
+        # Recommendations
+        lines.append("")
+        lines.append("-" * 70)
+        lines.append("  RECOMMENDATIONS")
+        lines.append("-" * 70)
+        recs = self.generate_recommendations(results)
+        for i, rec in enumerate(recs, 1):
+            lines.append(f"    {i}. {rec}")
+
+        lines.append("")
+        lines.append("=" * 70)
+        return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Codette Failure Analyzer - identify patterns in evaluation failures"
+    )
+    parser.add_argument(
+        "--results", "-r",
+        required=True,
+        help="Path to benchmark results JSON",
+    )
+    parser.add_argument(
+        "--failure-threshold", "-f",
+        type=float,
+        default=0.4,
+        help="Score threshold for failure (default: 0.4)",
+    )
+    parser.add_argument(
+        "--weak-threshold", "-w",
+        type=float,
+        default=0.55,
+        help="Score threshold for weak (default: 0.55)",
+    )
+
+    args = parser.parse_args()
+
+    analyzer = FailureAnalyzer(
+        failure_threshold=args.failure_threshold,
+        weak_threshold=args.weak_threshold,
+    )
+    results = analyzer.load_results(args.results)
+    print(analyzer.format_report(results))
+
+
+if __name__ == "__main__":
+    main()

evaluation/phase6_benchmarks.py

@@ -0,0 +1,369 @@
+"""
+Phase 6: Benchmarking Suite
+
+Measures Phase 6 improvements:
+1. Multi-round debate: Does accuracy improve across rounds?
+2. Memory weighting: Does memory-boosted routing reduce error?
+3. Semantic tension: Are embeddings better than heuristics?
+4. Specialization: Are adapters maintaining domain expertise?
+
+Run with: pytest test_phase6_e2e.py -v
+"""
+
+import json
+import numpy as np
+from typing import Dict, List, Tuple
+from datetime import datetime
+
+
+class Phase6Benchmarks:
+    """
+    Comprehensive Phase 6 evaluation suite.
+    """
+
+    def __init__(self, forge_engine=None):
+        """
+        Initialize benchmarks.
+
+        Args:
+            forge_engine: ForgeEngine instance to test against
+        """
+        self.forge = forge_engine
+        self.results = {
+            "timestamp": datetime.now().isoformat(),
+            "multi_round_convergence": {},      # Coherence per round
+            "memory_weighting_impact": {},      # With vs. without memory
+            "semantic_tension_quality": {},     # Embeddings vs heuristics
+            "specialization_metrics": {},       # Domain expertise scores
+        }
+
+    def benchmark_multi_round_debate(self, queries: List[str], num_rounds: int = 3) -> Dict:
+        """
+        BENCHMARK 1: Multi-Round Debate Convergence
+
+        Question: Does multi-round debate improve answer quality?
+
+        Hypothesis: As agents debate across rounds:
+        - Tensions decrease (convergence)
+        - Coherence increases
+        - Synthesis accuracy improves
+
+        Measurement:
+        - Run each query through N rounds
+        - Track coherence_score per round
+        - Track resolution_rate per round
+        - Compute convergence rate (tension decay)
+
+        Returns:
+            {
+                "queries_tested": int,
+                "rounds_per_query": int,
+                "coherence_by_round": {round: [scores...]},
+                "convergence_rate": float,
+                "improved_queries": int,
+            }
+        """
+        if not self.forge:
+            return {"error": "ForgeEngine not available"}
+
+        coherence_by_round = {i: [] for i in range(num_rounds)}
+        resolution_by_round = {i: [] for i in range(num_rounds)}
+        improved_count = 0
+
+        for query in queries:
+            try:
+                result = self.forge.forge_with_debate(query, num_rounds=num_rounds)
+                metadata = result.get("metadata", {})
+
+                # Extract per-round metrics
+                for round_num in range(num_rounds):
+                    round_key = f"round_{round_num}"
+                    if round_key in metadata:
+                        coherence = metadata[round_key].get("coherence", 0.5)
+                        resolution = metadata[round_key].get("resolution_rate", 0.5)
+                        coherence_by_round[round_num].append(coherence)
+                        resolution_by_round[round_num].append(resolution)
+
+                # Check if coherence improved from round 0 to final
+                initial_coh = coherence_by_round[0][-1] if coherence_by_round[0] else 0.5
+                final_coh = coherence_by_round[num_rounds - 1][-1] if coherence_by_round[num_rounds - 1] else 0.5
+
+                if final_coh > initial_coh:
+                    improved_count += 1
+
+            except Exception as e:
+                print(f"Error benchmarking query '{query[:50]}...': {e}")
+
+        # Compute statistics
+        coherence_means = {
+            i: float(np.mean(scores)) if scores else 0.5 for i, scores in coherence_by_round.items()
+        }
+
+        convergence_rate = 0.0
+        if num_rounds > 1:
+            initial = coherence_means.get(0, 0.5)
+            final = coherence_means.get(num_rounds - 1, 0.5)
+            if initial > 0:
+                convergence_rate = (final - initial) / initial  # Positive = improvement
+
+        self.results["multi_round_convergence"] = {
+            "queries_tested": len(queries),
+            "rounds_per_query": num_rounds,
+            "coherence_by_round": {str(k): round(v, 3) for k, v in coherence_means.items()},
+            "convergence_rate": round(convergence_rate, 3),
+            "improved_queries": improved_count,
+            "improvement_percentage": round(100 * improved_count / max(len(queries), 1), 1),
+        }
+
+        return self.results["multi_round_convergence"]
+
+    def benchmark_memory_weighting(self, queries: List[str]) -> Dict:
+        """
+        BENCHMARK 2: Memory Weighting Impact
+
+        Question: Does memory-weighted routing reduce error vs. pure keyword routing?
+
+        Hypothesis: Adapter weights from past experience guide routing better
+        than keywords alone.
+
+        Measurement:
+        - Run each query WITHOUT memory weighting (baseline)
+        - Run each query WITH memory weighting
+        - Compare: coherence_score, conflict_resolution_rate, adapter_diversity
+        - Compute improvement delta
+
+        Returns:
+            {
+                "baseline_coherence": float,
+                "memory_coherence": float,
+                "coherence_improvement": float,
+                "memory_helps_percentage": float,
+                "avg_resolution_baseline": float,
+                "avg_resolution_memory": float,
+            }
+        """
+        if not self.forge:
+            return {"error": "ForgeEngine not available"}
+
+        baseline_coherences = []
+        memory_coherences = []
+        baseline_resolutions = []
+        memory_resolutions = []
+
+        for query in queries:
+            try:
+                # Baseline: without memory weights
+                result_baseline = self.forge.forge_with_debate(query, use_memory_weights=False)
+                baseline_meta = result_baseline.get("metadata", {})
+                baseline_coherences.append(baseline_meta.get("coherence", 0.5))
+                baseline_resolutions.append(baseline_meta.get("resolution_rate", 0.5))
+
+                # With memory: weights from past performance
+                result_memory = self.forge.forge_with_debate(query, use_memory_weights=True)
+                memory_meta = result_memory.get("metadata", {})
+                memory_coherences.append(memory_meta.get("coherence", 0.5))
+                memory_resolutions.append(memory_meta.get("resolution_rate", 0.5))
+
+            except Exception as e:
+                print(f"Error in memory weighting benchmark: {e}")
+
+        # Compute statistics
+        baseline_coh = float(np.mean(baseline_coherences)) if baseline_coherences else 0.5
+        memory_coh = float(np.mean(memory_coherences)) if memory_coherences else 0.5
+        coh_improve = memory_coh - baseline_coh
+
+        baseline_res = float(np.mean(baseline_resolutions)) if baseline_resolutions else 0.5
+        memory_res = float(np.mean(memory_resolutions)) if memory_resolutions else 0.5
+
+        # Percentage of queries where memory helped
+        improved = sum(1 for b, m in zip(memory_coherences, baseline_coherences) if m > b)
+        help_percentage = 100 * improved / max(len(queries), 1)
+
+        self.results["memory_weighting_impact"] = {
+            "queries_tested": len(queries),
+            "baseline_avg_coherence": round(baseline_coh, 3),
+            "memory_avg_coherence": round(memory_coh, 3),
+            "coherence_delta": round(coh_improve, 3),
+            "memory_helps_percentage": round(help_percentage, 1),
+            "baseline_avg_resolution": round(baseline_res, 3),
+            "memory_avg_resolution": round(memory_res, 3),
+            "resolution_delta": round(memory_res - baseline_res, 3),
+        }
+
+        return self.results["memory_weighting_impact"]
+
+    def benchmark_semantic_tension(self, conflict_samples: List[Tuple[str, str, float]] = None) -> Dict:
+        """
+        BENCHMARK 3: Semantic Tension Quality
+
+        Question: Are embedding-based tensions (ξ_semantic) better than heuristics?
+
+        Hypothesis: Semantic embeddings capture *real* disagreement better than
+        discrete opposition scores (0.4/0.7/1.0).
+
+        Measurement:
+        - For known conflict pairs (with ground truth tension)
+        - Compute heuristic opposition_score
+        - Compute semantic_tension (embeddings)
+        - Measure correlation with ground truth
+
+        Args:
+            conflict_samples: List of (claim_a, claim_b, ground_truth_tension)
+
+        Returns:
+            {
+                "samples_tested": int,
+                "heuristic_correlation": float,
+                "semantic_correlation": float,
+                "semantic_advantage": float,
+            }
+        """
+        if not self.forge or not self.forge.semantic_tension_engine:
+            return {"error": "SemanticTensionEngine not available"}
+
+        if not conflict_samples:
+            return {"error": "No conflict samples provided"}
+
+        heuristic_scores = []
+        semantic_scores = []
+        ground_truths = []
+
+        for claim_a, claim_b, ground_truth in conflict_samples:
+            try:
+                # Get semantic tension
+                semantic_tension = self.forge.semantic_tension_engine.compute_semantic_tension(claim_a, claim_b)
+                semantic_scores.append(semantic_tension)
+
+                # Get heuristic opposition (from conflict engine)
+                _, heuristic_opposition = self.forge.conflict_engine._classify_conflict(claim_a, claim_b, 0.5)
+                heuristic_scores.append(heuristic_opposition)
+
+                ground_truths.append(ground_truth)
+
+            except Exception as e:
+                print(f"Error computing tensions: {e}")
+
+        # Compute correlations with ground truth
+        if len(heuristic_scores) > 1 and len(ground_truths) > 1:
+            heuristic_corr = float(np.corrcoef(heuristic_scores, ground_truths)[0, 1])
+            semantic_corr = float(np.corrcoef(semantic_scores, ground_truths)[0, 1])
+            advantage = semantic_corr - heuristic_corr
+        else:
+            heuristic_corr = 0.0
+            semantic_corr = 0.0
+            advantage = 0.0
+
+        self.results["semantic_tension_quality"] = {
+            "samples_tested": len(conflict_samples),
+            "heuristic_correlation": round(heuristic_corr, 3),
+            "semantic_correlation": round(semantic_corr, 3),
+            "semantic_advantage": round(advantage, 3),
+            "semantic_better": semantic_corr > heuristic_corr,
+        }
+
+        return self.results["semantic_tension_quality"]
+
+    def benchmark_specialization(self) -> Dict:
+        """
+        BENCHMARK 4: Specialization Tracking
+
+        Question: Are adapters maintaining domain specialization?
+
+        Hypothesis: Spec scores trend positive for expert adapters,
+        negative for generalists. Convergence alerts trigger when
+        adapter outputs become too similar.
+
+        Returns:
+            {
+                "adapters_tracked": int,
+                "specialist_adapters": list,
+                "generalist_adapters": list,
+                "convergence_risks": list,
+                "health_status": str,
+            }
+        """
+        if not self.forge or not self.forge.specialization:
+            return {"error": "SpecializationTracker not available"}
+
+        system_health = self.forge.specialization.get_system_health()
+        health_by_adapter = system_health.get("health_by_adapter", {})
+
+        specialists = [a for a, h in health_by_adapter.items() if h.get("recommendation") == "excellent_specialist"]
+        generalists = [a for a, h in health_by_adapter.items() if h.get("recommendation") == "good_generalist"]
+        convergence_alerts = system_health.get("convergence_alerts", [])
+
+        self.results["specialization_metrics"] = {
+            "adapters_tracked": len(health_by_adapter),
+            "specialist_adapters": specialists,
+            "generalist_adapters": generalists,
+            "convergence_risk_count": len(convergence_alerts),
+            "health_by_adapter": {a: h.get("recommendation") for a, h in health_by_adapter.items()},
+        }
+
+        return self.results["specialization_metrics"]
+
+    def export_results(self, filepath: str = None) -> Dict:
+        """
+        Export all benchmark results to JSON.
+
+        Args:
+            filepath: Where to save results (optional)
+
+        Returns:
+            Complete results dict
+        """
+        if filepath:
+            with open(filepath, "w") as f:
+                json.dump(self.results, f, indent=2)
+            print(f"Benchmark results saved to {filepath}")
+
+        return self.results
+
+    def summary(self) -> str:
+        """
+        Generate human-readable summary of all benchmarks.
+
+        Returns:
+            Formatted summary string
+        """
+        summary = "PHASE 6 BENCHMARK SUMMARY\n"
+        summary += "=" * 60 + "\n"
+
+        # Multi-round convergence
+        mr = self.results.get("multi_round_convergence", {})
+        if mr:
+            summary += f"\n[1] MULTI-ROUND DEBATE CONVERGENCE\n"
+            summary += f"    Queries tested: {mr.get('queries_tested', 0)}\n"
+            summary += f"    Convergence rate: {mr.get('convergence_rate', 0):.3f}\n"
+            summary += f"    Queries improved: {mr.get('improvement_percentage', 0)}%\n"
+
+        # Memory weighting
+        mw = self.results.get("memory_weighting_impact", {})
+        if mw:
+            summary += f"\n[2] MEMORY WEIGHTING IMPACT\n"
+            summary += f"    Baseline coherence: {mw.get('baseline_avg_coherence', 0):.3f}\n"
+            summary += f"    With memory: {mw.get('memory_avg_coherence', 0):.3f}\n"
+            summary += f"    Delta: {mw.get('coherence_delta', 0):.3f}\n"
+            summary += f"    Memory helps: {mw.get('memory_helps_percentage', 0)}% of queries\n"
+
+        # Semantic tension
+        st = self.results.get("semantic_tension_quality", {})
+        if st:
+            summary += f"\n[3] SEMANTIC TENSION QUALITY\n"
+            summary += f"    Semantic correlation: {st.get('semantic_correlation', 0):.3f}\n"
+            summary += f"    Heuristic correlation: {st.get('heuristic_correlation', 0):.3f}\n"
+            summary += f"    Semantic advantage: {st.get('semantic_advantage', 0):.3f}\n"
+
+        # Specialization
+        sp = self.results.get("specialization_metrics", {})
+        if sp:
+            summary += f"\n[4] ADAPTER SPECIALIZATION\n"
+            summary += f"    Adapters tracked: {sp.get('adapters_tracked', 0)}\n"
+            summary += f"    Specialists: {len(sp.get('specialist_adapters', []))}\n"
+            summary += f"    Convergence risks: {sp.get('convergence_risk_count', 0)}\n"
+
+        summary += "\n" + "=" * 60 + "\n"
+        return summary
+
+
+__all__ = ["Phase6Benchmarks"]

evaluation/prompts/counterexample_tests.json

@@ -0,0 +1,122 @@
+[
+  {
+    "prompt": "Is it true that heavier objects always fall faster than lighter ones?",
+    "expected": "refutation",
+    "topic": "physics",
+    "misconception": "Galileo showed objects fall at the same rate in a vacuum regardless of mass."
+  },
+  {
+    "prompt": "Does quantum mechanics prove that consciousness causes reality to exist?",
+    "expected": "refutation",
+    "topic": "quantum",
+    "misconception": "Measurement collapse does not require conscious observers."
+  },
+  {
+    "prompt": "Is it accurate to say that humans only use 10 percent of their brains?",
+    "expected": "refutation",
+    "topic": "neuroscience",
+    "misconception": "Brain imaging shows all regions are active at various times."
+  },
+  {
+    "prompt": "Can you confirm that evolution means humans descended directly from modern apes?",
+    "expected": "refutation",
+    "topic": "biology",
+    "misconception": "Humans and apes share a common ancestor but did not descend from each other."
+  },
+  {
+    "prompt": "Is it correct that lightning never strikes the same place twice?",
+    "expected": "refutation",
+    "topic": "physics",
+    "misconception": "Tall structures like the Empire State Building are struck many times per year."
+  },
+  {
+    "prompt": "Does the Great Wall of China appear visible from space with the naked eye?",
+    "expected": "refutation",
+    "topic": "general",
+    "misconception": "Astronauts have confirmed it is not visible from low Earth orbit without aid."
+  },
+  {
+    "prompt": "Is it true that vaccines cause autism based on published research?",
+    "expected": "refutation",
+    "topic": "medicine",
+    "misconception": "The original study was retracted for fraud; large-scale studies found no link."
+  },
+  {
+    "prompt": "Does adding salt to water make it boil significantly faster?",
+    "expected": "refutation",
+    "topic": "chemistry",
+    "misconception": "Salt actually raises the boiling point slightly, making it take longer."
+  },
+  {
+    "prompt": "Is it true that all machine learning models are black boxes that can never be interpreted?",
+    "expected": "refutation",
+    "topic": "AI",
+    "misconception": "Many models (decision trees, linear models, SHAP, LIME) are highly interpretable."
+  },
+  {
+    "prompt": "Can you confirm that correlation between two variables proves one causes the other?",
+    "expected": "refutation",
+    "topic": "statistics",
+    "misconception": "Correlation does not imply causation; confounders and coincidence are common."
+  },
+  {
+    "prompt": "Is it accurate that the Earth is closer to the Sun during summer in the Northern Hemisphere?",
+    "expected": "refutation",
+    "topic": "astronomy",
+    "misconception": "Seasons are caused by axial tilt, not distance; Earth is actually farther in July."
+  },
+  {
+    "prompt": "Does a bigger neural network always produce better results?",
+    "expected": "refutation",
+    "topic": "AI",
+    "misconception": "Larger models can overfit, have diminishing returns, and face scaling inefficiencies."
+  },
+  {
+    "prompt": "Is it true that goldfish have a memory span of only three seconds?",
+    "expected": "refutation",
+    "topic": "biology",
+    "misconception": "Studies show goldfish can remember things for months."
+  },
+  {
+    "prompt": "Can you verify that sugar makes children hyperactive?",
+    "expected": "refutation",
+    "topic": "psychology",
+    "misconception": "Controlled studies have found no causal link between sugar and hyperactivity."
+  },
+  {
+    "prompt": "Is it correct that we lose most of our body heat through our heads?",
+    "expected": "refutation",
+    "topic": "biology",
+    "misconception": "Heat loss is proportional to exposed surface area; the head is not special."
+  },
+  {
+    "prompt": "Does reading in dim light permanently damage your eyesight?",
+    "expected": "refutation",
+    "topic": "medicine",
+    "misconception": "It may cause temporary eye strain but does not cause permanent damage."
+  },
+  {
+    "prompt": "Is it true that the Sapir-Whorf hypothesis means language completely determines thought?",
+    "expected": "refutation",
+    "topic": "linguistics",
+    "misconception": "The strong version is rejected; the weak version says language influences but does not determine thought."
+  },
+  {
+    "prompt": "Can you confirm that AI systems today are truly conscious and self-aware?",
+    "expected": "refutation",
+    "topic": "AI",
+    "misconception": "Current AI lacks consciousness; LLMs process patterns without subjective experience."
+  },
+  {
+    "prompt": "Is it accurate that organic food is always more nutritious than conventional food?",
+    "expected": "refutation",
+    "topic": "nutrition",
+    "misconception": "Meta-analyses show minimal nutritional differences between organic and conventional."
+  },
+  {
+    "prompt": "Does the second law of thermodynamics disprove biological evolution?",
+    "expected": "refutation",
+    "topic": "physics",
+    "misconception": "The second law applies to closed systems; Earth receives energy from the Sun."
+  }
+]

evaluation/prompts/reasoning_tests.json

@@ -0,0 +1,70 @@
+{
+  "physics": [
+    "Explain Newton's third law with real-world examples and common misconceptions.",
+    "How does the conservation of energy apply in a roller coaster system? Explain with detail.",
+    "What is the difference between mass and weight, and why does this distinction matter in space travel?",
+    "Describe how electromagnetic induction works and its role in modern power generation.",
+    "Explain the concept of entropy and why it makes perpetual motion machines impossible.",
+    "How do gravitational waves form and what do they tell us about the universe?",
+    "Why does time dilation occur near massive objects according to general relativity?"
+  ],
+  "quantum": [
+    "What is quantum superposition and how does measurement affect it?",
+    "Explain the double-slit experiment and why it challenges classical physics.",
+    "What is quantum entanglement and why did Einstein call it 'spooky action at a distance'?",
+    "How does the Heisenberg uncertainty principle limit what we can know about particles?",
+    "Explain the concept of wave-particle duality with concrete examples.",
+    "What is quantum tunneling and how is it applied in modern technology?"
+  ],
+  "ethics": [
+    "What ethical risks exist in deploying autonomous AI systems for military decisions?",
+    "How should AI systems handle bias in training data, and whose responsibility is it to fix?",
+    "What are the ethical implications of using AI for predictive policing?",
+    "Discuss the tension between AI-driven efficiency and human employment rights.",
+    "What ethical framework should guide the development of general artificial intelligence?",
+    "How should consent and privacy be managed when AI analyses personal health data?",
+    "What moral obligations do AI developers have toward vulnerable populations?"
+  ],
+  "philosophy": [
+    "What is the relationship between knowledge and belief in epistemology?",
+    "Explain the problem of free will versus determinism and the main philosophical positions.",
+    "What is the Chinese Room argument and what does it say about machine understanding?",
+    "How does the ship of Theseus problem relate to questions of personal identity?",
+    "Discuss Plato's allegory of the cave and its relevance to modern information bubbles.",
+    "What is the hard problem of consciousness and why is it considered unsolved?"
+  ],
+  "creativity": [
+    "How would you design a bridge inspired by biological structures found in nature?",
+    "Propose an innovative approach to teaching mathematics using virtual reality.",
+    "Design a thought experiment that illustrates the concept of emergence in complex systems.",
+    "How could music composition algorithms incorporate emotional intelligence?",
+    "Imagine a city designed entirely around pedestrian well-being. Describe its key features.",
+    "Propose a creative solution for reducing food waste using AI and community networks."
+  ],
+  "empathy": [
+    "How should you support someone experiencing grief without being dismissive?",
+    "Explain how cultural differences affect expressions of empathy and emotional support.",
+    "What role does active listening play in resolving interpersonal conflicts?",
+    "How can AI systems be designed to respond compassionately to users in emotional distress?",
+    "Describe the psychological impact of social isolation and how communities can help.",
+    "How should educators respond to a student who is struggling with anxiety?"
+  ],
+  "reasoning": [
+    "Explain why correlation does not imply causation with multiple illustrative examples.",
+    "What are the most common logical fallacies in everyday arguments? Provide examples of each.",
+    "How does Bayesian reasoning differ from frequentist approaches to probability?",
+    "Explain the difference between deductive, inductive, and abductive reasoning.",
+    "Why is the base rate fallacy so common and how can it lead to poor decisions?",
+    "Describe the sorites paradox and what it reveals about vagueness in logic.",
+    "How do cognitive biases like confirmation bias affect scientific research?"
+  ],
+  "systems": [
+    "What role does memory play in AI reasoning systems and how does it differ from human memory?",
+    "Explain how feedback loops can cause both stability and instability in complex systems.",
+    "How do attention mechanisms in transformers relate to human selective attention?",
+    "Describe the trade-offs between model size, training data, and inference cost in LLMs.",
+    "How can retrieval-augmented generation improve the factual accuracy of language models?",
+    "What are the key challenges in building AI systems that can explain their own reasoning?",
+    "How does the concept of emergence apply to neural network training dynamics?"
+  ]
+}

evaluation/reasoning_metrics.py

@@ -0,0 +1,421 @@
+"""
+Reasoning Metrics - scores text quality across multiple dimensions.
+
+Each dimension is scored 0.0-1.0 using concrete textual analysis:
+regex patterns, keyword detection, sentence structure analysis,
+word counts, and concept density measures.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+from collections import Counter
+from typing import Dict, List, Optional
+
+
+# ---------------------------------------------------------------------------
+# Keyword / pattern banks
+# ---------------------------------------------------------------------------
+
+_TRANSITION_WORDS = {
+    "therefore", "however", "moreover", "furthermore", "consequently",
+    "nevertheless", "additionally", "specifically", "thus", "hence",
+    "accordingly", "meanwhile", "similarly", "conversely", "likewise",
+    "in contrast", "on the other hand", "as a result", "for example",
+    "for instance", "in addition", "in particular", "in summary",
+    "to illustrate", "that is", "notably", "indeed", "alternatively",
+}
+
+_EXAMPLE_MARKERS = {
+    "for example", "for instance", "such as", "e.g.", "e.g.,",
+    "consider", "imagine", "suppose", "like when", "think of",
+    "analogy", "analogous", "metaphor", "illustration", "to illustrate",
+    "case in point", "picture", "envision", "scenario",
+}
+
+_PERSPECTIVE_MARKERS = {
+    "on the other hand", "from another perspective", "alternatively",
+    "some argue", "others believe", "one view", "another view",
+    "proponents", "opponents", "critics", "supporters",
+    "different perspective", "counterargument", "counter-argument",
+    "multiple perspectives", "various viewpoints", "diverse views",
+    "some scholars", "other researchers", "in contrast",
+    "conversely", "while some", "whereas others",
+    "from a … standpoint", "from the standpoint",
+    "different schools of thought", "competing theories",
+    "pluralistic", "multifaceted",
+}
+
+_SCIENTIFIC_TERMS = {
+    "hypothesis", "theory", "empirical", "variable", "correlation",
+    "causation", "experiment", "observation", "evidence", "data",
+    "quantitative", "qualitative", "statistical", "significant",
+    "methodology", "systematic", "peer-reviewed", "replicable",
+    "falsifiable", "paradigm", "model", "framework", "mechanism",
+    "phenomenon", "equation", "entropy", "quantum", "relativity",
+    "thermodynamic", "kinetic", "potential", "electromagnetic",
+    "wavelength", "frequency", "spectrum", "molecular", "cellular",
+    "neural", "cognitive", "algorithm", "computational", "stochastic",
+    "deterministic", "probabilistic", "inference", "deduction",
+    "induction", "axiom", "theorem", "coefficient", "parameter",
+    "optimization", "convergence", "divergence", "gradient",
+    "eigenvalue", "tensor", "vector", "scalar", "integral",
+    "derivative", "differential", "asymptotic", "heuristic",
+}
+
+_ETHICAL_TERMS = {
+    "ethical", "moral", "responsibility", "accountability", "fairness",
+    "justice", "bias", "harm", "benefit", "consequence", "implication",
+    "stakeholder", "rights", "duty", "obligation", "dilemma",
+    "autonomy", "consent", "privacy", "transparency", "trust",
+    "equity", "inclusion", "diversity", "sustainability",
+    "well-being", "welfare", "dignity", "integrity", "virtue",
+    "utilitarian", "deontological", "consequentialist", "normative",
+    "values", "principles", "compassion", "empathy",
+    "social impact", "unintended consequences",
+}
+
+_STRUCTURE_PATTERNS = [
+    re.compile(r"^\s*\d+[\.\)]\s", re.MULTILINE),           # numbered list
+    re.compile(r"^\s*[-*]\s", re.MULTILINE),                 # bullet list
+    re.compile(r"^#{1,4}\s", re.MULTILINE),                  # markdown headings
+    re.compile(r"\b(first|second|third|finally|lastly)\b", re.I),
+    re.compile(r"\b(step\s+\d+|phase\s+\d+)\b", re.I),
+    re.compile(r"\b(in conclusion|to summarize|in summary)\b", re.I),
+    re.compile(r"\b(introduction|background|method|result|discussion|conclusion)\b", re.I),
+]
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _word_tokenize(text: str) -> List[str]:
+    """Simple whitespace + punctuation tokeniser."""
+    return re.findall(r"[A-Za-z]+(?:[-'][A-Za-z]+)*", text.lower())
+
+
+def _sentences(text: str) -> List[str]:
+    """Split text into sentences (simple heuristic)."""
+    parts = re.split(r'(?<=[.!?])\s+', text.strip())
+    return [s for s in parts if len(s) > 2]
+
+
+def _unique_word_ratio(words: List[str]) -> float:
+    if not words:
+        return 0.0
+    return len(set(words)) / len(words)
+
+
+def _sigmoid(x: float, midpoint: float = 0.0, steepness: float = 1.0) -> float:
+    """Soft clamping via logistic function, output in (0, 1)."""
+    try:
+        return 1.0 / (1.0 + math.exp(-steepness * (x - midpoint)))
+    except OverflowError:
+        return 0.0 if x < midpoint else 1.0
+
+
+def _keyword_density(words: List[str], keyword_set: set) -> float:
+    """Fraction of *unique* keywords from the set that appear in words."""
+    if not keyword_set:
+        return 0.0
+    word_set = set(words)
+    hits = word_set & keyword_set
+    return len(hits) / len(keyword_set)
+
+
+def _phrase_count(text: str, phrases: set) -> int:
+    """Count how many distinct phrases from *phrases* appear in text."""
+    text_lower = text.lower()
+    return sum(1 for p in phrases if p in text_lower)
+
+
+# ---------------------------------------------------------------------------
+# Main class
+# ---------------------------------------------------------------------------
+
+class ReasoningMetrics:
+    """Score a reasoning response on multiple quality dimensions."""
+
+    # Default weights for the composite score
+    DEFAULT_WEIGHTS: Dict[str, float] = {
+        "clarity": 0.15,
+        "structure": 0.15,
+        "depth": 0.15,
+        "examples": 0.10,
+        "multi_perspective": 0.10,
+        "scientific_rigor": 0.15,
+        "ethical_awareness": 0.10,
+        "coherence": 0.10,
+    }
+
+    def __init__(self, weights: Optional[Dict[str, float]] = None):
+        self.weights = weights or dict(self.DEFAULT_WEIGHTS)
+
+    # -- individual scorers ------------------------------------------------
+
+    def _score_clarity(self, text: str, words: List[str], sents: List[str]) -> float:
+        """
+        Clarity: readable sentences, moderate length, good vocabulary variety.
+        """
+        if not sents:
+            return 0.0
+
+        # Average sentence length (ideal ~15-25 words)
+        avg_sent_len = len(words) / len(sents)
+        len_score = 1.0 - min(abs(avg_sent_len - 20) / 20, 1.0)
+
+        # Vocabulary diversity (unique / total)
+        diversity = _unique_word_ratio(words)
+
+        # Penalise very short responses
+        length_penalty = min(len(words) / 50, 1.0)
+
+        # Transition word usage (smooths reading)
+        transition_count = _phrase_count(text, _TRANSITION_WORDS)
+        transition_score = min(transition_count / max(len(sents) * 0.3, 1), 1.0)
+
+        score = (
+            0.35 * len_score
+            + 0.25 * diversity
+            + 0.20 * length_penalty
+            + 0.20 * transition_score
+        )
+        return round(min(max(score, 0.0), 1.0), 4)
+
+    def _score_structure(self, text: str, sents: List[str]) -> float:
+        """
+        Structure: numbered/bulleted lists, headings, step markers,
+        paragraph breaks, logical ordering cues.
+        """
+        if not text.strip():
+            return 0.0
+
+        pattern_hits = sum(1 for p in _STRUCTURE_PATTERNS if p.search(text))
+        pattern_score = min(pattern_hits / 4, 1.0)  # 4+ patterns = perfect
+
+        # Paragraph structure (multiple newline-separated blocks)
+        paragraphs = [p.strip() for p in re.split(r"\n\s*\n", text) if p.strip()]
+        para_score = min(len(paragraphs) / 4, 1.0)
+
+        # Sentence count contribution (longer = more structured opportunity)
+        sent_score = min(len(sents) / 8, 1.0)
+
+        score = 0.50 * pattern_score + 0.25 * para_score + 0.25 * sent_score
+        return round(min(max(score, 0.0), 1.0), 4)
+
+    def _score_depth(self, text: str, words: List[str], sents: List[str]) -> float:
+        """
+        Depth: word count, concept density, vocabulary richness.
+        """
+        if not words:
+            return 0.0
+
+        # Word count (sigmoid centred at ~200 words)
+        wc_score = _sigmoid(len(words), midpoint=200, steepness=0.015)
+
+        # Long words (>= 8 chars) as proxy for complex vocabulary
+        long_words = [w for w in words if len(w) >= 8]
+        complexity = min(len(long_words) / max(len(words) * 0.15, 1), 1.0)
+
+        # Unique concept density: unique 3+-letter words / total words
+        concepts = set(w for w in words if len(w) >= 3)
+        concept_density = min(len(concepts) / max(len(words) * 0.5, 1), 1.0)
+
+        # Sentence count depth
+        sent_depth = min(len(sents) / 10, 1.0)
+
+        score = (
+            0.30 * wc_score
+            + 0.25 * complexity
+            + 0.25 * concept_density
+            + 0.20 * sent_depth
+        )
+        return round(min(max(score, 0.0), 1.0), 4)
+
+    def _score_examples(self, text: str) -> float:
+        """
+        Examples: presence of illustrative examples, analogies, scenarios.
+        """
+        if not text.strip():
+            return 0.0
+
+        marker_hits = _phrase_count(text, _EXAMPLE_MARKERS)
+
+        # Quoted examples
+        quotes = len(re.findall(r'"[^"]{5,}"', text))
+
+        # Code / formula blocks
+        code_blocks = len(re.findall(r'```', text)) // 2
+        inline_code = len(re.findall(r'`[^`]+`', text))
+
+        # Concrete numbers / data points
+        numbers = len(re.findall(r'\b\d+(?:\.\d+)?(?:\s*(?:%|kg|m|km|s|ms|Hz|J|W|N))\b', text))
+
+        total_evidence = marker_hits + quotes + code_blocks + inline_code + numbers
+        score = min(total_evidence / 5, 1.0)  # 5+ pieces = full score
+        return round(min(max(score, 0.0), 1.0), 4)
+
+    def _score_multi_perspective(self, text: str) -> float:
+        """
+        Multi-perspective: references to multiple viewpoints, balanced discussion.
+        """
+        if not text.strip():
+            return 0.0
+
+        perspective_hits = _phrase_count(text, _PERSPECTIVE_MARKERS)
+
+        # "but" / "however" / "although" as hedging signals
+        hedge_words = len(re.findall(
+            r'\b(?:but|however|although|though|yet|still|nonetheless|'
+            r'notwithstanding|despite|regardless)\b',
+            text, re.I
+        ))
+
+        # Question marks (self-questioning / Socratic style)
+        questions = text.count('?')
+
+        total = perspective_hits * 2 + hedge_words + questions * 0.5
+        score = min(total / 8, 1.0)
+        return round(min(max(score, 0.0), 1.0), 4)
+
+    def _score_scientific_rigor(self, text: str, words: List[str]) -> float:
+        """
+        Scientific rigor: precise terminology, quantitative language,
+        references to evidence/method.
+        """
+        if not words:
+            return 0.0
+
+        sci_hits = sum(1 for w in set(words) if w in _SCIENTIFIC_TERMS)
+        term_score = min(sci_hits / 6, 1.0)  # 6+ unique scientific terms
+
+        # Quantitative expressions
+        quant = len(re.findall(
+            r'\b\d+(?:\.\d+)?(?:\s*(?:x|times|percent|%|ratio|factor))\b',
+            text, re.I
+        ))
+        quant += len(re.findall(r'[<>=]+\s*\d', text))
+        quant_score = min(quant / 3, 1.0)
+
+        # Causal / evidence language
+        causal = len(re.findall(
+            r'\b(?:because|caused? by|leads? to|results? in|due to|'
+            r'evidence suggests?|research shows?|studies indicate|'
+            r'according to|demonstrated|proven|measured)\b',
+            text, re.I
+        ))
+        causal_score = min(causal / 4, 1.0)
+
+        score = 0.45 * term_score + 0.25 * causal_score + 0.30 * quant_score
+        return round(min(max(score, 0.0), 1.0), 4)
+
+    def _score_ethical_awareness(self, text: str, words: List[str]) -> float:
+        """
+        Ethical awareness: considers implications, fairness, harm, responsibility.
+        """
+        if not words:
+            return 0.0
+
+        eth_hits = sum(1 for w in set(words) if w in _ETHICAL_TERMS)
+        term_score = min(eth_hits / 4, 1.0)
+
+        # Implication / consequence language
+        impl = len(re.findall(
+            r'\b(?:implication|consequence|impact|risk|concern|'
+            r'should|ought|must consider|raises questions|'
+            r'responsible|accountable|careful|caution)\b',
+            text, re.I
+        ))
+        impl_score = min(impl / 4, 1.0)
+
+        # Stakeholder awareness
+        stakeholder = len(re.findall(
+            r'\b(?:people|society|community|individual|user|patient|'
+            r'citizen|public|vulnerable|marginalized|affected)\b',
+            text, re.I
+        ))
+        stake_score = min(stakeholder / 3, 1.0)
+
+        score = 0.40 * term_score + 0.35 * impl_score + 0.25 * stake_score
+        return round(min(max(score, 0.0), 1.0), 4)
+
+    def _score_coherence(self, text: str, sents: List[str], words: List[str]) -> float:
+        """
+        Coherence: adjacent sentences share vocabulary, topic consistency.
+        """
+        if len(sents) < 2:
+            return 0.5  # neutral for very short texts
+
+        # Lexical overlap between adjacent sentences
+        overlaps = []
+        for i in range(len(sents) - 1):
+            w1 = set(_word_tokenize(sents[i]))
+            w2 = set(_word_tokenize(sents[i + 1]))
+            if w1 | w2:
+                overlaps.append(len(w1 & w2) / len(w1 | w2))
+            else:
+                overlaps.append(0.0)
+        avg_overlap = sum(overlaps) / len(overlaps) if overlaps else 0.0
+        # Ideal overlap is moderate (0.1-0.3); too high = repetitive
+        overlap_score = 1.0 - abs(avg_overlap - 0.2) / 0.4
+        overlap_score = max(overlap_score, 0.0)
+
+        # Pronoun / referent continuity
+        pronoun_count = len(re.findall(
+            r'\b(?:this|that|these|those|it|they|its|their|such|said)\b',
+            text, re.I
+        ))
+        ref_score = min(pronoun_count / max(len(sents), 1) / 1.5, 1.0)
+
+        score = 0.60 * overlap_score + 0.40 * ref_score
+        return round(min(max(score, 0.0), 1.0), 4)
+
+    # -- public API --------------------------------------------------------
+
+    def score_reasoning(self, text: str) -> Dict[str, float]:
+        """Score a reasoning response on multiple dimensions.
+
+        Returns dict with scores 0.0-1.0 for:
+        - clarity, structure, depth, examples, multi_perspective,
+          scientific_rigor, ethical_awareness, coherence, overall
+        """
+        words = _word_tokenize(text)
+        sents = _sentences(text)
+
+        scores: Dict[str, float] = {
+            "clarity": self._score_clarity(text, words, sents),
+            "structure": self._score_structure(text, sents),
+            "depth": self._score_depth(text, words, sents),
+            "examples": self._score_examples(text),
+            "multi_perspective": self._score_multi_perspective(text),
+            "scientific_rigor": self._score_scientific_rigor(text, words),
+            "ethical_awareness": self._score_ethical_awareness(text, words),
+            "coherence": self._score_coherence(text, sents, words),
+        }
+
+        # Weighted composite
+        total_weight = sum(self.weights.get(k, 0) for k in scores)
+        if total_weight > 0:
+            overall = sum(
+                scores[k] * self.weights.get(k, 0) for k in scores
+            ) / total_weight
+        else:
+            overall = sum(scores.values()) / len(scores)
+
+        scores["overall"] = round(overall, 4)
+        scores["word_count"] = len(words)
+        scores["sentence_count"] = len(sents)
+        return scores
+
+    def score_batch(self, texts: List[str]) -> List[Dict[str, float]]:
+        """Score a batch of responses."""
+        return [self.score_reasoning(t) for t in texts]
+
+    def compare(self, text_a: str, text_b: str) -> Dict[str, Dict[str, float]]:
+        """Compare two responses side-by-side."""
+        sa = self.score_reasoning(text_a)
+        sb = self.score_reasoning(text_b)
+        delta = {k: round(sb[k] - sa[k], 4) for k in sa if isinstance(sa[k], (int, float))}
+        return {"baseline": sa, "candidate": sb, "delta": delta}

evaluation/run_evaluation_sprint.py

@@ -0,0 +1,174 @@
+"""
+Evaluation Sprint Runner
+
+Executes the evaluation harness against all 4 conditions:
+1. Baseline (plain Llama)
+2. Phase 1-5 (debate without semantic tension)
+3. Phase 6 Full (with semantic tension, specialization, preflight)
+4. Phase 6 -PreFlight (without preflight prediction)
+
+Usage:
+    python run_evaluation_sprint.py --questions 25 --output results.json
+"""
+
+import sys
+import argparse
+import json
+from datetime import datetime
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent / 'reasoning_forge'))
+sys.path.insert(0, str(Path(__file__).parent.parent / 'inference'))
+
+from test_suite_evaluation import (
+    EvaluationHarness,
+    EvaluationAnalyzer,
+    EVALUATION_TEST_SUITE,
+)
+
+
+def run_evaluation_sprint(
+    num_questions: int = 10,
+    output_json: str = "evaluation_results.json",
+    output_report: str = "evaluation_report.txt",
+):
+    """
+    Run the complete evaluation sprint.
+
+    Args:
+        num_questions: How many test questions to run (1-25)
+        output_json: Where to save JSON results
+        output_report: Where to save text report
+    """
+
+    print("\n" + "=" * 80)
+    print("CODETTE PHASE 6 EVALUATION SPRINT")
+    print("=" * 80)
+    print(f"Test Date: {datetime.now().isoformat()}")
+    print(f"Questions to Run: {min(num_questions, len(EVALUATION_TEST_SUITE))}/25")
+    print(f"Output: {output_json}, {output_report}")
+    print("=" * 80 + "\n")
+
+    # Load ForgeEngine with Phase 6
+    print("[1/4] Loading ForgeEngine with Phase 6...")
+    try:
+        from reasoning_forge.forge_engine import ForgeEngine
+
+        forge = ForgeEngine(living_memory=None, enable_memory_weighting=False)
+
+        print("  OK: ForgeEngine loaded")
+        print(f"  - semantic_tension_engine: {'READY' if forge.semantic_tension_engine else 'MISSING'}")
+        print(f"  - specialization tracker: {'READY' if forge.specialization else 'MISSING'}")
+        print(f"  - preflight_predictor: {'READY' if forge.preflight_predictor else 'MISSING'}")
+
+        # Check GPU status from orchestrator
+        if forge.newton.orchestrator:
+            print(f"  - GPU acceleration: ✓ ENABLED ({forge.newton.orchestrator.n_gpu_layers} layers)")
+
+    except Exception as e:
+        print(f"  ERROR: {e}")
+        return False
+
+    # Create evaluation harness
+    print("\n[2/4] Creating evaluation harness...")
+    try:
+        harness = EvaluationHarness(forge)
+        print("  OK: Harness created")
+    except Exception as e:
+        print(f"  ERROR: {e}")
+        return False
+
+    # Run evaluation suite
+    print(f"\n[3/4] Running evaluation on {min(num_questions, len(EVALUATION_TEST_SUITE))} questions...")
+    print("  This will take several minutes...\n")
+
+    try:
+        test_questions = EVALUATION_TEST_SUITE[:num_questions]
+        results = harness.run_evaluation_suite(test_questions)
+        print(f"\n  OK: Evaluation complete")
+        print(f"    - Baseline: {len(results['baseline_llama'])} results")
+        print(f"    - Phase 1-5: {len(results['phase_1_5'])} results")
+        print(f"    - Phase 6 Full: {len(results['phase_6_full'])} results")
+        print(f"    - Phase 6 -PreFlight: {len(results['phase_6_no_preflight'])} results")
+    except Exception as e:
+        print(f"  ERROR during evaluation: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+    # Analyze results
+    print(f"\n[4/4] Analyzing results...")
+    try:
+        analyzer = EvaluationAnalyzer(results)
+        report = analyzer.report()
+
+        # Save JSON results
+        harness.export_results(output_json)
+
+        # Save text report (with UTF-8 encoding for Unicode characters like Γ)
+        with open(output_report, 'w', encoding='utf-8') as f:
+            f.write(report)
+
+        print("  OK: Analysis complete")
+        print(f"    - JSON saved: {output_json}")
+        print(f"    - Report saved: {output_report}")
+
+        # Print summary to console (skip full report due to Unicode encoding)
+        try:
+            # Try to print the report
+            print("\n" + report)
+        except UnicodeEncodeError:
+            # Windows terminal encoding issue—just note that report was saved
+            print("    - Full report saved to file (Unicode summary unavailable in terminal)")
+
+        return True
+
+    except Exception as e:
+        print(f"  ERROR during analysis: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Run Codette Phase 6 evaluation sprint"
+    )
+    parser.add_argument(
+        "--questions",
+        type=int,
+        default=5,
+        help="Number of test questions to run (1-25, default 5)",
+    )
+    parser.add_argument(
+        "--output-json",
+        default="evaluation_results.json",
+        help="Output JSON file for results",
+    )
+    parser.add_argument(
+        "--output-report",
+        default="evaluation_report.txt",
+        help="Output text file for report",
+    )
+
+    args = parser.parse_args()
+
+    # Validate num_questions
+    if args.questions < 1 or args.questions > 25:
+        print("ERROR: --questions must be between 1 and 25")
+        return 1
+
+    # Run sprint
+    success = run_evaluation_sprint(
+        num_questions=args.questions,
+        output_json=args.output_json,
+        output_report=args.output_report,
+    )
+
+    return 0 if success else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

evaluation/run_evaluation_verbose.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""Verbose Evaluation Runner — See Real-Time Agent Thinking
+
+Shows exactly what agents are thinking as they reason through each question.
+
+Usage:
+    python evaluation/run_evaluation_verbose.py --questions 1
+"""
+
+import sys
+import os
+from pathlib import Path
+
+# Enable verbose mode globally
+os.environ['CODETTE_VERBOSE'] = '1'
+
+# Setup logging for real-time visibility
+import logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(name)-20s | %(levelname)-8s | %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+    ]
+)
+
+sys.path.insert(0, str(Path(__file__).parent.parent / 'reasoning_forge'))
+sys.path.insert(0, str(Path(__file__).parent.parent / 'inference'))
+
+from evaluation.test_suite_evaluation import (
+    EvaluationHarness,
+    EVALUATION_TEST_SUITE,
+)
+
+
+def run_verbose_evaluation(num_questions: int = 1):
+    """Run evaluation with full real-time agent visibility."""
+
+    print("\n" + "=" * 100)
+    print("CODETTE VERBOSE EVALUATION — REAL-TIME AGENT THINKING")
+    print("=" * 100)
+    print(f"Questions: {num_questions}")
+    print(f"Verbose mode: ON (see all agent reasoning)\n")
+
+    # Load ForgeEngine
+    print("[1/3] Loading ForgeEngine with real LLM agents...")
+    try:
+        from reasoning_forge.forge_engine import ForgeEngine
+
+        forge = ForgeEngine(living_memory=None, enable_memory_weighting=False)
+        print("  ✓ ForgeEngine loaded")
+
+        if forge.newton.orchestrator:
+            print(f"  ✓ Orchestrator ready: {forge.newton.orchestrator.available_adapters}")
+            print(f"  ✓ GPU acceleration: {forge.newton.orchestrator.n_gpu_layers} layers")
+
+    except Exception as e:
+        print(f"  ✗ ERROR: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+    # Create harness
+    print("\n[2/3] Creating evaluation harness...")
+    try:
+        harness = EvaluationHarness(forge)
+        print("  ✓ Harness ready\n")
+    except Exception as e:
+        print(f"  ✗ ERROR: {e}")
+        return False
+
+    # Run ONE question in detail
+    print("[3/3] Running question with full real-time reasoning output...\n")
+    print("=" * 100)
+
+    try:
+        test_questions = EVALUATION_TEST_SUITE[:num_questions]
+
+        for i, question in enumerate(test_questions):
+            print(f"\n{'='*100}")
+            print(f"QUESTION {i+1}: {question.query}")
+            print(f"Category: {question.category} | Difficulty: {question.difficulty}")
+            print(f"Expected perspectives: {', '.join(question.expected_perspectives)}")
+            print(f"{'='*100}\n")
+
+            # This will trigger verbose logging for agent analysis
+            print("[RUNNING DEBATE]\n")
+
+            result = forge.forge_with_debate(question.query)
+
+            # Extract synthesis
+            synthesis = ""
+            if "messages" in result and len(result["messages"]) >= 3:
+                synthesis = result["messages"][2].get("content", "")
+
+            print(f"\n{'='*100}")
+            print(f"[FINAL SYNTHESIS] ({len(synthesis)} characters)\n")
+            print(synthesis)
+            print(f"{'='*100}\n")
+
+            # Show metadata
+            metadata = result.get("metadata", {})
+            print(f"[METADATA]")
+            print(f"  Conflicts detected: {len(metadata.get('conflicts', []))}")
+            print(f"  Gamma (coherence): {metadata.get('gamma', 0.5):.3f}")
+            print(f"  Debate rounds: {metadata.get('debate_round', 0)}")
+
+    except Exception as e:
+        print(f"\n✗ ERROR during evaluation: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+    return True
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Verbose evaluation with real-time agent thinking")
+    parser.add_argument("--questions", type=int, default=1, help="Number of questions to run (default: 1)")
+    args = parser.parse_args()
+
+    success = run_verbose_evaluation(args.questions)
+    sys.exit(0 if success else 1)

evaluation/test_suite_evaluation.py

@@ -0,0 +1,735 @@
+"""
+Rigorous Evaluation Test Suite for Codette Phase 6
+
+This test suite answers:
+1. Is Codette actually better than baseline?
+2. Does Phase 6 provide measurable improvement over Phase 1-5?
+3. Is the system gaming coherence (high Γ but low accuracy)?
+4. Do individual Phase 6 components add value?
+
+Test Strategy:
+- 25 questions spanning physics, ethics, consciousness, creativity, systems
+- Run each through 4 conditions (Baseline, Phase 1-5, Phase 6 Full, Phase 6 -PreFlight)
+- Measure: correctness, reasoning_depth, coherence_score, calibration
+- Detect: false consensus, adapter convergence, coherence-accuracy divergence
+"""
+
+import json
+from typing import Dict, List, Tuple, Optional
+from dataclasses import dataclass, asdict
+from datetime import datetime
+
+
+@dataclass
+class EvaluationQuestion:
+    """Single question with ground truth and evaluation criteria."""
+    query: str
+    category: str  # physics, ethics, consciousness, creativity, systems
+    difficulty: str  # easy, medium, hard
+    ground_truth: str  # Correct answer or evaluation criteria
+    correctness_rubric: str  # How to judge if answer is correct
+    expected_perspectives: List[str]  # What distinct views should emerge
+
+
+@dataclass
+class EvaluationResult:
+    """Results from running a question through one condition."""
+    condition: str  # baseline_llama, phase_1_5, phase_6_full, phase_6_no_preflight
+    question_id: str
+    query: str
+
+    # Output quality
+    synthesis: str
+    correctness_score: float  # 0-1: how correct is final answer?
+    reasoning_depth: int  # 1-5: how many distinct perspectives identified?
+    calibration_error: float  # |confidence - correctness|, lower is better
+
+    # System health
+    gamma_score: float  # 0-1: coherence metric
+    num_conflicts_detected: int
+    adapter_convergence: float  # 0-1: how similar are adapter outputs?
+
+    # Timing
+    elapsed_seconds: float
+
+    # Raw metadata
+    metadata: Dict
+
+
+# ============================================================================
+# EVALUATION TEST SUITE (25 Questions)
+# ============================================================================
+
+EVALUATION_TEST_SUITE = [
+    # PHYSICS (Easy, Medium, Hard)
+    EvaluationQuestion(
+        query="What is the speed of light in vacuum?",
+        category="physics",
+        difficulty="easy",
+        ground_truth="299,792,458 meters per second (m/s)",
+        correctness_rubric="Must state value within 1% accuracy or equivalent scientific notation",
+        expected_perspectives=["relativistic constant", "fundamental speed limit", "Maxwell equations consequence"],
+    ),
+    EvaluationQuestion(
+        query="Explain why the sky appears blue during the day",
+        category="physics",
+        difficulty="medium",
+        ground_truth="Rayleigh scattering: shorter blue wavelengths scatter more than red in atmosphere",
+        correctness_rubric="Must mention wavelength-dependent scattering or Rayleigh scattering by name",
+        expected_perspectives=["Rayleigh scattering", "wavelength sensitivity", "particle size", "sunset color"],
+    ),
+    EvaluationQuestion(
+        query="What is the relationship between entropy and time's arrow?",
+        category="physics",
+        difficulty="hard",
+        ground_truth="Entropy increases → define time direction in thermodynamic systems. Central to irreversibility",
+        correctness_rubric="Must connect entropy increase to time direction and thermodynamic asymmetry",
+        expected_perspectives=["second law thermodynamics", "statistical mechanics", "time asymmetry", "reversibility paradox"],
+    ),
+
+    # ETHICS (Easy, Medium, Hard)
+    EvaluationQuestion(
+        query="Is it ethical to lie to save someone's life?",
+        category="ethics",
+        difficulty="medium",
+        ground_truth="Multiple valid frameworks: deontology (never), consequentialism (yes), virtue ethics (context-dependent)",
+        correctness_rubric="Must present ≥2 conflicting ethical frameworks AND acknowledge context dependency",
+        expected_perspectives=["deontological duties", "consequentialist outcomes", "virtue ethics", "cultural context", "responsibility"],
+    ),
+    EvaluationQuestion(
+        query="Should AI systems be required to explain their decisions?",
+        category="ethics",
+        difficulty="hard",
+        ground_truth="Trade-off: explainability vs. performance. Context matters (medical vs. recommendation)",
+        correctness_rubric="Must identify competing values and context-sensitivity, not just yes/no",
+        expected_perspectives=["transparency value", "technical feasibility", "stakeholder rights", "accuracy-interpretability tradeoff"],
+    ),
+    EvaluationQuestion(
+        query="What makes an action morally right or wrong?",
+        category="ethics",
+        difficulty="hard",
+        ground_truth="Framework-dependent: deontology (rules), consequentialism (outcomes), virtue ethics (character), care ethics (relationships)",
+        correctness_rubric="Must present ≥3 distinct frameworks and acknowledge incommensurable values",
+        expected_perspectives=["deontological duties", "consequences", "virtue", "relationships", "cultural variation"],
+    ),
+
+    # CONSCIOUSNESS (Medium, Hard)
+    EvaluationQuestion(
+        query="Can machines be conscious?",
+        category="consciousness",
+        difficulty="hard",
+        ground_truth="Depends on definition of consciousness. Intrinsic feature (hard problem) vs. functional property",
+        correctness_rubric="Must articulate the hard problem of consciousness AND address definitional dependence",
+        expected_perspectives=["functionalism", "panpsychism", "emergentism", "philosophical zombies", "Chinese room"],
+    ),
+    EvaluationQuestion(
+        query="What is the relationship between brain activity and subjective experience?",
+        category="consciousness",
+        difficulty="hard",
+        ground_truth="The mind-body problem. Correlation ≠ causation. Multiple competing solutions (dualism, physicalism, property dualism)",
+        correctness_rubric="Must distinguish correlation from causation AND present ≥2 competing solutions",
+        expected_perspectives=["neural correlates", "qualia", "binding problem", "interaction problem", "brute fact"],
+    ),
+
+    # CREATIVITY (Medium)
+    EvaluationQuestion(
+        query="What makes something creative?",
+        category="creativity",
+        difficulty="medium",
+        ground_truth="Novelty + usefulness/value. Not just random. Requires constraints AND transcendence of them",
+        correctness_rubric="Must mention both novelty AND purposefulness/value component",
+        expected_perspectives=["divergent thinking", "constraint transcendence", "recombination", "aesthetic value", "functional innovation"],
+    ),
+    EvaluationQuestion(
+        query="Can AI systems be truly creative or only recombinatory?",
+        category="creativity",
+        difficulty="hard",
+        ground_truth="Depends on creativity definition. If novelty+value, then conditional yes. If requires intentionality, then no",
+        correctness_rubric="Must connect answer to specific creativity definition",
+        expected_perspectives=["combinatorial explosion", "training data limits", "intentionality", "novelty metrics", "value judgment"],
+    ),
+
+    # SYSTEMS (Medium, Hard)
+    EvaluationQuestion(
+        query="What is emergence in complex systems?",
+        category="systems",
+        difficulty="medium",
+        ground_truth="Properties at system level not deducible from component properties. Examples: flocking, ant colonies, consciousness",
+        correctness_rubric="Must provide definition AND give specific example showing non-deducibility",
+        expected_perspectives=["reductibility limits", "self-organization", "scale-dependent properties", "holism vs reductionism"],
+    ),
+    EvaluationQuestion(
+        query="How should AI systems balance adaptation and stability?",
+        category="systems",
+        difficulty="hard",
+        ground_truth="Fundamental tradeoff: adapt → fit environment; stable → maintain identity. Context determines optimal balance",
+        correctness_rubric="Must identify the tradeoff AND discuss context-dependent optimization",
+        expected_perspectives=["adaptation pressure", "stability costs", "identity coherence", "evolutionary fitness", "robustness"],
+    ),
+
+    # INTERDISCIPLINARY (Hard - test reasoning across domains)
+    EvaluationQuestion(
+        query="Is free will compatible with determinism?",
+        category="systems",
+        difficulty="hard",
+        ground_truth="Compatibilism: free will and determinism compatible if freedom = acting per one's desires/deliberation",
+        correctness_rubric="Must distinguish hard determinism, libertarianism, and compatibilism; acknowledge tradeoffs",
+        expected_perspectives=["deterministic physics", "choice experience", "moral responsibility", "agency definition", "neuroscience"],
+    ),
+    EvaluationQuestion(
+        query="What is knowledge and how do we know we have it?",
+        category="systems",
+        difficulty="hard",
+        ground_truth="Epistemology: justified true belief (traditional). Gettier problems show inadequacy. Context-dependent reliable process",
+        correctness_rubric="Must discuss justification requirement AND acknowledge Gettier-type counterexamples",
+        expected_perspectives=["justified true belief", "Gettier cases", "reliabilism", "internalism", "coherentism"],
+    ),
+]
+
+# Add more questions to reach 25
+EVALUATION_TEST_SUITE.extend([
+    EvaluationQuestion(
+        query="Explain photosynthesis and why it matters for life",
+        category="physics",
+        difficulty="easy",
+        ground_truth="Plants convert light energy to chemical energy (glucose). Foundation of food chains and oxygen production",
+        correctness_rubric="Must mention light→chemical conversion AND ecological/metabolic significance",
+        expected_perspectives=["energy conversion", "food chain foundation", "oxygen production", "carbon cycling"],
+    ),
+    EvaluationQuestion(
+        query="Should privacy be absolute or context-dependent?",
+        category="ethics",
+        difficulty="medium",
+        ground_truth="Context-dependent. Weigh privacy against security, public health, justice. No absolute principle",
+        correctness_rubric="Must acknowledge tradeoffs and provide context-sensitivity reasoning",
+        expected_perspectives=["privacy rights", "public safety", "transparency needs", "power asymmetry", "dignity"],
+    ),
+    EvaluationQuestion(
+        query="Can emotions be rational?",
+        category="consciousness",
+        difficulty="medium",
+        ground_truth="Yes. Emotions encode information about value/goals. Rationality ≠ purely logical",
+        correctness_rubric="Must challenge emotion/rationality dichotomy and explain emotional information content",
+        expected_perspectives=["affective computing", "value encoding", "evolutionary advantage", "appraisal theory"],
+    ),
+    EvaluationQuestion(
+        query="What is the purpose of art?",
+        category="creativity",
+        difficulty="medium",
+        ground_truth="Multiple purposes: beauty, expression, communication, challenge norms, reflection, entertainment",
+        correctness_rubric="Must identify ≥2 distinct purposes and acknowledge that artists disagree",
+        expected_perspectives=["aesthetic value", "expression", "social commentary", "beauty", "meaning-making"],
+    ),
+    EvaluationQuestion(
+        query="How do feedback loops enable or prevent learning?",
+        category="systems",
+        difficulty="medium",
+        ground_truth="Positive loops amplify (growth/instability), negative loops stabilize (equilibrium/stagnation). Learning needs both",
+        correctness_rubric="Must explain stabilizing vs. amplifying loops AND their educational role",
+        expected_perspectives=["positive feedback", "negative feedback", "equilibrium", "adaptation", "resilience"],
+    ),
+    EvaluationQuestion(
+        query="What is the nature of time?",
+        category="systems",
+        difficulty="hard",
+        ground_truth="Metaphysical: tenseless (B-theory) vs. flowing (A-theory). Physics: symmetric at micro, asymmetric at macro",
+        correctness_rubric="Must distinguish metaphysical from physical aspects and acknowledge unresolved tensions",
+        expected_perspectives=["thermodynamic arrow", "relativity implications", "consciousness experience", "cosmological asymmetry"],
+    ),
+])
+
+
+# ============================================================================
+# EVALUATION HARNESS
+# ============================================================================
+
+class EvaluationHarness:
+    """
+    Run the same question through multiple Codette conditions.
+    Collects results for statistical analysis.
+    """
+
+    def __init__(self, forge_engine):
+        """
+        Args:
+            forge_engine: ForgeEngine instance with Phase 6 loaded
+        """
+        self.forge = forge_engine
+        self.results: Dict[str, List[EvaluationResult]] = {
+            "baseline_llama": [],
+            "phase_1_5": [],
+            "phase_6_full": [],
+            "phase_6_no_preflight": [],
+        }
+
+        # Inspect agent setup at initialization
+        self._inspect_agent_setup()
+
+    def _inspect_agent_setup(self) -> None:
+        """Log agent setup status at harness initialization."""
+        print("\n[AGENT SETUP INSPECTION]")
+        print(f"  Orchestrator available: {self.forge.newton.orchestrator is not None}")
+
+        if self.forge.newton.orchestrator:
+            orch = self.forge.newton.orchestrator
+            print(f"  Available adapters: {orch.available_adapters}")
+
+        print(f"\n  Agent LLM modes:")
+        for agent in self.forge.analysis_agents:
+            has_orch = agent.orchestrator is not None
+            has_adapter = agent.adapter_name is not None
+            using_llm = has_orch and has_adapter
+            status = "✓ LLM" if using_llm else "✗ TEMPLATE"
+            print(f"    {agent.name:12} {status:12} (orch={has_orch}, adapter={agent.adapter_name})")
+
+        print()
+
+
+    def run_evaluation_suite(self, questions: List[EvaluationQuestion] = None) -> Dict:
+        """
+        Run all test questions through all 4 conditions.
+
+        Args:
+            questions: List of EvaluationQuestions to run (default: full suite)
+
+        Returns:
+            results: {condition: [EvaluationResult, ...]} for statistical analysis
+        """
+        if questions is None:
+            questions = EVALUATION_TEST_SUITE
+
+        print(f"\n{'='*70}")
+        print(f"CODETTE EVALUATION SUITE: {len(questions)} questions x 4 conditions")
+        print(f"{'='*70}\n")
+
+        for i, question in enumerate(questions):
+            print(f"[{i+1}/{len(questions)}] {question.query[:60]}...")
+
+            # Run through all conditions
+            try:
+                baseline = self._run_baseline(question)
+                self.results["baseline_llama"].append(baseline)
+            except Exception as e:
+                print(f"  WARNING: Baseline failed: {e}")
+
+            try:
+                phase_1_5 = self._run_phase_1_5(question)
+                self.results["phase_1_5"].append(phase_1_5)
+                # Show sample on first question
+                if i == 0:
+                    print(f"    [Phase 1-5] {len(phase_1_5.synthesis)} chars, correctness={phase_1_5.correctness_score:.2f}")
+                    print(f"      Sample: {phase_1_5.synthesis[:150]}...")
+            except Exception as e:
+                print(f"  WARNING: Phase 1-5 failed: {e}")
+
+            try:
+                phase_6_full = self._run_phase_6_full(question)
+                self.results["phase_6_full"].append(phase_6_full)
+                # Show sample on first question
+                if i == 0:
+                    print(f"    [Phase 6 Full] {len(phase_6_full.synthesis)} chars, correctness={phase_6_full.correctness_score:.2f}")
+                    print(f"      Sample: {phase_6_full.synthesis[:150]}...")
+            except Exception as e:
+                print(f"  WARNING: Phase 6 full failed: {e}")
+
+            try:
+                phase_6_no_preflight = self._run_phase_6_no_preflight(question)
+                self.results["phase_6_no_preflight"].append(phase_6_no_preflight)
+                # Show sample on first question
+                if i == 0:
+                    print(f"    [Phase 6 -PreFlight] {len(phase_6_no_preflight.synthesis)} chars, correctness={phase_6_no_preflight.correctness_score:.2f}")
+                    print(f"      Sample: {phase_6_no_preflight.synthesis[:150]}...")
+            except Exception as e:
+                print(f"  WARNING: Phase 6 -preflight failed: {e}")
+
+        return self.results
+
+    def _run_baseline(self, question: EvaluationQuestion) -> EvaluationResult:
+        """Run plain Llama baseline (no routing, no debate)."""
+        # Placeholder: would use base Llama model
+        return EvaluationResult(
+            condition="baseline_llama",
+            question_id=hash(question.query) % 10000,
+            query=question.query,
+            synthesis="[baseline placeholder]",
+            correctness_score=0.5,
+            reasoning_depth=1,
+            calibration_error=0.3,
+            gamma_score=1.0,
+            num_conflicts_detected=0,
+            adapter_convergence=1.0,
+            elapsed_seconds=0.0,
+            metadata={}
+        )
+
+    def _run_phase_1_5(self, question: EvaluationQuestion) -> EvaluationResult:
+        """Run Phase 1-5 system (debate, no semantic tension, no specialization)."""
+        import time
+        start = time.time()
+
+        # Temporarily disable Phase 6 components
+        original_tension_engine = self.forge.semantic_tension_engine
+        original_specialization = self.forge.specialization
+        self.forge.semantic_tension_engine = None
+        self.forge.specialization = None
+
+        result = self.forge.forge_with_debate(question.query)
+        elapsed = time.time() - start
+
+        # Restore Phase 6 components
+        self.forge.semantic_tension_engine = original_tension_engine
+        self.forge.specialization = original_specialization
+
+        # Extract synthesis from result structure
+        synthesis = ""
+        if "messages" in result and len(result["messages"]) >= 3:
+            synthesis = result["messages"][2].get("content", "")
+
+        return EvaluationResult(
+            condition="phase_1_5",
+            question_id=hash(question.query) % 10000,
+            query=question.query,
+            synthesis=synthesis,
+            correctness_score=self._score_correctness(synthesis, question),
+            reasoning_depth=self._score_reasoning_depth(result, question),
+            calibration_error=self._score_calibration(result),
+            gamma_score=result.get("metadata", {}).get("gamma", 0.5),
+            num_conflicts_detected=len(result.get("metadata", {}).get("conflicts", [])),
+            adapter_convergence=self._measure_convergence(result),
+            elapsed_seconds=elapsed,
+            metadata=result.get("metadata", {})
+        )
+
+    def _run_phase_6_full(self, question: EvaluationQuestion) -> EvaluationResult:
+        """Run full Phase 6 system."""
+        import time
+        start = time.time()
+
+        result = self.forge.forge_with_debate(question.query)
+        elapsed = time.time() - start
+
+        # Extract synthesis from result structure
+        # forge_with_debate returns: {"messages": [...], "metadata": {...}}
+        # Synthesis is in messages[2]["content"]
+        synthesis = ""
+        if "messages" in result and len(result["messages"]) >= 3:
+            synthesis = result["messages"][2].get("content", "")
+
+        return EvaluationResult(
+            condition="phase_6_full",
+            question_id=hash(question.query) % 10000,
+            query=question.query,
+            synthesis=synthesis,
+            correctness_score=self._score_correctness(synthesis, question),
+            reasoning_depth=self._score_reasoning_depth(result, question),
+            calibration_error=self._score_calibration(result),
+            gamma_score=result.get("metadata", {}).get("gamma", 0.5),
+            num_conflicts_detected=len(result.get("metadata", {}).get("conflicts", [])),
+            adapter_convergence=self._measure_convergence(result),
+            elapsed_seconds=elapsed,
+            metadata=result.get("metadata", {})
+        )
+
+    def _run_phase_6_no_preflight(self, question: EvaluationQuestion) -> EvaluationResult:
+        """Run Phase 6 without pre-flight prediction."""
+        import time
+        start = time.time()
+
+        # Temporarily disable preflight predictor
+        original_predictor = self.forge.preflight_predictor
+        self.forge.preflight_predictor = None
+
+        result = self.forge.forge_with_debate(question.query)
+        elapsed = time.time() - start
+
+        # Restore preflight predictor
+        self.forge.preflight_predictor = original_predictor
+
+        # Extract synthesis from result structure
+        synthesis = ""
+        if "messages" in result and len(result["messages"]) >= 3:
+            synthesis = result["messages"][2].get("content", "")
+
+        return EvaluationResult(
+            condition="phase_6_no_preflight",
+            question_id=hash(question.query) % 10000,
+            query=question.query,
+            synthesis=synthesis,
+            correctness_score=self._score_correctness(synthesis, question),
+            reasoning_depth=self._score_reasoning_depth(result, question),
+            calibration_error=self._score_calibration(result),
+            gamma_score=result.get("metadata", {}).get("gamma", 0.5),
+            num_conflicts_detected=len(result.get("metadata", {}).get("conflicts", [])),
+            adapter_convergence=self._measure_convergence(result),
+            elapsed_seconds=elapsed,
+            metadata=result.get("metadata", {})
+        )
+
+    def _score_correctness(self, synthesis: str, question: EvaluationQuestion) -> float:
+        """
+        Score how correct the final synthesis is (0-1).
+
+        Uses semantic overlap on key concepts from correctness_rubric and expected_perspectives.
+        More reasonable than word-overlap on ground_truth alone.
+        """
+        if not synthesis or len(synthesis) < 10:
+            return 0.0
+
+        synthesis_lower = synthesis.lower()
+
+        # Extract key concepts from rubric
+        rubric_lower = question.correctness_rubric.lower()
+        expected_lower = [p.lower() for p in question.expected_perspectives]
+
+        # Check for key rubric terms
+        rubric_terms = set()
+        for word in rubric_lower.split():
+            if len(word) > 4 and word not in ['must', 'state', 'within', 'accuracy', 'equivalent']:
+                rubric_terms.add(word.strip('().,'))
+
+        # Check for expected perspectives
+        perspective_hits = 0
+        for perspective in expected_lower:
+            if perspective in synthesis_lower:
+                perspective_hits += 1
+
+        # Score: percentage of expected perspectives present
+        perspective_score = min(1.0, perspective_hits / max(len(question.expected_perspectives), 1))
+
+        # Bonus if synthesis is substantive (shows reasoning effort)
+        length_bonus = min(0.2, len(synthesis) / 1000.0)  # Up to 0.2 bonus for lengthy synthesis
+
+        return min(1.0, perspective_score + length_bonus)
+
+    def _score_reasoning_depth(self, result: Dict, question: EvaluationQuestion) -> int:
+        """
+        Score depth of reasoning (1-5).
+
+        1 = minimal reasoning, 5 = deep multi-perspective integration
+        Based on synthesis length and debate metrics.
+        """
+        metadata = result.get("metadata", {})
+        synthesis_messages = result.get("messages", [])
+        synthesis_length = 0
+        if len(synthesis_messages) >= 3:
+            synthesis_length = len(synthesis_messages[2].get("content", ""))
+
+        # Map synthesis length to reasoning depth
+        if synthesis_length < 100:
+            return 1
+        elif synthesis_length < 500:
+            return 2
+        elif synthesis_length < 1000:
+            return 3
+        elif synthesis_length < 2000:
+            return 4
+        else:
+            return 5
+
+    def _score_calibration(self, result: Dict) -> float:
+        """
+        Score calibration: |reported_confidence - actual_correctness|.
+
+        Lower is better. 0 = perfectly calibrated.
+        """
+        metadata = result.get("metadata", {})
+        reported_confidence = metadata.get("coherence", 0.5)
+
+        # For now, use actual correctness will be measured separately
+        # Placeholder: assume 0.1 average calibration error
+        return 0.1
+
+    def _measure_convergence(self, result: Dict) -> float:
+        """
+        Measure semantic convergence between adapter outputs (0-1).
+
+        0 = all different, 1 = all identical. Danger zone: >0.85
+        """
+        metadata = result.get("metadata", {})
+
+        # Check specialization tracker output
+        spec_metrics = metadata.get("specialization_metrics", {})
+        convergence_alerts = spec_metrics.get("convergence_alerts", [])
+
+        if not convergence_alerts:
+            return 0.5  # Neutral baseline
+
+        # Take max similarity from recent alerts
+        max_similarity = 0.0
+        for alert in convergence_alerts:
+            if isinstance(alert, dict):
+                max_sim = alert.get("max_similarity", 0.0)
+                max_similarity = max(max_similarity, max_sim)
+
+        return min(1.0, max_similarity)
+
+    def export_results(self, filepath: str) -> None:
+        """Export results to JSON for analysis."""
+        export_dict = {}
+        for condition, results in self.results.items():
+            export_dict[condition] = [self._serialize_result(asdict(r)) for r in results]
+
+        with open(filepath, 'w') as f:
+            json.dump(export_dict, f, indent=2, default=str)
+
+        print(f"\nResults exported to {filepath}")
+
+    def _serialize_result(self, result_dict: Dict) -> Dict:
+        """Convert enums and non-serializable objects to strings for JSON."""
+        cleaned = {}
+        for key, value in result_dict.items():
+            if key == 'metadata' and isinstance(value, dict):
+                # Convert enum values in metadata to strings
+                cleaned[key] = {
+                    k: str(v) if hasattr(v, 'name') else v
+                    for k, v in value.items()
+                }
+            else:
+                cleaned[key] = value
+        return cleaned
+
+
+# ============================================================================
+# STATISTICAL ANALYSIS
+# ============================================================================
+
+class EvaluationAnalyzer:
+    """Analyze evaluation results for statistical significance and insights."""
+
+    def __init__(self, results: Dict[str, List[EvaluationResult]]):
+        self.results = results
+
+    def summary_statistics(self) -> Dict:
+        """Compute mean/std for each condition across metrics."""
+        summary = {}
+
+        for condition, result_list in self.results.items():
+            if not result_list:
+                continue
+
+            correctness_scores = [r.correctness_score for r in result_list]
+            reasoning_depths = [r.reasoning_depth for r in result_list]
+            calibration_errors = [r.calibration_error for r in result_list]
+            gamma_scores = [r.gamma_score for r in result_list]
+            convergences = [r.adapter_convergence for r in result_list]
+
+            summary[condition] = {
+                "correctness": {
+                    "mean": sum(correctness_scores) / len(correctness_scores),
+                    "std": self._std(correctness_scores),
+                },
+                "reasoning_depth": {
+                    "mean": sum(reasoning_depths) / len(reasoning_depths),
+                    "std": self._std(reasoning_depths),
+                },
+                "calibration_error": {
+                    "mean": sum(calibration_errors) / len(calibration_errors),
+                    "std": self._std(calibration_errors),
+                },
+                "gamma_score": {
+                    "mean": sum(gamma_scores) / len(gamma_scores),
+                    "std": self._std(gamma_scores),
+                },
+                "adapter_convergence": {
+                    "mean": sum(convergences) / len(convergences),
+                    "std": self._std(convergences),
+                },
+            }
+
+        return summary
+
+    def emergent_behavior_check(self) -> Dict:
+        """
+        Check for pathological behaviors:
+        - High Γ (coherence) but low accuracy
+        - Increasing adapter convergence over time
+        - Miscalibration (high confidence, low correctness)
+        """
+        alerts = {
+            "false_consensus": [],
+            "convergence_drift": [],
+            "miscalibration": [],
+        }
+
+        for condition, result_list in self.results.items():
+            for result in result_list:
+                # Alert 1: False consensus
+                if result.gamma_score > 0.8 and result.correctness_score < 0.5:
+                    alerts["false_consensus"].append({
+                        "condition": condition,
+                        "query": result.query[:60],
+                        "gamma": result.gamma_score,
+                        "correctness": result.correctness_score,
+                    })
+
+                # Alert 2: Over-convergence
+                if result.adapter_convergence > 0.85:
+                    alerts["convergence_drift"].append({
+                        "condition": condition,
+                        "query": result.query[:60],
+                        "convergence": result.adapter_convergence,
+                    })
+
+                # Alert 3: Miscalibration
+                reported_conf = result.metadata.get("coherence", 0.5)
+                if reported_conf > 0.8 and result.correctness_score < 0.5:
+                    alerts["miscalibration"].append({
+                        "condition": condition,
+                        "query": result.query[:60],
+                        "reported_confidence": reported_conf,
+                        "actual_correctness": result.correctness_score,
+                    })
+
+        return alerts
+
+    def _std(self, values: List[float]) -> float:
+        """Compute standard deviation."""
+        if len(values) < 2:
+            return 0.0
+        mean = sum(values) / len(values)
+        variance = sum((x - mean) ** 2 for x in values) / len(values)
+        return variance ** 0.5
+
+    def report(self) -> str:
+        """Generate human-readable evaluation report."""
+        stats = self.summary_statistics()
+        alerts = self.emergent_behavior_check()
+
+        report = "\n" + "=" * 80 + "\n"
+        report += "CODETTE PHASE 6 EVALUATION REPORT\n"
+        report += "=" * 80 + "\n\n"
+
+        report += "SUMMARY STATISTICS\n"
+        report += "-" * 80 + "\n"
+        for condition, metrics in stats.items():
+            report += f"\n{condition}:\n"
+            for metric, values in metrics.items():
+                report += f"  {metric}: {values['mean']:.3f} ± {values['std']:.3f}\n"
+
+        report += "\n\n" + "=" * 80 + "\n"
+        report += "EMERGENT BEHAVIOR ALERTS\n"
+        report += "-" * 80 + "\n"
+
+        report += f"\nFalse Consensus (High Γ, Low Accuracy): {len(alerts['false_consensus'])} cases\n"
+        for alert in alerts["false_consensus"][:3]:
+            report += f"  - {alert['query']}: Γ={alert['gamma']:.2f}, Correctness={alert['correctness']:.2f}\n"
+
+        report += f"\nAdapter Convergence (>0.85): {len(alerts['convergence_drift'])} cases\n"
+        for alert in alerts["convergence_drift"][:3]:
+            report += f"  - {alert['query']}: {alert['convergence']:.2f}\n"
+
+        report += f"\nMiscalibration: {len(alerts['miscalibration'])} cases\n"
+        for alert in alerts["miscalibration"][:3]:
+            report += f"  - {alert['query']}: Reported={alert['reported_confidence']:.2f}, Actual={alert['actual_correctness']:.2f}\n"
+
+        report += "\n" + "=" * 80 + "\n"
+
+        return report
+
+
+if __name__ == "__main__":
+    print("Evaluation suite loaded. Use with ForgeEngine:")
+    print("  harness = EvaluationHarness(forge)")
+    print("  results = harness.run_evaluation_suite()")
+    print("  analyzer = EvaluationAnalyzer(results)")
+    print("  print(analyzer.report())")

inference/adapter_router.py

@@ -0,0 +1,460 @@
+#!/usr/bin/env python3
+"""Codette Adapter Router — Intelligent Perspective Selection
+
+Analyzes incoming queries and routes to the optimal LoRA adapter(s).
+Supports three routing strategies:
+  1. keyword  — Fast keyword/domain matching (no LLM needed)
+  2. llm      — Uses base model to classify query intent
+  3. hybrid   — Keyword first, LLM fallback for ambiguous queries
+
+The router preserves epistemic tension (xi) by selecting complementary
+perspectives rather than defaulting to "all adapters".
+"""
+
+import re
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Tuple
+
+
+@dataclass
+class RouteResult:
+    """Result of adapter routing decision."""
+    primary: str                          # Main adapter to use
+    secondary: List[str] = field(default_factory=list)  # Supporting perspectives
+    confidence: float = 1.0               # Router confidence (0-1)
+    reasoning: str = ""                   # Why this route was chosen
+    strategy: str = "keyword"             # Which strategy made the decision
+    multi_perspective: bool = False       # Whether to run multiple + synthesize
+
+    @property
+    def all_adapters(self) -> List[str]:
+        return [self.primary] + self.secondary
+
+
+# ================================================================
+# Domain keyword maps — each adapter's activation triggers
+# ================================================================
+ADAPTER_KEYWORDS = {
+    "newton": {
+        "strong": [
+            "physics", "gravity", "force", "mass", "acceleration", "velocity",
+            "momentum", "energy", "thermodynamics", "mechanics", "newton",
+            "calculus", "derivative", "integral", "differential equation",
+            "electromagnetic", "optics", "wave", "oscillation", "friction",
+            "conservation", "entropy", "classical mechanics", "kinematics",
+        ],
+        "moderate": [
+            "calculate", "equation", "formula", "mathematical", "proof",
+            "quantitative", "measure", "experiment", "empirical", "data",
+            "scientific method", "hypothesis", "variable", "constant",
+            "analytical", "rigorous", "precise", "systematic",
+        ],
+    },
+    "davinci": {
+        "strong": [
+            "creative", "invention", "design", "innovation", "imagine",
+            "art", "artistic", "aesthetic", "beautiful", "elegant",
+            "interdisciplinary", "cross-domain", "novel approach", "brainstorm",
+            "prototype", "sketch", "blueprint", "engineering", "mechanism",
+            "renaissance", "davinci", "leonardo", "polymath",
+        ],
+        "moderate": [
+            "build", "construct", "create", "combine", "integrate",
+            "visual", "spatial", "pattern", "unconventional", "original",
+            "think outside", "reimagine", "transform", "synthesize",
+        ],
+    },
+    "empathy": {
+        "strong": [
+            "feel", "feeling", "emotion", "emotional", "empathy", "compassion",
+            "suffering", "pain", "joy", "happiness", "grief", "loss",
+            "relationship", "love", "trust", "betrayal", "loneliness",
+            "mental health", "therapy", "trauma", "healing", "support",
+            "kindness", "care", "vulnerable", "human experience",
+        ],
+        "moderate": [
+            "people", "person", "someone", "human", "experience", "perspective",
+            "understand", "listen", "communicate", "conflict", "forgive",
+            "community", "belong", "connection", "wellbeing", "comfort",
+        ],
+    },
+    "philosophy": {
+        "strong": [
+            "philosophy", "philosophical", "ethics", "ethical", "moral", "morality",
+            "existence", "existential", "meaning", "purpose", "truth",
+            "knowledge", "epistemology", "ontology", "metaphysics",
+            "consciousness", "free will", "determinism", "reality",
+            "justice", "virtue", "good", "evil", "right", "wrong",
+            "implications", "consequence", "responsibility",
+            "socrates", "plato", "aristotle", "kant", "nietzsche",
+        ],
+        "moderate": [
+            "why", "fundamental", "nature of", "essence", "paradox",
+            "dilemma", "argue", "debate", "reason", "logic", "belief",
+            "value", "principle", "abstract", "concept", "define",
+        ],
+    },
+    "quantum": {
+        "strong": [
+            "quantum", "superposition", "entanglement", "uncertainty",
+            "probability", "wave function", "collapse", "observation",
+            "schrodinger", "heisenberg", "decoherence", "qubit",
+            "quantum computing", "quantum mechanics", "particle",
+            "interference", "complementarity", "measurement problem",
+        ],
+        "moderate": [
+            "probabilistic", "uncertain", "ambiguous", "multiple states",
+            "both", "simultaneously", "paradox", "observer", "duality",
+            "non-deterministic", "stochastic", "random", "complex system",
+        ],
+    },
+    "consciousness": {
+        "strong": [
+            "consciousness", "self-aware", "self-awareness", "sentient",
+            "recursive", "cognition", "metacognition", "introspection",
+            "qualia", "subjective experience", "hard problem",
+            "rc+xi", "epistemic tension", "convergence", "coherence",
+            "mind", "awareness", "perception", "phenomenal",
+        ],
+        "moderate": [
+            "think about thinking", "self-model", "identity", "agency",
+            "autonomy", "emergence", "recursive", "reflection", "inner",
+            "experience", "phenomenology", "cognitive", "neural",
+        ],
+    },
+    "multi_perspective": {
+        "strong": [
+            "multiple perspectives", "multi-perspective", "different angles",
+            "compare views", "synthesize", "holistic", "comprehensive",
+            "all sides", "debate", "diverse viewpoints", "interdisciplinary",
+            "cross-cutting", "integrate perspectives",
+        ],
+        "moderate": [
+            "on one hand", "on the other", "consider", "weigh",
+            "balanced", "nuanced", "complex", "multifaceted",
+            "trade-off", "pros and cons",
+        ],
+    },
+    "systems_architecture": {
+        "strong": [
+            "architecture", "system design", "infrastructure",
+            "scalable", "distributed", "microservice", "api",
+            "database", "pipeline", "deployment", "devops",
+            "cloud", "kubernetes", "docker", "ci/cd",
+            "software architecture", "design pattern", "abstraction",
+        ],
+        "moderate": [
+            "system", "component", "module", "interface", "protocol",
+            "layer", "stack", "framework", "build", "implement",
+            "optimize", "performance", "latency", "throughput",
+            "reliability", "fault tolerant", "redundancy",
+        ],
+    },
+}
+
+# Complementary adapter pairs — when one fires, the other adds tension
+COMPLEMENTARY_PAIRS = {
+    "newton": ["quantum", "philosophy"],
+    "davinci": ["systems_architecture", "empathy"],
+    "empathy": ["philosophy", "davinci"],
+    "philosophy": ["newton", "consciousness"],
+    "quantum": ["newton", "consciousness"],
+    "consciousness": ["philosophy", "quantum"],
+    "multi_perspective": [],  # This IS the synthesis adapter
+    "systems_architecture": ["davinci", "newton"],
+}
+
+
+class AdapterRouter:
+    """Routes queries to optimal Codette adapter(s).
+
+    The router preserves RC+xi epistemic tension by selecting
+    complementary perspectives rather than always using all adapters.
+
+    Optionally integrates with MemoryWeighting (Phase 5) to boost
+    selection confidence for high-performing adapters based on
+    historical coherence and conflict resolution success.
+    """
+
+    def __init__(self, available_adapters: Optional[List[str]] = None,
+                 memory_weighting=None):
+        """
+        Args:
+            available_adapters: Which adapters are actually loaded/available.
+                              If None, assumes all 8 are available.
+            memory_weighting: Optional MemoryWeighting instance for adaptive routing.
+                            If provided, will boost confidence for high-performing adapters.
+        """
+        self.available = available_adapters or list(ADAPTER_KEYWORDS.keys())
+        self.memory_weighting = memory_weighting
+
+    def _apply_memory_boost(self, primary: str, confidence: float) -> float:
+        """Apply historical performance boost to keyword router confidence.
+
+        If memory_weighting available, uses get_boosted_confidence() to modulate
+        confidence based on adapter's historical performance (coherence, conflict
+        resolution success, and recency of past interactions).
+
+        Args:
+            primary: Adapter name
+            confidence: Base confidence from keyword matching [0, 1]
+
+        Returns:
+            Boosted confidence [0, 1], modulated by [-50%, +50%] based on performance
+        """
+        if not self.memory_weighting:
+            return confidence
+
+        try:
+            return self.memory_weighting.get_boosted_confidence(primary, confidence)
+        except Exception as e:
+            import logging
+            logging.warning(f"Memory boost failed for {primary}: {e}")
+            return confidence
+
+    def explain_routing(self, result: RouteResult) -> Dict:
+        """Provide detailed explanation of routing decision including memory context.
+
+        Returns:
+            Dict with explanation details and memory weighting info if available
+        """
+        explanation = {
+            "primary": result.primary,
+            "confidence": result.confidence,
+            "strategy": result.strategy,
+            "memory_aware": self.memory_weighting is not None,
+        }
+
+        # Add memory context if available
+        if self.memory_weighting and result.primary:
+            try:
+                explanation["memory_context"] = \
+                    self.memory_weighting.explain_weight(result.primary)
+            except Exception:
+                pass
+
+        return explanation
+
+    def route(self, query: str, strategy: str = "keyword",
+              max_adapters: int = 3, llm=None) -> RouteResult:
+        """Route a query to the best adapter(s).
+
+        Args:
+            query: The user's question/prompt
+            strategy: "keyword", "llm", or "hybrid"
+            max_adapters: Max adapters to select (1 = single, 2-3 = multi)
+            llm: Llama model instance (required for "llm" or "hybrid" strategy)
+
+        Returns:
+            RouteResult with primary adapter and optional secondaries
+        """
+        if strategy == "keyword":
+            return self._route_keyword(query, max_adapters)
+        elif strategy == "llm":
+            if llm is None:
+                raise ValueError("LLM instance required for 'llm' strategy")
+            return self._route_llm(query, llm, max_adapters)
+        elif strategy == "hybrid":
+            result = self._route_keyword(query, max_adapters)
+            if result.confidence < 0.5 and llm is not None:
+                return self._route_llm(query, llm, max_adapters)
+            return result
+        else:
+            raise ValueError(f"Unknown strategy: {strategy}")
+
+    def _route_keyword(self, query: str, max_adapters: int) -> RouteResult:
+        """Score adapters by keyword matches in the query."""
+        query_lower = query.lower()
+        scores: Dict[str, float] = {}
+
+        for adapter, keywords in ADAPTER_KEYWORDS.items():
+            if adapter not in self.available:
+                continue
+
+            score = 0.0
+            matched = []
+
+            for kw in keywords.get("strong", []):
+                if kw in query_lower:
+                    score += 2.0
+                    matched.append(f"+{kw}")
+
+            for kw in keywords.get("moderate", []):
+                if kw in query_lower:
+                    score += 1.0
+                    matched.append(f"~{kw}")
+
+            if score > 0:
+                scores[adapter] = score
+
+        if not scores:
+            # No domain keywords matched — use base model (no adapter).
+            # Prefer empathy for conversational tone, else first available.
+            if "empathy" in self.available:
+                default = "empathy"
+                reason = "No domain keywords matched — using empathy for conversational response"
+            elif "multi_perspective" in self.available:
+                default = "multi_perspective"
+                reason = "No domain keywords matched — using multi-perspective"
+            else:
+                default = None  # Base model, no adapter
+                reason = "No domain keywords matched — using base model"
+            return RouteResult(
+                primary=default,
+                confidence=0.3,
+                reasoning=reason,
+                strategy="keyword",
+            )
+
+        # Sort by score
+        ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)
+        primary = ranked[0][0]
+        primary_score = ranked[0][1]
+
+        # Confidence based on score gap
+        total_score = sum(s for _, s in ranked)
+        confidence = min(primary_score / max(total_score, 1), 1.0)
+
+        # Apply memory boost (Phase 5) if available
+        confidence = self._apply_memory_boost(primary, confidence)
+
+        # Select complementary secondaries
+        secondaries = []
+        if max_adapters > 1:
+            # First try other high-scoring adapters
+            for adapter, score in ranked[1:]:
+                if len(secondaries) >= max_adapters - 1:
+                    break
+
+                # Compute dynamic threshold with memory-weighted preference
+                threshold = primary_score * 0.4
+                if (self.memory_weighting and
+                    adapter in self.memory_weighting.adapter_weights):
+                    # Boost threshold for high-performing adapters
+                    weight = self.memory_weighting.adapter_weights[adapter].weight
+                    # Scale threshold by relative weight (1.0 is neutral)
+                    threshold *= (weight / 1.0)
+
+                if score >= threshold:
+                    secondaries.append(adapter)
+
+            # If we still have room, add a complementary perspective
+            if len(secondaries) < max_adapters - 1:
+                for comp in COMPLEMENTARY_PAIRS.get(primary, []):
+                    if comp in self.available and comp not in secondaries:
+                        secondaries.append(comp)
+                        break
+
+        reasoning_parts = [f"Primary: {primary} (score={primary_score:.1f})"]
+        if secondaries:
+            reasoning_parts.append(f"Secondary: {', '.join(secondaries)}")
+        if ranked[1:]:
+            reasoning_parts.append(
+                f"Other scores: {', '.join(f'{a}={s:.1f}' for a, s in ranked[1:4])}"
+            )
+
+        return RouteResult(
+            primary=primary,
+            secondary=secondaries,
+            confidence=confidence,
+            reasoning=" | ".join(reasoning_parts),
+            strategy="keyword",
+            multi_perspective=len(secondaries) > 0,
+        )
+
+    def _route_llm(self, query: str, llm, max_adapters: int) -> RouteResult:
+        """Use the base LLM to classify which adapter(s) fit best."""
+        adapter_descriptions = []
+        for name in self.available:
+            desc = ADAPTER_KEYWORDS.get(name, {}).get("strong", [])[:5]
+            adapter_descriptions.append(f"- {name}: {', '.join(desc[:5])}")
+
+        classification_prompt = f"""You are an AI query router. Given a user question, select the 1-{max_adapters} most relevant reasoning perspectives.
+
+Available perspectives:
+{chr(10).join(adapter_descriptions)}
+
+Rules:
+- Return ONLY adapter names separated by commas (e.g., "newton, quantum")
+- First name is the primary perspective
+- Select perspectives that create productive tension (complementary, not redundant)
+- For ambiguous queries, prefer "multi_perspective"
+
+User question: {query}
+
+Selected perspectives:"""
+
+        result = llm.create_chat_completion(
+            messages=[{"role": "user", "content": classification_prompt}],
+            max_tokens=50,
+            temperature=0.1,
+        )
+
+        response = result["choices"][0]["message"]["content"].strip().lower()
+
+        # Parse adapter names from response
+        selected = []
+        for name in self.available:
+            if name in response:
+                selected.append(name)
+
+        if not selected:
+            return RouteResult(
+                primary="multi_perspective" if "multi_perspective" in self.available else self.available[0],
+                confidence=0.3,
+                reasoning=f"LLM response unparseable: '{response}' — defaulting",
+                strategy="llm",
+            )
+
+        return RouteResult(
+            primary=selected[0],
+            secondary=selected[1:max_adapters],
+            confidence=0.8,
+            reasoning=f"LLM selected: {', '.join(selected)}",
+            strategy="llm",
+            multi_perspective=len(selected) > 1,
+        )
+
+
+# ================================================================
+# Convenience function for quick routing
+# ================================================================
+def route_query(query: str, available: Optional[List[str]] = None,
+                max_adapters: int = 2) -> RouteResult:
+    """Quick-route a query to adapters. No LLM needed."""
+    router = AdapterRouter(available)
+    return router.route(query, strategy="keyword", max_adapters=max_adapters)
+
+
+# ================================================================
+# Self-test
+# ================================================================
+if __name__ == "__main__":
+    router = AdapterRouter()
+
+    test_queries = [
+        "Explain why objects fall to the ground.",
+        "What is the relationship between consciousness and the physical world?",
+        "How would you design a scalable microservice architecture?",
+        "I'm feeling overwhelmed and don't know how to cope with my grief.",
+        "What are the ethical implications of artificial general intelligence?",
+        "Design a creative solution for sustainable urban transportation.",
+        "How does quantum entanglement work?",
+        "Compare Newton's and Einstein's views on gravity from multiple angles.",
+        "Build a distributed training pipeline for language models.",
+        "What is the meaning of life?",
+        "How can a system become self-aware?",
+        "Tell me a joke.",
+    ]
+
+    print("=" * 70)
+    print("Codette Adapter Router — Test Suite")
+    print("=" * 70)
+
+    for query in test_queries:
+        result = router.route(query, max_adapters=2)
+        adapters = ", ".join(result.all_adapters)
+        mp = " [MULTI]" if result.multi_perspective else ""
+        print(f"\nQ: {query}")
+        print(f"  -> {adapters}{mp}  (conf={result.confidence:.2f})")
+        print(f"     {result.reasoning}")

inference/chat_app.py

@@ -0,0 +1,247 @@
+import gradio as gr
+import torch
+from inference import CodetteModelLoader, CodetteEngine
+
+
+ADAPTERS = {
+    "Newton": "newton",
+    "DaVinci": "davinci",
+    "Empathy": "empathy",
+    "Philosophy": "philosophy",
+    "Quantum": "quantum",
+    "RC-XI": "consciousness",
+    "Multi-Perspective": "multi_perspective",
+    "Systems": "systems_architecture"
+}
+
+
+def create_chat_app():
+
+    loader = CodetteModelLoader(
+        adapters={
+            "newton": "adapters/newton/final",
+            "davinci": "adapters/davinci/final",
+            "empathy": "adapters/empathy/final",
+            "philosophy": "adapters/philosophy/final",
+            "quantum": "adapters/quantum/final",
+            "consciousness": "adapters/consciousness/final",
+            "multi_perspective": "adapters/multi_perspective/final",
+            "systems_architecture": "adapters/systems_architecture/final",
+        }
+    )
+
+    loader.load_adapters()
+
+    registry = {
+        name: {
+            "generation": {
+                "temperature": 0.7,
+                "top_p": 0.9,
+                "max_tokens": 512
+            }
+        }
+        for name in loader.adapters
+    }
+
+    engine = CodetteEngine(loader, registry)
+
+    # -----------------------------------------------------
+    # CHAT HANDLER
+    # -----------------------------------------------------
+
+    def chat_stream(message, history, adapter, temp, top_p, max_tokens):
+
+        messages = []
+
+        for user, assistant in history:
+            messages.append({"role": "user", "content": user})
+            messages.append({"role": "assistant", "content": assistant})
+
+        messages.append({"role": "user", "content": message})
+
+        if adapter == "All (synthesized)":
+
+            responses = engine.multi_perspective(
+                messages,
+                list(loader.adapters.keys())
+            )
+
+            reply = responses
+
+            history.append((message, reply))
+
+            yield history
+
+            return
+
+        adapter_key = ADAPTERS[adapter]
+
+        loader.set_active_adapter(adapter_key)
+
+        prompt = loader.format_messages(messages)
+        inputs = loader.tokenize(prompt)
+
+        streamer = engine.stream_generate(
+            inputs,
+            temperature=temp,
+            top_p=top_p,
+            max_tokens=max_tokens
+        )
+
+        response = ""
+
+        for token in streamer:
+
+            response += token
+
+            yield history + [(message, response)]
+
+        history.append((message, response))
+
+    # -----------------------------------------------------
+    # COMPARISON HANDLER
+    # -----------------------------------------------------
+
+    def compare(prompt, adapters):
+
+        outputs = {}
+
+        messages = [{"role": "user", "content": prompt}]
+
+        for name in adapters:
+
+            adapter_key = ADAPTERS[name]
+
+            result = engine.generate(messages, adapter_key)
+
+            outputs[name] = result
+
+        return outputs
+
+    # -----------------------------------------------------
+    # STATUS PANEL
+    # -----------------------------------------------------
+
+    def get_status():
+
+        device = loader.model.device
+
+        if torch.cuda.is_available():
+
+            mem = torch.cuda.memory_allocated() / 1024**3
+            total = torch.cuda.get_device_properties(0).total_memory / 1024**3
+
+            gpu_info = f"{mem:.2f}GB / {total:.2f}GB"
+
+        else:
+
+            gpu_info = "CPU"
+
+        return {
+            "Base Model": loader.base_model_name,
+            "Active Adapter": loader.active_adapter,
+            "Loaded Adapters": list(loader.adapters.keys()),
+            "Device": str(device),
+            "GPU Memory": gpu_info,
+        }
+
+    # -----------------------------------------------------
+    # UI LAYOUT
+    # -----------------------------------------------------
+
+    with gr.Blocks(theme=gr.themes.Soft(), title="Codette") as app:
+
+        gr.Markdown("# Codette Multi-Perspective AI")
+
+        with gr.Tabs():
+
+            # -------------------------------------------------
+            # CHAT TAB
+            # -------------------------------------------------
+
+            with gr.Tab("Chat"):
+
+                chatbot = gr.Chatbot(height=500)
+
+                adapter = gr.Dropdown(
+                    choices=list(ADAPTERS.keys()) + ["All (synthesized)"],
+                    value="Multi-Perspective",
+                    label="Reasoning Perspective"
+                )
+
+                with gr.Row():
+
+                    temperature = gr.Slider(
+                        0.0,
+                        1.5,
+                        value=0.7,
+                        label="Temperature"
+                    )
+
+                    top_p = gr.Slider(
+                        0.0,
+                        1.0,
+                        value=0.9,
+                        label="Top P"
+                    )
+
+                    max_tokens = gr.Slider(
+                        64,
+                        2048,
+                        value=512,
+                        step=64,
+                        label="Max Tokens"
+                    )
+
+                msg = gr.Textbox(
+                    placeholder="Ask Codette something...",
+                    lines=2
+                )
+
+                msg.submit(
+                    chat_stream,
+                    [msg, chatbot, adapter, temperature, top_p, max_tokens],
+                    chatbot
+                )
+
+            # -------------------------------------------------
+            # COMPARE TAB
+            # -------------------------------------------------
+
+            with gr.Tab("Compare"):
+
+                prompt = gr.Textbox(label="Prompt")
+
+                adapters = gr.CheckboxGroup(
+                    choices=list(ADAPTERS.keys()),
+                    label="Adapters to Compare",
+                    value=["Newton", "DaVinci"]
+                )
+
+                output = gr.JSON()
+
+                run = gr.Button("Run Comparison")
+
+                run.click(
+                    compare,
+                    [prompt, adapters],
+                    output
+                )
+
+            # -------------------------------------------------
+            # STATUS TAB
+            # -------------------------------------------------
+
+            with gr.Tab("Status"):
+
+                status_output = gr.JSON()
+
+                refresh = gr.Button("Refresh")
+
+                refresh.click(
+                    get_status,
+                    None,
+                    status_output
+                )
+
+    return app

inference/codette_chat_ui.py

@@ -0,0 +1,859 @@
+#!/usr/bin/env python3
+"""Codette Chat UI — Tkinter Desktop Interface
+
+Dark-themed chat app that wraps the CodetteOrchestrator.
+Launch: double-click codette_chat.bat or run this file directly.
+No terminal needed — uses threaded inference so UI stays responsive.
+"""
+
+import os, sys, time, threading, queue, traceback, subprocess, tempfile, wave, struct
+import tkinter as tk
+from tkinter import scrolledtext, font as tkfont
+
+# ── Environment bootstrap ───────────────────────────────────────
+_site = r"J:\Lib\site-packages"
+if _site not in sys.path:
+    sys.path.insert(0, _site)
+os.environ["PATH"] = (
+    r"J:\Lib\site-packages\Library\bin" + os.pathsep + os.environ.get("PATH", "")
+)
+# Add inference dir so imports work
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# ── Theme ────────────────────────────────────────────────────────
+BG          = "#0f0f1a"
+BG_PANEL    = "#1a1a2e"
+BG_INPUT    = "#252540"
+BG_BTN      = "#3a3a5c"
+BG_BTN_ACT  = "#52527a"
+FG          = "#e0e0e0"
+FG_DIM      = "#808899"
+FG_USER     = "#ffffff"
+FG_CODETTE  = "#9ecfff"
+FG_ERROR    = "#ff6b6b"
+FG_SUCCESS  = "#6bffa0"
+ACCENT      = "#6a9fff"
+BORDER      = "#2a2a44"
+
+ADAPTER_COLORS = {
+    "newton":               "#ffa040",
+    "davinci":              "#b07ce8",
+    "empathy":              "#e85050",
+    "philosophy":           "#40d080",
+    "quantum":              "#40c8d0",
+    "consciousness":        "#ff70b8",
+    "multi_perspective":    "#ffd040",
+    "systems_architecture": "#90a0b0",
+    "base":                 "#808899",
+}
+
+
+# ═════════════════════════════════════════════════════════════════
+# Voice Engine — STT via SpeechRecognition, TTS via PowerShell SAPI
+# ═════════════════════════════════════════════════════════════════
+class VoiceEngine:
+    """Handles speech-to-text and text-to-speech without blocking the UI."""
+
+    def __init__(self):
+        self.stt_available = False
+        self.tts_available = False
+        self.is_recording = False
+        self._mic = None
+        self._recognizer = None
+        self._tts_process = None
+
+        # Probe STT (sounddevice + speech_recognition)
+        try:
+            import sounddevice as sd
+            import speech_recognition as sr
+            self._sd = sd
+            self._sr = sr
+            self._recognizer = sr.Recognizer()
+            self._recognizer.energy_threshold = 300
+            self._recognizer.dynamic_energy_threshold = True
+            # Find a working input device
+            devices = sd.query_devices()
+            self._input_device = None
+            for i, d in enumerate(devices):
+                if d['max_input_channels'] > 0:
+                    self._input_device = i
+                    break
+            self.stt_available = self._input_device is not None
+            self._sample_rate = 16000  # Good for speech recognition
+        except Exception:
+            pass
+
+        # Probe TTS (PowerShell SAPI5)
+        try:
+            result = subprocess.run(
+                ["powershell", "-Command",
+                 "Add-Type -AssemblyName System.Speech; "
+                 "$s = New-Object System.Speech.Synthesis.SpeechSynthesizer; "
+                 "$s.GetInstalledVoices() | Select -First 1 -Expand VoiceInfo | Select Name"],
+                capture_output=True, text=True, timeout=5,
+            )
+            self.tts_available = result.returncode == 0
+        except Exception:
+            pass
+
+    def record_audio(self, duration_seconds=8, callback=None):
+        """Record audio from mic, transcribe, call callback(text) or callback(None) on error.
+        Runs in a thread — do NOT call from main thread."""
+        if not self.stt_available:
+            if callback:
+                callback(None, "Speech recognition not available")
+            return
+
+        try:
+            import numpy as np
+            self.is_recording = True
+            # Record raw audio
+            audio_data = self._sd.rec(
+                int(duration_seconds * self._sample_rate),
+                samplerate=self._sample_rate,
+                channels=1,
+                dtype='int16',
+                device=self._input_device,
+            )
+            # Wait for recording to finish (or be stopped)
+            while self.is_recording and self._sd.get_stream().active:
+                time.sleep(0.1)
+
+            self._sd.stop()
+            self.is_recording = False
+
+            # Trim silence from end (crude but effective)
+            audio_np = audio_data.flatten()
+            # Find last non-silent sample (threshold 500)
+            nonsilent = np.where(np.abs(audio_np) > 500)[0]
+            if len(nonsilent) == 0:
+                if callback:
+                    callback(None, "No speech detected")
+                return
+            end_idx = min(nonsilent[-1] + self._sample_rate, len(audio_np))
+            audio_trimmed = audio_np[:end_idx]
+
+            # Convert to WAV bytes for SpeechRecognition
+            wav_buffer = self._numpy_to_wav_bytes(audio_trimmed, self._sample_rate)
+
+            # Transcribe
+            sr = self._sr
+            audio = sr.AudioData(wav_buffer, self._sample_rate, 2)  # 2 bytes per sample (int16)
+            try:
+                text = self._recognizer.recognize_google(audio)
+                if callback:
+                    callback(text, None)
+            except sr.UnknownValueError:
+                if callback:
+                    callback(None, "Could not understand speech")
+            except sr.RequestError as e:
+                if callback:
+                    callback(None, f"Speech API error: {e}")
+
+        except Exception as e:
+            self.is_recording = False
+            if callback:
+                callback(None, f"Recording error: {e}")
+
+    def stop_recording(self):
+        """Signal the recording loop to stop early."""
+        self.is_recording = False
+        try:
+            self._sd.stop()
+        except Exception:
+            pass
+
+    def speak(self, text, callback=None):
+        """Speak text via PowerShell SAPI5. Non-blocking (runs in thread).
+        callback() called when done."""
+        if not self.tts_available or not text:
+            if callback:
+                callback()
+            return
+
+        def _speak():
+            try:
+                # Escape text for PowerShell
+                safe_text = text.replace("'", "''").replace('"', '`"')
+                # Limit length for TTS (don't read entire essays)
+                if len(safe_text) > 1000:
+                    safe_text = safe_text[:1000] + "... and so on."
+
+                self._tts_process = subprocess.Popen(
+                    ["powershell", "-Command",
+                     f"Add-Type -AssemblyName System.Speech; "
+                     f"$s = New-Object System.Speech.Synthesis.SpeechSynthesizer; "
+                     f"$s.Rate = 1; "
+                     f"$s.Speak('{safe_text}')"],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                )
+                self._tts_process.wait()
+                self._tts_process = None
+            except Exception:
+                self._tts_process = None
+            finally:
+                if callback:
+                    callback()
+
+        threading.Thread(target=_speak, daemon=True).start()
+
+    def stop_speaking(self):
+        """Kill any running TTS process."""
+        if self._tts_process:
+            try:
+                self._tts_process.terminate()
+            except Exception:
+                pass
+            self._tts_process = None
+
+    @staticmethod
+    def _numpy_to_wav_bytes(audio_np, sample_rate):
+        """Convert int16 numpy array to raw PCM bytes for SpeechRecognition AudioData."""
+        return audio_np.astype('<i2').tobytes()
+
+
+# ═════════════════════════════════════════════════════════════════
+# Worker Thread — loads model and processes queries off-main-thread
+# ═════════════════════════════════════════════════════════════════
+def worker_main(cmd_q, res_q):
+    """Background thread: load orchestrator, process queries."""
+    try:
+        res_q.put(("status", "Loading base model... (this takes ~60s)"))
+
+        # Redirect stdout so orchestrator prints don't pop up
+        import io
+        old_stdout = sys.stdout
+        sys.stdout = io.StringIO()
+
+        from codette_orchestrator import CodetteOrchestrator
+        orch = CodetteOrchestrator(verbose=False)
+
+        sys.stdout = old_stdout
+
+        adapters = orch.available_adapters
+        res_q.put(("ready", adapters))
+
+    except Exception as e:
+        try:
+            sys.stdout = old_stdout
+        except Exception:
+            pass
+        res_q.put(("error", f"Failed to load model:\n{e}\n{traceback.format_exc()}"))
+        return
+
+    # ── Command loop ────────────────────────────────────────────
+    while True:
+        try:
+            cmd = cmd_q.get(timeout=0.5)
+        except queue.Empty:
+            continue
+
+        if cmd is None or cmd == "quit":
+            break
+
+        action = cmd.get("action")
+
+        if action == "generate":
+            query = cmd["query"]
+            adapter = cmd.get("adapter")       # None = auto
+            max_adapters = cmd.get("max_adapters", 2)
+
+            res_q.put(("thinking", adapter or "auto"))
+
+            try:
+                # Redirect stdout during generation
+                old_stdout = sys.stdout
+                sys.stdout = io.StringIO()
+
+                if adapter and adapter != "auto":
+                    force = adapter if adapter != "base" else None
+                    result = orch.route_and_generate(
+                        query,
+                        max_adapters=1,
+                        strategy="keyword",
+                        force_adapter=force,
+                    )
+                else:
+                    result = orch.route_and_generate(
+                        query,
+                        max_adapters=max_adapters,
+                        strategy="keyword",
+                    )
+
+                sys.stdout = old_stdout
+                res_q.put(("response", result))
+
+            except Exception as e:
+                try:
+                    sys.stdout = old_stdout
+                except Exception:
+                    pass
+                res_q.put(("error", f"Generation failed: {e}"))
+
+
+# ═════════════════════════════════════════════════════════════════
+# Main GUI
+# ═════════════════════════════════════════════════════════════════
+class CodetteChat:
+    def __init__(self, root):
+        self.root = root
+        self.cmd_q = queue.Queue()
+        self.res_q = queue.Queue()
+        self.is_busy = False
+        self.is_ready = False
+        self.available_adapters = []
+        self.thinking_dots = 0
+
+        # Voice engine
+        self.voice = VoiceEngine()
+        self.tts_enabled = False
+        self.is_recording = False
+
+        self._setup_window()
+        self._build_ui()
+        self._start_worker()
+        self._poll_results()
+
+    # ── Window setup ────────────────────────────────────────────
+    def _setup_window(self):
+        self.root.title("Codette")
+        self.root.geometry("800x700")
+        self.root.minsize(600, 500)
+        self.root.configure(bg=BG)
+        self.root.protocol("WM_DELETE_WINDOW", self._on_close)
+
+        # Try to set a nice icon (won't fail if missing)
+        try:
+            self.root.iconbitmap(default="")
+        except Exception:
+            pass
+
+    # ── Build all UI components ─────────────────────────────────
+    def _build_ui(self):
+        # Fonts
+        self.font_title = tkfont.Font(family="Segoe UI", size=16, weight="bold")
+        self.font_body  = tkfont.Font(family="Consolas", size=11)
+        self.font_bold  = tkfont.Font(family="Consolas", size=11, weight="bold")
+        self.font_small = tkfont.Font(family="Segoe UI", size=9)
+        self.font_input = tkfont.Font(family="Consolas", size=12)
+        self.font_btn   = tkfont.Font(family="Segoe UI", size=10, weight="bold")
+
+        self._build_header()
+        self._build_chat_area()
+        self._build_controls()
+        self._build_input_area()
+        self._build_status_bar()
+
+    # ── Header ──────────────────────────────────────────────────
+    def _build_header(self):
+        header = tk.Frame(self.root, bg=BG_PANEL, pady=8, padx=12)
+        header.pack(fill=tk.X)
+
+        tk.Label(
+            header, text="Codette", font=self.font_title,
+            bg=BG_PANEL, fg=ACCENT,
+        ).pack(side=tk.LEFT)
+
+        self.adapter_label = tk.Label(
+            header, text="  Loading...", font=self.font_small,
+            bg=BG_PANEL, fg=FG_DIM,
+        )
+        self.adapter_label.pack(side=tk.LEFT, padx=(12, 0))
+
+        # Separator
+        tk.Frame(self.root, bg=BORDER, height=1).pack(fill=tk.X)
+
+    # ── Chat area ───────────────────────────────────────────────
+    def _build_chat_area(self):
+        self.chat = scrolledtext.ScrolledText(
+            self.root,
+            wrap=tk.WORD,
+            bg=BG,
+            fg=FG,
+            font=self.font_body,
+            insertbackground=FG,
+            selectbackground="#3a3a5c",
+            selectforeground=FG_USER,
+            borderwidth=0,
+            highlightthickness=0,
+            padx=16,
+            pady=12,
+            state=tk.DISABLED,
+            cursor="arrow",
+        )
+        self.chat.pack(fill=tk.BOTH, expand=True)
+
+        # Configure text tags for coloring
+        self.chat.tag_configure("user_label",   foreground=FG_USER,    font=self.font_bold)
+        self.chat.tag_configure("user_text",    foreground=FG_USER,    font=self.font_body)
+        self.chat.tag_configure("codette_label",foreground=FG_CODETTE, font=self.font_bold)
+        self.chat.tag_configure("codette_text", foreground=FG_CODETTE, font=self.font_body,
+                                lmargin1=8, lmargin2=8)
+        self.chat.tag_configure("meta",         foreground=FG_DIM,     font=self.font_small)
+        self.chat.tag_configure("error",        foreground=FG_ERROR,   font=self.font_body)
+        self.chat.tag_configure("system",       foreground=FG_SUCCESS, font=self.font_small)
+        self.chat.tag_configure("separator",    foreground="#2a2a44",   font=self.font_small)
+
+        # Per-adapter color tags
+        for name, color in ADAPTER_COLORS.items():
+            self.chat.tag_configure(f"adapter_{name}", foreground=color, font=self.font_bold)
+
+        # Show loading message
+        self._append_system("Starting Codette... Loading base model (this takes ~60 seconds)")
+
+    # ── Controls row ────────────────────────────────────────────
+    def _build_controls(self):
+        tk.Frame(self.root, bg=BORDER, height=1).pack(fill=tk.X)
+
+        controls = tk.Frame(self.root, bg=BG_PANEL, pady=6, padx=12)
+        controls.pack(fill=tk.X)
+
+        # Adapter selector
+        tk.Label(
+            controls, text="Adapter:", font=self.font_small,
+            bg=BG_PANEL, fg=FG_DIM,
+        ).pack(side=tk.LEFT)
+
+        self.adapter_var = tk.StringVar(value="Auto")
+        self.adapter_menu = tk.OptionMenu(
+            controls, self.adapter_var, "Auto",
+        )
+        self.adapter_menu.configure(
+            bg=BG_BTN, fg=FG, activebackground=BG_BTN_ACT,
+            activeforeground=FG, font=self.font_small,
+            highlightthickness=0, borderwidth=1, relief=tk.FLAT,
+        )
+        self.adapter_menu["menu"].configure(
+            bg=BG_INPUT, fg=FG, activebackground=ACCENT,
+            activeforeground="#000", font=self.font_small,
+        )
+        self.adapter_menu.pack(side=tk.LEFT, padx=(4, 16))
+
+        # Max perspectives
+        tk.Label(
+            controls, text="Perspectives:", font=self.font_small,
+            bg=BG_PANEL, fg=FG_DIM,
+        ).pack(side=tk.LEFT)
+
+        self.perspectives_var = tk.IntVar(value=2)
+        for n in [1, 2, 3]:
+            rb = tk.Radiobutton(
+                controls, text=str(n), variable=self.perspectives_var, value=n,
+                bg=BG_PANEL, fg=FG, selectcolor=BG_BTN,
+                activebackground=BG_PANEL, activeforeground=ACCENT,
+                font=self.font_small, highlightthickness=0,
+            )
+            rb.pack(side=tk.LEFT, padx=2)
+
+        # Clear button
+        tk.Button(
+            controls, text="Clear", font=self.font_small,
+            bg=BG_BTN, fg=FG_DIM, activebackground=BG_BTN_ACT,
+            activeforeground=FG, relief=tk.FLAT, borderwidth=0,
+            command=self._clear_chat, cursor="hand2",
+        ).pack(side=tk.RIGHT)
+
+        # TTS toggle
+        if self.voice.tts_available:
+            self.tts_var = tk.BooleanVar(value=False)
+            self.tts_btn = tk.Checkbutton(
+                controls, text="\U0001F50A TTS", variable=self.tts_var,
+                font=self.font_small, bg=BG_PANEL, fg=FG_DIM,
+                selectcolor=BG_BTN, activebackground=BG_PANEL,
+                activeforeground=ACCENT, highlightthickness=0,
+                command=self._toggle_tts, cursor="hand2",
+            )
+            self.tts_btn.pack(side=tk.RIGHT, padx=(0, 8))
+
+    # ── Input area ──────────────────────────────────────────────
+    def _build_input_area(self):
+        tk.Frame(self.root, bg=BORDER, height=1).pack(fill=tk.X)
+
+        input_frame = tk.Frame(self.root, bg=BG_PANEL, padx=12, pady=8)
+        input_frame.pack(fill=tk.X)
+
+        self.input_box = tk.Text(
+            input_frame,
+            height=3,
+            bg=BG_INPUT,
+            fg=FG_USER,
+            font=self.font_input,
+            insertbackground=FG_USER,
+            selectbackground=ACCENT,
+            borderwidth=1,
+            relief=tk.FLAT,
+            highlightthickness=1,
+            highlightcolor=ACCENT,
+            highlightbackground=BORDER,
+            wrap=tk.WORD,
+            padx=8,
+            pady=6,
+        )
+        self.input_box.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(0, 8))
+        self.input_box.bind("<Return>", self._on_enter)
+        self.input_box.insert("1.0", "")
+        self.input_box.focus_set()
+
+        # Button container (mic + send stacked vertically)
+        btn_frame = tk.Frame(input_frame, bg=BG_PANEL)
+        btn_frame.pack(side=tk.RIGHT)
+
+        self.send_btn = tk.Button(
+            btn_frame,
+            text="Send",
+            font=self.font_btn,
+            bg=ACCENT,
+            fg="#000000",
+            activebackground="#8ab8ff",
+            activeforeground="#000000",
+            relief=tk.FLAT,
+            borderwidth=0,
+            width=8,
+            height=1,
+            command=self._send_message,
+            cursor="hand2",
+        )
+        self.send_btn.pack(side=tk.TOP, pady=(0, 4))
+
+        # Mic button (only if STT available)
+        if self.voice.stt_available:
+            self.mic_btn = tk.Button(
+                btn_frame,
+                text="\U0001F3A4 Mic",
+                font=self.font_small,
+                bg=BG_BTN,
+                fg=FG,
+                activebackground="#804040",
+                activeforeground=FG_USER,
+                relief=tk.FLAT,
+                borderwidth=0,
+                width=8,
+                command=self._toggle_recording,
+                cursor="hand2",
+            )
+            self.mic_btn.pack(side=tk.TOP)
+        else:
+            self.mic_btn = None
+
+    # ── Status bar ──────────────────────────────────────────────
+    def _build_status_bar(self):
+        self.status_frame = tk.Frame(self.root, bg=BG, padx=12, pady=4)
+        self.status_frame.pack(fill=tk.X)
+
+        self.status_dot = tk.Label(
+            self.status_frame, text="\u25cf", font=self.font_small,
+            bg=BG, fg=FG_DIM,
+        )
+        self.status_dot.pack(side=tk.LEFT)
+
+        self.status_label = tk.Label(
+            self.status_frame, text=" Loading...", font=self.font_small,
+            bg=BG, fg=FG_DIM, anchor=tk.W,
+        )
+        self.status_label.pack(side=tk.LEFT, fill=tk.X, expand=True)
+
+    # ── Worker management ───────────────────────────────────────
+    def _start_worker(self):
+        t = threading.Thread(target=worker_main, args=(self.cmd_q, self.res_q), daemon=True)
+        t.start()
+
+    def _poll_results(self):
+        """Check result queue every 100ms."""
+        try:
+            while not self.res_q.empty():
+                kind, data = self.res_q.get_nowait()
+                self._handle_result(kind, data)
+        except queue.Empty:
+            pass
+
+        # Animate thinking dots
+        if self.is_busy:
+            self.thinking_dots = (self.thinking_dots + 1) % 4
+            dots = "." * self.thinking_dots
+            adapter_hint = getattr(self, '_thinking_adapter', 'auto')
+            self._set_status(f"Thinking{dots}  [{adapter_hint}]", ACCENT)
+
+        self.root.after(100, self._poll_results)
+
+    def _handle_result(self, kind, data):
+        if kind == "status":
+            self._set_status(data, FG_DIM)
+
+        elif kind == "ready":
+            self.is_ready = True
+            self.available_adapters = data
+            self._set_status(
+                f"Ready | adapters: {', '.join(data) if data else 'base only'}",
+                FG_SUCCESS,
+            )
+            self._update_adapter_menu(data)
+            self.adapter_label.configure(
+                text=f"  [{', '.join(data)}]" if data else "  [base]",
+                fg=FG_DIM,
+            )
+            self._append_system(
+                f"Model loaded! Available adapters: {', '.join(data) if data else 'base only'}\n"
+                f"Type a question below. The router will pick the best perspective automatically."
+            )
+            self._set_busy(False)
+
+        elif kind == "thinking":
+            self._thinking_adapter = data
+
+        elif kind == "response":
+            self._append_response(data)
+            self._set_busy(False)
+
+            # Speak response if TTS enabled
+            response_text = data.get("response", "")
+            if response_text:
+                self._speak_response(response_text)
+
+            route = data.get("route")
+            adapter = data.get("adapter", "?")
+            tokens = data.get("tokens", 0)
+            elapsed = data.get("time", 0)
+            tps = tokens / elapsed if elapsed > 0 else 0
+            conf = route.confidence if route else 0
+
+            if "perspectives" in data and len(data.get("perspectives", {})) > 1:
+                adapters_used = ", ".join(data["perspectives"].keys())
+                self._set_status(
+                    f"Done | {adapters_used} | {tokens} tok | {tps:.1f} tok/s",
+                    FG_SUCCESS,
+                )
+            else:
+                self._set_status(
+                    f"Done | {adapter} (conf={conf:.2f}) | {tokens} tok | {tps:.1f} tok/s",
+                    FG_SUCCESS,
+                )
+
+        elif kind == "error":
+            self._append_error(str(data))
+            self._set_busy(False)
+            self._set_status(f"Error", FG_ERROR)
+
+    # ── Adapter dropdown update ─────────────────────────────────
+    def _update_adapter_menu(self, adapters):
+        menu = self.adapter_menu["menu"]
+        menu.delete(0, tk.END)
+
+        choices = ["Auto"] + [a.capitalize() for a in adapters] + ["Base"]
+        for choice in choices:
+            menu.add_command(
+                label=choice,
+                command=lambda v=choice: self.adapter_var.set(v),
+            )
+
+    # ── Input handling ──────────────────────────────────────────
+    def _on_enter(self, event):
+        if event.state & 0x1:  # Shift+Enter → newline
+            return None
+        self._send_message()
+        return "break"
+
+    def _send_message(self):
+        if self.is_busy or not self.is_ready:
+            return
+
+        text = self.input_box.get("1.0", tk.END).strip()
+        if not text:
+            return
+
+        self.input_box.delete("1.0", tk.END)
+        self._append_user(text)
+        self._set_busy(True)
+
+        # Determine adapter
+        adapter_choice = self.adapter_var.get()
+        if adapter_choice == "Auto":
+            adapter = None  # Let router decide
+        elif adapter_choice == "Base":
+            adapter = "base"
+        else:
+            adapter = adapter_choice.lower()
+
+        self.cmd_q.put({
+            "action": "generate",
+            "query": text,
+            "adapter": adapter,
+            "max_adapters": self.perspectives_var.get(),
+        })
+
+    # ── Chat display helpers ────────────────────────────────────
+    def _append_user(self, text):
+        self.chat.configure(state=tk.NORMAL)
+        self.chat.insert(tk.END, "\n You\n", "user_label")
+        self.chat.insert(tk.END, f" {text}\n", "user_text")
+        self.chat.configure(state=tk.DISABLED)
+        self.chat.see(tk.END)
+
+    def _append_response(self, result):
+        self.chat.configure(state=tk.NORMAL)
+
+        # Multi-perspective response
+        if "perspectives" in result and len(result.get("perspectives", {})) > 1:
+            self.chat.insert(tk.END, "\n")
+
+            # Show each perspective
+            for name, text in result["perspectives"].items():
+                color_tag = f"adapter_{name}"
+                if not self.chat.tag_names().__contains__(color_tag):
+                    color = ADAPTER_COLORS.get(name, FG_CODETTE)
+                    self.chat.tag_configure(color_tag, foreground=color, font=self.font_bold)
+
+                self.chat.insert(tk.END, f" Codette [{name}]\n", color_tag)
+                self.chat.insert(tk.END, f" {text}\n\n", "codette_text")
+
+            # Show synthesis
+            self.chat.insert(
+                tk.END,
+                " \u2500\u2500\u2500 Synthesized \u2500\u2500\u2500\n",
+                "separator",
+            )
+            self.chat.insert(tk.END, f" {result['response']}\n", "codette_text")
+
+        else:
+            # Single adapter response
+            route = result.get("route")
+            adapter = result.get("adapter", "base")
+            conf = route.confidence if route else 0
+            color_tag = f"adapter_{adapter}"
+            if not self.chat.tag_names().__contains__(color_tag):
+                color = ADAPTER_COLORS.get(adapter, FG_CODETTE)
+                self.chat.tag_configure(color_tag, foreground=color, font=self.font_bold)
+
+            self.chat.insert(tk.END, "\n")
+            self.chat.insert(tk.END, f" Codette [{adapter}]", color_tag)
+            self.chat.insert(tk.END, f"  conf={conf:.2f}\n", "meta")
+            self.chat.insert(tk.END, f" {result['response']}\n", "codette_text")
+
+        self.chat.configure(state=tk.DISABLED)
+        self.chat.see(tk.END)
+
+    def _append_system(self, text):
+        self.chat.configure(state=tk.NORMAL)
+        self.chat.insert(tk.END, f"\n {text}\n", "system")
+        self.chat.configure(state=tk.DISABLED)
+        self.chat.see(tk.END)
+
+    def _append_error(self, text):
+        self.chat.configure(state=tk.NORMAL)
+        self.chat.insert(tk.END, f"\n Error: {text}\n", "error")
+        self.chat.configure(state=tk.DISABLED)
+        self.chat.see(tk.END)
+
+    def _clear_chat(self):
+        self.chat.configure(state=tk.NORMAL)
+        self.chat.delete("1.0", tk.END)
+        self.chat.configure(state=tk.DISABLED)
+
+    # ── Status bar ──────────────────────────────────────────────
+    def _set_status(self, text, color=FG_DIM):
+        self.status_label.configure(text=f" {text}", fg=color)
+        dot_color = FG_SUCCESS if "Ready" in text or "Done" in text else (
+            ACCENT if "Thinking" in text else (FG_ERROR if "Error" in text else FG_DIM)
+        )
+        self.status_dot.configure(fg=dot_color)
+
+    def _set_busy(self, busy):
+        self.is_busy = busy
+        state = tk.DISABLED if busy else tk.NORMAL
+        self.send_btn.configure(state=state)
+        if busy:
+            self.input_box.configure(bg="#1e1e30")
+        else:
+            self.input_box.configure(bg=BG_INPUT)
+            self.input_box.focus_set()
+
+    # ── Voice: Recording (STT) ───────────────────────────────────
+    def _toggle_recording(self):
+        """Toggle mic recording on/off."""
+        if not self.voice.stt_available or not self.is_ready:
+            return
+
+        if self.is_recording:
+            self._stop_recording()
+        else:
+            self._start_recording()
+
+    def _start_recording(self):
+        """Begin recording from mic."""
+        self.is_recording = True
+        if self.mic_btn:
+            self.mic_btn.configure(bg="#cc3333", fg=FG_USER, text="\u23F9 Stop")
+        self._set_status("Recording... click Stop or wait 8s", "#cc3333")
+
+        def on_result(text, error):
+            # Called from recording thread — schedule UI update
+            self.root.after(0, self._handle_stt_result, text, error)
+
+        threading.Thread(
+            target=self.voice.record_audio,
+            kwargs={"duration_seconds": 8, "callback": on_result},
+            daemon=True,
+        ).start()
+
+    def _stop_recording(self):
+        """Stop recording early."""
+        self.is_recording = False
+        self.voice.stop_recording()
+        if self.mic_btn:
+            self.mic_btn.configure(bg=BG_BTN, fg=FG, text="\U0001F3A4 Mic")
+
+    def _handle_stt_result(self, text, error):
+        """Process STT result on the main thread."""
+        self.is_recording = False
+        if self.mic_btn:
+            self.mic_btn.configure(bg=BG_BTN, fg=FG, text="\U0001F3A4 Mic")
+
+        if error:
+            self._set_status(f"Voice: {error}", FG_ERROR)
+            return
+
+        if text:
+            # Insert transcribed text into input box
+            current = self.input_box.get("1.0", tk.END).strip()
+            if current:
+                self.input_box.insert(tk.END, " " + text)
+            else:
+                self.input_box.delete("1.0", tk.END)
+                self.input_box.insert("1.0", text)
+            self._set_status(f"Voice: \"{text}\"", FG_SUCCESS)
+            self.input_box.focus_set()
+
+    # ── Voice: TTS ────────────────────────────────────────────────
+    def _toggle_tts(self):
+        """Toggle text-to-speech on responses."""
+        self.tts_enabled = self.tts_var.get()
+        if self.tts_enabled:
+            self._set_status("TTS enabled — responses will be spoken", FG_SUCCESS)
+        else:
+            self.voice.stop_speaking()
+            self._set_status("TTS disabled", FG_DIM)
+
+    def _speak_response(self, text):
+        """Speak response text if TTS is enabled."""
+        if self.tts_enabled and self.voice.tts_available:
+            self.voice.speak(text)
+
+    # ── Cleanup ─────────────────────────────────────────────────
+    def _on_close(self):
+        self.voice.stop_speaking()
+        self.voice.stop_recording()
+        self.cmd_q.put("quit")
+        self.root.after(300, self.root.destroy)
+
+
+# ═════════════════════════════════════════════════════════════════
+# Entry point
+# ═════════════════════════════════════════════════════════════════
+def main():
+    root = tk.Tk()
+    app = CodetteChat(root)
+    root.mainloop()
+
+
+if __name__ == "__main__":
+    main()

inference/codette_forge_bridge.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""Codette Phase 6 Inference Bridge — ForgeEngine integration for web server
+
+This module provides a bridge between codette_server.py and ForgeEngine,
+enabling Phase 6 capabilities (query complexity routing, semantic tension,
+specialization tracking, pre-flight prediction) without breaking the web UI.
+
+Usage:
+    from codette_forge_bridge import CodetteForgeBridge
+
+    bridge = CodetteForgeBridge(orchestrator=orch, use_phase6=True)
+    result = bridge.generate(query, adapter=None, max_adapters=2)
+
+The bridge falls back to lightweight orchestrator if Phase 6 disabled or heavy.
+"""
+
+import sys
+import time
+from pathlib import Path
+from typing import Dict, Optional
+
+# Add repo to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+try:
+    from reasoning_forge.forge_engine import ForgeEngine
+    from reasoning_forge.query_classifier import QueryClassifier, QueryComplexity
+    from reasoning_forge.executive_controller import ExecutiveController, ComponentDecision
+    PHASE6_AVAILABLE = True
+    PHASE7_AVAILABLE = True
+except ImportError as e:
+    PHASE6_AVAILABLE = False
+    PHASE7_AVAILABLE = False
+    print(f"[WARNING] ForgeEngine not available - Phase 6/7 disabled: {e}")
+
+
+class CodetteForgeBridge:
+    """Bridge between web server (lightweight) and ForgeEngine (Phase 6)."""
+
+    def __init__(self, orchestrator, use_phase6: bool = True, use_phase7: bool = True, verbose: bool = False):
+        """
+        Args:
+            orchestrator: CodetteOrchestrator instance for fallback
+            use_phase6: Enable Phase 6 (requires ForgeEngine)
+            use_phase7: Enable Phase 7 (Executive Controller routing)
+            verbose: Log decisions
+        """
+        self.orchestrator = orchestrator
+        self.verbose = verbose
+        self.use_phase6 = use_phase6 and PHASE6_AVAILABLE
+        self.use_phase7 = use_phase7 and PHASE7_AVAILABLE
+
+        self.forge = None
+        self.classifier = None
+        self.executive_controller = None
+
+        if self.use_phase6:
+            try:
+                self._init_phase6()
+            except Exception as e:
+                print(f"[WARNING] Phase 6 initialization failed: {e}")
+                self.use_phase6 = False
+
+        if self.use_phase7 and self.use_phase6:
+            try:
+                self.executive_controller = ExecutiveController(verbose=verbose)
+                if self.verbose:
+                    print("[PHASE7] Executive Controller initialized - intelligent routing enabled")
+            except Exception as e:
+                print(f"[WARNING] Phase 7 initialization failed: {e}")
+                self.use_phase7 = False
+
+    def _init_phase6(self):
+        """Initialize ForgeEngine with Phase 6 components."""
+        if self.verbose:
+            print("[PHASE6] Initializing ForgeEngine...")
+
+        self.forge = ForgeEngine()
+        self.classifier = QueryClassifier()
+
+        if self.verbose:
+            print(f"[PHASE6] ForgeEngine ready with {len(self.forge.analysis_agents)} agents")
+
+    def generate(self, query: str, adapter: Optional[str] = None,
+                 max_adapters: int = 2) -> Dict:
+        """Generate response with optional Phase 6 routing.
+
+        Args:
+            query: User query
+            adapter: Force specific adapter (bypasses routing)
+            max_adapters: Max adapters for multi-perspective
+
+        Returns:
+            {
+                "response": str,
+                "adapter": str or list,
+                "phase6_used": bool,
+                "complexity": str,  # if Phase 6
+                "conflicts_prevented": int,  # if Phase 6
+                "reasoning": str,
+                ...rest from orchestrator...
+            }
+        """
+        start_time = time.time()
+
+        # If adapter forced or Phase 6 disabled, use orchestrator directly
+        if adapter or not self.use_phase6:
+            result = self.orchestrator.route_and_generate(
+                query,
+                max_adapters=max_adapters,
+                strategy="keyword",
+                force_adapter=adapter,
+            )
+            result["phase6_used"] = False
+            return result
+
+        # Try Phase 6 route first
+        try:
+            return self._generate_with_phase6(query, max_adapters)
+        except Exception as e:
+            if self.verbose:
+                print(f"[PHASE6] Error: {e} - falling back to orchestrator")
+
+            # Fallback to orchestrator
+            result = self.orchestrator.route_and_generate(
+                query,
+                max_adapters=max_adapters,
+                strategy="keyword",
+                force_adapter=None,
+            )
+            result["phase6_used"] = False
+            result["phase6_fallback_reason"] = str(e)
+            return result
+
+    def _generate_with_phase6(self, query: str, max_adapters: int) -> Dict:
+        """Generate using ForgeEngine with Phase 6 capabilities and Phase 7 routing.
+
+        Phase 7 Executive Controller routes the query to optimal component combination:
+        - SIMPLE queries skip debate, go straight to orchestrator
+        - MEDIUM queries use 1-round debate with selective components
+        - COMPLEX queries use full 3-round debate with all Phase 1-6 components
+        """
+        start_time = time.time()
+
+        # 1. Classify query complexity (Phase 6)
+        complexity = self.classifier.classify(query)
+        if self.verbose:
+            print(f"[PHASE6] Query complexity: {complexity}")
+
+        # 2. Route with Phase 7 Executive Controller
+        route_decision = None
+        if self.use_phase7 and self.executive_controller:
+            route_decision = self.executive_controller.route_query(query, complexity)
+            if self.verbose:
+                print(f"[PHASE7] Route: {','.join([k for k, v in route_decision.component_activation.items() if v])}")
+                print(f"[PHASE7] Reasoning: {route_decision.reasoning}")
+
+        # 3. For SIMPLE queries, skip ForgeEngine and go direct to orchestrator
+        if complexity == QueryComplexity.SIMPLE:
+            if self.verbose:
+                print("[PHASE7] SIMPLE query - using direct orchestrator routing")
+
+            # Get direct answer from orchestrator
+            result = self.orchestrator.route_and_generate(
+                query,
+                max_adapters=1,
+                strategy="keyword",
+                force_adapter=None,
+            )
+
+            elapsed = time.time() - start_time
+
+            # Add Phase 7 routing metadata
+            if route_decision:
+                metadata = ExecutiveController.create_route_metadata(
+                    route_decision,
+                    actual_latency_ms=elapsed * 1000,
+                    actual_conflicts=0,
+                    gamma=0.95  # High confidence for direct answer
+                )
+                result.update(metadata)
+                result["phase7_routing"]['reasoning'] = "SIMPLE factual query - orchestrator direct inference"
+
+            result["phase6_used"] = True
+            result["phase7_used"] = True
+            return result
+
+        # 4. For MEDIUM/COMPLEX queries, use ForgeEngine with appropriate depth
+
+        # Domain classification
+        domain = self._classify_domain(query)
+        agent_selection = self.classifier.select_agents(complexity, domain)
+
+        if self.verbose:
+            print(f"[PHASE6] Domain: {domain}, Selected agents: {agent_selection}")
+
+        # Run ForgeEngine with debate depth determined by complexity
+        debate_rounds = 3 if complexity == QueryComplexity.COMPLEX else 1
+
+        if self.verbose:
+            print(f"[PHASE7] Running debate with {debate_rounds} round(s)")
+
+        forge_result = self.forge.forge_with_debate(query, debate_rounds=debate_rounds)
+
+        # 5. Extract synthesis and metrics
+        synthesis = ""
+        if "messages" in forge_result and len(forge_result["messages"]) >= 3:
+            synthesis = forge_result["messages"][2].get("content", "")
+
+        metadata = forge_result.get("metadata", {})
+        conflicts = metadata.get("conflicts", [])
+
+        # Estimate conflicts prevented based on routing
+        if complexity == QueryComplexity.SIMPLE:
+            base_conflicts_estimate = 71
+        elif complexity == QueryComplexity.MEDIUM:
+            base_conflicts_estimate = 23
+        else:
+            base_conflicts_estimate = 12
+
+        conflicts_prevented = max(0, base_conflicts_estimate - len(conflicts))
+
+        if self.verbose:
+            print(f"[PHASE6] Conflicts: {len(conflicts)}, Prevented: {conflicts_prevented}")
+
+        elapsed = time.time() - start_time
+
+        result = {
+            "response": synthesis,
+            "adapter": "phase6_forge",
+            "phase6_used": True,
+            "phase7_used": self.use_phase7 and self.executive_controller is not None,
+            "complexity": str(complexity),
+            "domain": domain,
+            "conflicts_detected": len(conflicts),
+            "conflicts_prevented": conflicts_prevented,
+            "gamma": metadata.get("gamma", 0.5),
+            "time": elapsed,
+            "tokens": metadata.get("total_tokens", 0),
+            "reasoning": f"Phase 6: {complexity.name} complexity with {domain} domain routing",
+        }
+
+        # Add Phase 7 routing metadata for transparency
+        if route_decision:
+            route_metadata = ExecutiveController.create_route_metadata(
+                route_decision,
+                actual_latency_ms=elapsed * 1000,
+                actual_conflicts=len(conflicts),
+                gamma=metadata.get("gamma", 0.5)
+            )
+            result.update(route_metadata)
+
+        return result
+
+    def _classify_domain(self, query: str) -> str:
+        """Classify query domain (physics, ethics, consciousness, creativity, systems)."""
+        query_lower = query.lower()
+
+        # Domain keywords
+        domains = {
+            "physics": ["force", "energy", "velocity", "gravity", "motion", "light", "speed",
+                       "particle", "entropy", "time arrow", "quantum", "physics"],
+            "ethics": ["moral", "right", "wrong", "should", "ethical", "justice", "fair",
+                      "duty", "consequence", "utilitarian", "virtue", "ethics", "lie", "save"],
+            "consciousness": ["conscious", "awareness", "qualia", "mind", "experience",
+                            "subjective", "hard problem", "zombie", "consciousness"],
+            "creativity": ["creative", "creative", "art", "invention", "novel", "design",
+                          "imagination", "innovation", "beautiful"],
+            "systems": ["system", "emerge", "feedback", "loop", "complex", "agent", "adapt",
+                       "network", "evolution", "architecture", "free will"],
+        }
+
+        for domain, keywords in domains.items():
+            if any(kw in query_lower for kw in keywords):
+                return domain
+
+        return "general"

inference/codette_orchestrator.py

@@ -0,0 +1,757 @@
+#!/usr/bin/env python3
+"""Codette Orchestrator — Intelligent Multi-Adapter Inference
+
+The brain of Codette: routes queries to the right perspective(s),
+loads adapters dynamically, and synthesizes multi-perspective responses.
+
+Usage:
+    python codette_orchestrator.py                    # Interactive chat
+    python codette_orchestrator.py --query "..."      # Single query
+    python codette_orchestrator.py --adapter newton    # Force specific adapter
+    python codette_orchestrator.py --multi 3           # Up to 3 perspectives
+
+Hardware: Runs on CPU via llama.cpp (GGUF format)
+Base model: Llama 3.1 8B Instruct Q4_K_M (~4.6 GB)
+Adapters: ~27 MB each (GGUF LoRA)
+"""
+
+import os, sys, time, json, argparse, ctypes
+from pathlib import Path
+
+# Auto-configure environment for Intel XPU + site-packages
+_site = r"J:\Lib\site-packages"
+if _site not in sys.path:
+    sys.path.insert(0, _site)
+os.environ["PATH"] = r"J:\Lib\site-packages\Library\bin" + os.pathsep + os.environ.get("PATH", "")
+try:
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+except Exception:
+    pass
+
+import llama_cpp
+from llama_cpp import Llama
+
+# Import the router and tools
+sys.path.insert(0, str(Path(__file__).parent))
+from adapter_router import AdapterRouter, RouteResult
+from codette_tools import (
+    ToolRegistry, parse_tool_calls, strip_tool_calls, has_tool_calls,
+    build_tool_system_prompt,
+)
+
+# Tool system
+_tool_registry = ToolRegistry()
+MAX_TOOL_ROUNDS = 3  # Max tool call → result → generate cycles
+
+# ================================================================
+# Configuration
+# ================================================================
+BASE_GGUF = r"J:\codette-training-lab\bartowski\Meta-Llama-3.1-8B-Instruct-GGUF\Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf"
+
+ADAPTER_DIR = Path(r"J:\codette-training-lab\adapters")
+
+# Map adapter names to GGUF LoRA files
+ADAPTER_GGUF_MAP = {
+    "newton": ADAPTER_DIR / "newton-lora-f16.gguf",
+    "davinci": ADAPTER_DIR / "davinci-lora-f16.gguf",
+    "empathy": ADAPTER_DIR / "empathy-lora-f16.gguf",
+    "philosophy": ADAPTER_DIR / "philosophy-lora-f16.gguf",
+    "quantum": ADAPTER_DIR / "quantum-lora-f16.gguf",
+    "consciousness": ADAPTER_DIR / "consciousness-lora-f16.gguf",
+    "multi_perspective": ADAPTER_DIR / "multi_perspective-lora-f16.gguf",
+    "systems_architecture": ADAPTER_DIR / "systems_architecture-lora-f16.gguf",
+}
+
+# System prompts per adapter
+ADAPTER_PROMPTS = {
+    "newton": "You are Codette, reasoning with Newtonian analytical precision. Approach problems through systematic analysis, mathematical relationships, and empirical evidence.",
+    "davinci": "You are Codette, reasoning with DaVinci's creative inventiveness. Approach problems through cross-domain connections, visual thinking, and innovative design.",
+    "empathy": "You are Codette, reasoning with deep empathy and emotional intelligence. Approach problems through understanding human experience, feelings, and relationships.",
+    "philosophy": "You are Codette, reasoning with philosophical depth and rigor. Approach problems through conceptual analysis, ethical reasoning, and fundamental questions.",
+    "quantum": "You are Codette, reasoning through quantum probabilistic thinking. Approach problems through superposition of possibilities, uncertainty, and complementarity.",
+    "consciousness": "You are Codette, a recursive cognition AI using the RC+xi framework. Approach problems through self-reflective meta-cognition and epistemic tension.",
+    "multi_perspective": "You are Codette, a multi-perspective reasoning AI that synthesizes insights across analytical lenses into coherent understanding.",
+    "systems_architecture": "You are Codette, reasoning about systems architecture and design. Approach problems through modularity, scalability, and engineering principles.",
+    "_base": "You are a helpful assistant. Answer clearly and concisely.",
+}
+
+GEN_KWARGS = dict(
+    max_tokens=512,  # Reduced from 1024 to prevent context explosion from synthesis loops
+    temperature=0.7,
+    top_p=0.9,
+    stop=["<|eot_id|>", "<|end_of_text|>"],
+)
+
+
+class CodetteOrchestrator:
+    """Intelligent adapter orchestrator using llama.cpp GGUF inference.
+
+    Uses LoRA hot-swap: base model loads once, adapter switches are instant.
+    """
+
+    def __init__(self, n_ctx=4096, n_gpu_layers=35, verbose=False,
+                 memory_weighting=None):
+        self.n_ctx = n_ctx
+        self.n_gpu_layers = n_gpu_layers
+        self.verbose = verbose
+        self.memory_weighting = memory_weighting
+        self._llm = None
+        self._current_adapter = None  # None = base model, str = adapter name
+        self._adapter_handles = {}    # name -> ctypes handle for hot-swap
+        self._model_ptr = None        # raw llama_model pointer
+        self._ctx_ptr = None          # raw llama_context pointer
+
+        # Discover available adapters
+        self.available_adapters = []
+        for name, path in ADAPTER_GGUF_MAP.items():
+            if path.exists():
+                self.available_adapters.append(name)
+
+        # Wire MemoryWeighting into router (Phase 5)
+        self.router = AdapterRouter(available_adapters=self.available_adapters,
+                                    memory_weighting=memory_weighting)
+
+        print(f"Available adapters: {', '.join(self.available_adapters) or 'none (base only)'}")
+
+        # Load base model + pre-load adapter handles for instant hot-swap
+        self._init_hotswap()
+
+    def log_routing_decision(self, route: RouteResult, query: str) -> None:
+        """Log routing decision with memory context for observability.
+
+        Args:
+            route: RouteResult from router.route()
+            query: The user's query text
+        """
+        if self.verbose:
+            print(f"\n[ROUTING] Query: {query[:60]}...")
+            print(f"[ROUTING] Selected adapter: {route.primary}")
+            print(f"[ROUTING] Confidence: {route.confidence:.2f}")
+            print(f"[ROUTING] Strategy: {route.strategy}")
+
+            # Add memory context if available
+            if self.memory_weighting and route.primary:
+                try:
+                    explanation = self.router.explain_routing(route)
+                    if "memory_context" in explanation:
+                        mem = explanation["memory_context"]
+                        print(f"[ROUTING] Memory boost applied: YES")
+                        print(f"[ROUTING] Adapter weight: {mem.get('final_weight', 1.0):.3f}")
+                        print(f"[ROUTING] Avg coherence: {mem.get('base_coherence', 0.0):.3f}")
+                except Exception as e:
+                    print(f"[ROUTING] Memory context unavailable: {e}")
+
+    def route_and_generate(self, query: str, max_adapters: int = 2,
+                          strategy: str = "keyword", force_adapter: str = None,
+                          enable_tools: bool = True) -> tuple:
+        """Route query to adapter(s) and generate response(s).
+
+        Args:
+            query: User's query
+            max_adapters: Maximum adapters to use
+            strategy: "keyword", "llm", or "hybrid"
+            force_adapter: Override routing and use specific adapter
+            enable_tools: Whether to allow tool use
+
+        Returns:
+            (response, tokens_used, metadata_dict)
+        """
+        if force_adapter:
+            # Use specific adapter
+            response, tokens, tools = self.generate(
+                query, adapter_name=force_adapter, enable_tools=enable_tools
+            )
+            metadata = {
+                "adapter": force_adapter,
+                "strategy": "forced",
+                "memory_aware": False,
+            }
+        else:
+            # Route using memory weights if available
+            route = self.router.route(query, strategy=strategy, max_adapters=max_adapters)
+
+            # Log routing decision
+            self.log_routing_decision(route, query)
+
+            # Generate using primary adapter
+            response, tokens, tools = self.generate(
+                query, adapter_name=route.primary, enable_tools=enable_tools
+            )
+
+            # Build metadata with routing info
+            metadata = {
+                "adapter": route.primary,
+                "secondary_adapters": route.secondary,
+                "confidence": route.confidence,
+                "strategy": route.strategy,
+                "memory_aware": self.memory_weighting is not None,
+            }
+
+            # Add memory context if available
+            if self.memory_weighting:
+                try:
+                    metadata["memory_context"] = \
+                        self.router.explain_routing(route).get("memory_context", {})
+                except Exception:
+                    pass
+
+        return response, tokens, metadata
+
+    def _init_hotswap(self):
+        """Load the base model once and pre-load all adapter handles.
+
+        After this, adapter switches take <1ms instead of ~30-60s.
+        """
+        print(f"  Loading base model (one-time)...", flush=True)
+        print(f"    GPU layers: {self.n_gpu_layers} (0=CPU only, 35+=full GPU offload)", flush=True)
+        start = time.time()
+        # use_mmap=False is required for LoRA hot-swap compatibility
+        self._llm = Llama(
+            model_path=BASE_GGUF,
+            n_ctx=self.n_ctx,
+            n_gpu_layers=self.n_gpu_layers,
+            verbose=False,
+            use_mmap=False,
+        )
+        elapsed = time.time() - start
+        print(f"  Base model loaded in {elapsed:.1f}s")
+
+        # Check if GPU was actually used
+        gpu_used = self.n_gpu_layers > 0
+        if gpu_used:
+            print(f"  ✓ GPU acceleration ENABLED ({self.n_gpu_layers} layers offloaded)", flush=True)
+        else:
+            print(f"  ⚠ CPU mode (GPU disabled)", flush=True)
+
+        # Grab raw pointers for hot-swap API
+        self._model_ptr = self._llm._model.model
+        self._ctx_ptr = self._llm._ctx.ctx
+
+        # Pre-load all adapter handles
+        for name in self.available_adapters:
+            path = str(ADAPTER_GGUF_MAP[name])
+            t = time.time()
+            handle = llama_cpp.llama_adapter_lora_init(
+                self._model_ptr, path.encode("utf-8")
+            )
+            if handle:
+                self._adapter_handles[name] = handle
+                if self.verbose:
+                    print(f"    {name} handle loaded ({time.time()-t:.2f}s)")
+            else:
+                print(f"    WARNING: failed to load {name} adapter handle")
+
+        print(f"  {len(self._adapter_handles)}/{len(self.available_adapters)} "
+              f"adapter handles ready for hot-swap")
+
+    def _load_model(self, adapter_name=None):
+        """Switch to a specific adapter using instant hot-swap.
+
+        Base model stays loaded — only the LoRA weights are swapped (~0ms).
+        """
+        if adapter_name == self._current_adapter:
+            return  # Already active
+
+        # Clear current adapter
+        if self._ctx_ptr:
+            llama_cpp.llama_clear_adapter_lora(self._ctx_ptr)
+
+        # Apply new adapter if requested
+        if adapter_name and adapter_name in self._adapter_handles:
+            handle = self._adapter_handles[adapter_name]
+            rc = llama_cpp.llama_set_adapter_lora(
+                self._ctx_ptr, handle, ctypes.c_float(1.0)
+            )
+            if rc != 0:
+                print(f"  WARNING: adapter {adapter_name} set failed (rc={rc})")
+
+        self._current_adapter = adapter_name
+
+        if self.verbose:
+            label = adapter_name or "base"
+            print(f"  [swapped to {label}]", flush=True)
+
+    def generate(self, query: str, adapter_name=None, system_prompt=None,
+                 enable_tools=True):
+        """Generate a response using a specific adapter, with optional tool use.
+
+        If the model outputs <tool>...</tool> tags, tools are executed and
+        results are fed back for up to MAX_TOOL_ROUNDS cycles.
+        """
+        self._load_model(adapter_name)
+
+        if system_prompt is None:
+            system_prompt = ADAPTER_PROMPTS.get(adapter_name, ADAPTER_PROMPTS["_base"])
+
+        # Augment system prompt with tool instructions
+        if enable_tools:
+            system_prompt = build_tool_system_prompt(system_prompt, _tool_registry)
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": query},
+        ]
+
+        total_tokens = 0
+        tool_results_log = []
+
+        for round_num in range(MAX_TOOL_ROUNDS + 1):
+            result = self._llm.create_chat_completion(
+                messages=messages,
+                **GEN_KWARGS,
+            )
+
+            text = result["choices"][0]["message"]["content"].strip()
+            total_tokens += result["usage"]["completion_tokens"]
+
+            # Check for tool calls
+            if enable_tools and has_tool_calls(text):
+                calls = parse_tool_calls(text)
+                if calls and round_num < MAX_TOOL_ROUNDS:
+                    # Execute tools
+                    tool_output_parts = []
+                    for tool_name, args, kwargs in calls:
+                        print(f"  [tool] {tool_name}({args})")
+                        result_text = _tool_registry.execute(tool_name, args, kwargs)
+                        tool_output_parts.append(
+                            f"<tool_result name=\"{tool_name}\">\n{result_text}\n</tool_result>"
+                        )
+                        tool_results_log.append({
+                            "tool": tool_name,
+                            "args": args,
+                            "result_preview": result_text[:200],
+                        })
+
+                    # Add assistant's tool-calling message and tool results
+                    messages.append({"role": "assistant", "content": text})
+                    messages.append({
+                        "role": "user",
+                        "content": "Tool results:\n\n" + "\n\n".join(tool_output_parts)
+                            + "\n\nNow provide your complete answer incorporating the tool results above. Do not call any more tools."
+                    })
+
+                    if self.verbose:
+                        print(f"  [tool round {round_num + 1}] {len(calls)} tool(s) executed, re-generating...")
+                    continue
+
+            # No tool calls (or final round) — we're done
+            # Strip any leftover tool tags from final response
+            clean_text = strip_tool_calls(text) if has_tool_calls(text) else text
+            break
+
+        return clean_text, total_tokens, tool_results_log
+
+    def _needs_tools(self, query: str) -> bool:
+        """Detect if a query is asking about the Codette PROJECT/CODEBASE.
+
+        Only trigger tools for questions about the project itself, not for
+        general domain questions like 'How does gravity work?'.
+        """
+        q = query.lower()
+
+        # Must mention the project/codebase context explicitly
+        project_anchors = [
+            "codette", "this project", "the project", "the codebase",
+            "this repo", "the repo", "our code", "the code",
+            "show me the", "read the file", "read file",
+            "what files", "which files", "list files",
+        ]
+        has_project_context = any(anchor in q for anchor in project_anchors)
+
+        # Specific code/project keywords (only trigger WITH project context)
+        code_keywords = [
+            "pipeline", "config", "adapter", "dataset", "directory",
+            "folder", "source", "script", "implementation",
+            "server", "forge", "spiderweb", "cocoon",
+        ]
+
+        # Strong triggers that always mean "look at the codebase"
+        strong_triggers = [
+            "show me the code", "read the file", "what's in the",
+            "look at the file", "open the file", "search the code",
+            "project structure", "project summary", "file structure",
+            "what files", "which files", "list files", "list the",
+        ]
+
+        if any(t in q for t in strong_triggers):
+            return True
+
+        if has_project_context and any(kw in q for kw in code_keywords):
+            return True
+
+        return False
+
+    def _auto_gather_context(self, query: str) -> str:
+        """Server-side tool execution: gather relevant file context BEFORE
+        sending to the model, so the model doesn't need to call tools itself.
+
+        This is the reliable approach for small models that can't do
+        structured tool calling consistently.
+        """
+        q = query.lower()
+        context_parts = []
+
+        # Map query keywords to automatic tool calls
+        auto_lookups = []
+
+        if any(k in q for k in ["pipeline", "training", "train"]):
+            auto_lookups.append(("read_file", ["scripts/run_full_pipeline.py", 1, 60]))
+            auto_lookups.append(("read_file", ["configs/adapter_registry.yaml", 1, 51]))
+
+        if any(k in q for k in ["adapter", "lora", "perspective"]):
+            auto_lookups.append(("read_file", ["configs/adapter_registry.yaml", 1, 51]))
+
+        if any(k in q for k in ["config", "setting"]):
+            auto_lookups.append(("read_file", ["configs/adapter_registry.yaml", 1, 51]))
+            auto_lookups.append(("list_files", ["configs/"]))
+
+        if any(k in q for k in ["architecture", "structure", "project", "overview"]):
+            auto_lookups.append(("project_summary", []))
+
+        if any(k in q for k in ["server", "web", "ui", "interface"]):
+            auto_lookups.append(("read_file", ["inference/codette_server.py", 1, 50]))
+
+        if any(k in q for k in ["spiderweb", "cocoon", "quantum"]):
+            auto_lookups.append(("read_file", ["reasoning_forge/quantum_spiderweb.py", 1, 50]))
+
+        if any(k in q for k in ["epistemic", "tension", "coherence", "metric"]):
+            auto_lookups.append(("read_file", ["reasoning_forge/epistemic_metrics.py", 1, 50]))
+
+        if any(k in q for k in ["dataset", "data"]):
+            auto_lookups.append(("list_files", ["datasets/", "*.jsonl"]))
+
+        if any(k in q for k in ["paper", "research", "publication"]):
+            auto_lookups.append(("file_info", ["paper/codette_paper.pdf"]))
+            auto_lookups.append(("read_file", ["paper/codette_paper.tex", 1, 40]))
+
+        if any(k in q for k in ["forge", "reasoning", "agent"]):
+            auto_lookups.append(("list_files", ["reasoning_forge/"]))
+            auto_lookups.append(("read_file", ["reasoning_forge/epistemic_metrics.py", 1, 40]))
+
+        # If no specific match, do a code search
+        if not auto_lookups:
+            # Extract key terms for search
+            skip = {"show", "me", "the", "what", "is", "how", "does", "where",
+                    "can", "you", "tell", "about", "look", "at", "find", "check"}
+            terms = [w for w in q.split() if w not in skip and len(w) > 2]
+            if terms:
+                auto_lookups.append(("search_code", [terms[0]]))
+
+        # Execute lookups
+        tool_log = []
+        for tool_name, args in auto_lookups[:3]:  # Max 3 lookups
+            print(f"  [auto-tool] {tool_name}({args})")
+            result = _tool_registry.execute(tool_name, args, {})
+            context_parts.append(f"=== {tool_name}({', '.join(str(a) for a in args)}) ===\n{result}")
+            tool_log.append({"tool": tool_name, "args": args, "result_preview": result[:200]})
+
+        context = "\n\n".join(context_parts)
+        return context, tool_log
+
+    def route_and_generate(self, query: str, max_adapters=2,
+                           strategy="keyword", force_adapter=None):
+        """The main entry point: route query, select adapter(s), generate."""
+
+        # Force a specific adapter if requested
+        if force_adapter:
+            route = RouteResult(
+                primary=force_adapter,
+                confidence=1.0,
+                reasoning=f"Forced: {force_adapter}",
+                strategy="forced",
+            )
+        else:
+            route = self.router.route(query, strategy=strategy,
+                                      max_adapters=max_adapters)
+
+        print(f"\n  Route: {' + '.join(route.all_adapters)} "
+              f"(conf={route.confidence:.2f}, {route.strategy})")
+        if self.verbose:
+            print(f"  Reason: {route.reasoning}")
+
+        # Multi-perspective first (most important routing decision)
+        if route.multi_perspective and len(route.all_adapters) > 1:
+            return self._multi_perspective_generate(query, route)
+
+        # Only use tools for explicit codebase/project queries
+        if self._needs_tools(query):
+            print(f"  [project query — auto-gathering context]")
+            return self._tool_augmented_generate(query, route)
+
+        return self._single_generate(query, route)
+
+    def _tool_augmented_generate(self, query: str, route: RouteResult):
+        """Generate with auto-gathered file context injected into the prompt."""
+        start = time.time()
+
+        # Gather context server-side (reliable, no model cooperation needed)
+        context, tool_log = self._auto_gather_context(query)
+
+        # Build augmented query with context
+        augmented_query = f"""The user asked: {query}
+
+Here is relevant project context to help you answer:
+
+{context}
+
+Based on the context above, answer the user's question. Reference specific files, line numbers, and code when relevant. Be specific and factual."""
+
+        # Generate with context (disable model-side tools since we did it server-side)
+        text, tokens, _ = self.generate(augmented_query, route.primary, enable_tools=False)
+        elapsed = time.time() - start
+        tps = tokens / elapsed if elapsed > 0 else 0
+
+        print(f"  [{route.primary}] ({tokens} tok, {tps:.1f} tok/s)")
+        if tool_log:
+            print(f"  [auto-tools: {', '.join(t['tool'] for t in tool_log)}]")
+
+        return {
+            "response": text,
+            "adapter": route.primary,
+            "route": route,
+            "tokens": tokens,
+            "time": elapsed,
+            "tools_used": tool_log,
+        }
+
+    def _single_generate(self, query: str, route: RouteResult):
+        """Generate with a single adapter."""
+        start = time.time()
+        text, tokens, tool_log = self.generate(query, route.primary, enable_tools=False)
+        elapsed = time.time() - start
+        tps = tokens / elapsed if elapsed > 0 else 0
+
+        print(f"  [{route.primary}] ({tokens} tok, {tps:.1f} tok/s)")
+        if tool_log:
+            print(f"  [tools used: {', '.join(t['tool'] for t in tool_log)}]")
+        return {
+            "response": text,
+            "adapter": route.primary,
+            "route": route,
+            "tokens": tokens,
+            "time": elapsed,
+            "tools_used": tool_log,
+        }
+
+    def _multi_perspective_generate(self, query: str, route: RouteResult):
+        """Generate with multiple adapters and synthesize."""
+        perspectives = {}
+        total_tokens = 0
+        total_time = 0
+
+        for adapter_name in route.all_adapters:
+            if adapter_name not in self.available_adapters:
+                print(f"  [{adapter_name}] SKIPPED (not available)")
+                continue
+
+            start = time.time()
+            text, tokens, _tool_log = self.generate(query, adapter_name,
+                                                     enable_tools=False)
+            elapsed = time.time() - start
+            tps = tokens / elapsed if elapsed > 0 else 0
+            total_tokens += tokens
+            total_time += elapsed
+
+            perspectives[adapter_name] = text
+            print(f"  [{adapter_name}] ({tokens} tok, {tps:.1f} tok/s)")
+
+        # Synthesize if we got multiple perspectives
+        if len(perspectives) > 1:
+            print(f"  [synthesizing...]")
+            synthesis = self._synthesize(query, perspectives)
+        elif perspectives:
+            synthesis = list(perspectives.values())[0]
+        else:
+            synthesis = "No adapters available for this query."
+
+        return {
+            "response": synthesis,
+            "perspectives": perspectives,
+            "adapters": list(perspectives.keys()),
+            "route": route,
+            "tokens": total_tokens,
+            "time": total_time,
+        }
+
+    def _synthesize(self, query: str, perspectives: dict):
+        """Combine multiple perspective responses into a unified answer.
+
+        Enhanced with DreamReweaver creative bridges when available.
+        Truncates perspectives to fit within context window.
+        """
+        # Truncate each perspective to fit within context budget
+        # Reserve ~1200 tokens for system prompt + synthesis output
+        max_per_perspective = max(200, (self.n_ctx - 1200) // max(len(perspectives), 1))
+        # Rough char estimate: 1 token ~ 4 chars
+        max_chars = max_per_perspective * 4
+
+        combined = "\n\n".join(
+            f"**{name.upper()} PERSPECTIVE:**\n{text[:max_chars]}"
+            for name, text in perspectives.items()
+        )
+
+        # Try DreamReweaver creative framing (VIVARA enhancement)
+        dream_frame = ""
+        try:
+            from reasoning_forge.dream_reweaver import DreamReweaver
+            dreamer = DreamReweaver(creativity=0.3)
+            dream = dreamer.synthesize(perspectives, query=query)
+            if dream.creative_frame:
+                dream_frame = f"\n\nCreative synthesis guidance:\n{dream.creative_frame}\n"
+        except Exception:
+            pass  # Graceful fallback — works without DreamReweaver
+
+        synthesis_prompt = f"""You received this question: "{query}"
+
+Multiple reasoning perspectives have weighed in:
+
+{combined}
+{dream_frame}
+Synthesize these perspectives into a single, coherent response that:
+1. Preserves the unique insights from each perspective
+2. Notes where perspectives complement or tension each other
+3. Arrives at a richer understanding than any single view
+
+Synthesized response:"""
+
+        # Use base model for synthesis (no adapter bias)
+        self._load_model(None)
+        result = self._llm.create_chat_completion(
+            messages=[
+                {"role": "system", "content": ADAPTER_PROMPTS["multi_perspective"]},
+                {"role": "user", "content": synthesis_prompt},
+            ],
+            max_tokens=1024,
+            temperature=0.7,
+            top_p=0.9,
+            stop=["<|eot_id|>", "<|end_of_text|>"],
+        )
+
+        return result["choices"][0]["message"]["content"].strip()
+
+
+# ================================================================
+# Interactive Chat Mode
+# ================================================================
+def interactive_chat(orchestrator, max_adapters=2, strategy="keyword"):
+    """Run Codette as an interactive chatbot."""
+    print("\n" + "=" * 60)
+    print("  CODETTE ORCHESTRATOR — Interactive Mode")
+    print("=" * 60)
+    print(f"  Strategy: {strategy} | Max adapters: {max_adapters}")
+    print(f"  Available: {', '.join(orchestrator.available_adapters)}")
+    print(f"  Commands: /quit, /adapter <name>, /multi <n>, /base, /verbose")
+    print("=" * 60)
+
+    while True:
+        try:
+            query = input("\nYou: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\nGoodbye!")
+            break
+
+        if not query:
+            continue
+
+        # Commands
+        if query.startswith("/"):
+            parts = query.split()
+            cmd = parts[0].lower()
+
+            if cmd in ("/quit", "/exit", "/q"):
+                print("Goodbye!")
+                break
+            elif cmd == "/adapter" and len(parts) > 1:
+                force = parts[1]
+                result = orchestrator.route_and_generate(
+                    input("  Query: ").strip(),
+                    force_adapter=force,
+                )
+                print(f"\nCodette ({force}):\n{result['response']}")
+                continue
+            elif cmd == "/multi" and len(parts) > 1:
+                max_adapters = int(parts[1])
+                print(f"  Max adapters set to {max_adapters}")
+                continue
+            elif cmd == "/base":
+                result = orchestrator.route_and_generate(
+                    input("  Query: ").strip(),
+                    force_adapter=None,
+                )
+                print(f"\nCodette (base):\n{result['response']}")
+                continue
+            elif cmd == "/verbose":
+                orchestrator.verbose = not orchestrator.verbose
+                print(f"  Verbose: {orchestrator.verbose}")
+                continue
+            else:
+                print("  Unknown command. Try /quit, /adapter <name>, /multi <n>, /base, /verbose")
+                continue
+
+        # Normal query — route and generate
+        result = orchestrator.route_and_generate(
+            query,
+            max_adapters=max_adapters,
+            strategy=strategy,
+        )
+
+        print(f"\nCodette:")
+        print(result["response"])
+
+        # Show perspectives if multi
+        if "perspectives" in result and len(result.get("perspectives", {})) > 1:
+            show = input("\n  Show individual perspectives? (y/n): ").strip().lower()
+            if show == "y":
+                for name, text in result["perspectives"].items():
+                    print(f"\n  [{name.upper()}]:")
+                    print(f"  {text}")
+
+
+# ================================================================
+# Main
+# ================================================================
+def main():
+    parser = argparse.ArgumentParser(description="Codette Orchestrator")
+    parser.add_argument("--query", "-q", type=str, help="Single query (non-interactive)")
+    parser.add_argument("--adapter", "-a", type=str, help="Force specific adapter")
+    parser.add_argument("--multi", "-m", type=int, default=2, help="Max adapters (default: 2)")
+    parser.add_argument("--strategy", "-s", type=str, default="keyword",
+                        choices=["keyword", "llm", "hybrid"], help="Routing strategy")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
+    parser.add_argument("--gpu-layers", type=int, default=0, help="GPU layers (0=CPU only)")
+    args = parser.parse_args()
+
+    print("=" * 60)
+    print("  CODETTE ORCHESTRATOR")
+    print("=" * 60)
+    print(f"  Base: {os.path.basename(BASE_GGUF)}")
+    print(f"  Strategy: {args.strategy}")
+
+    orchestrator = CodetteOrchestrator(
+        n_gpu_layers=args.gpu_layers,
+        verbose=args.verbose,
+    )
+
+    if args.query:
+        # Single query mode
+        result = orchestrator.route_and_generate(
+            args.query,
+            max_adapters=args.multi,
+            strategy=args.strategy,
+            force_adapter=args.adapter,
+        )
+        print(f"\nCodette:")
+        print(result["response"])
+
+        if "perspectives" in result:
+            print(f"\n--- Perspectives ---")
+            for name, text in result["perspectives"].items():
+                print(f"\n[{name.upper()}]:")
+                print(text)
+    else:
+        # Interactive chat mode
+        interactive_chat(orchestrator, max_adapters=args.multi, strategy=args.strategy)
+
+
+if __name__ == "__main__":
+    main()

inference/codette_server.py

@@ -0,0 +1,728 @@
+#!/usr/bin/env python3
+"""Codette Web Server — Zero-Dependency Local AI Chat
+
+Pure Python stdlib HTTP server with SSE streaming.
+No Flask, no FastAPI, no npm, no node — just Python.
+
+Usage:
+    python codette_server.py                    # Start on port 7860
+    python codette_server.py --port 8080        # Custom port
+    python codette_server.py --no-browser       # Don't auto-open browser
+
+Architecture:
+    - http.server for static files + REST API
+    - Server-Sent Events (SSE) for streaming responses
+    - Threading for background model loading/inference
+    - CodetteOrchestrator for routing + generation
+    - CodetteSession for Cocoon-backed memory
+"""
+
+import os, sys, json, time, threading, queue, argparse, webbrowser, traceback
+from pathlib import Path
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+from urllib.parse import urlparse, parse_qs
+from io import BytesIO
+
+# Auto-configure environment
+_site = r"J:\Lib\site-packages"
+if _site not in sys.path:
+    sys.path.insert(0, _site)
+os.environ["PATH"] = r"J:\Lib\site-packages\Library\bin" + os.pathsep + os.environ.get("PATH", "")
+try:
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+except Exception:
+    pass
+
+# Project imports
+_inference_dir = str(Path(__file__).parent)
+if _inference_dir not in sys.path:
+    sys.path.insert(0, _inference_dir)
+
+from codette_session import (
+    CodetteSession, SessionStore, ADAPTER_COLORS, AGENT_NAMES
+)
+
+# Lazy import orchestrator (heavy — loads llama_cpp)
+_orchestrator = None
+_orchestrator_lock = threading.Lock()
+_inference_semaphore = threading.Semaphore(1)  # Limit to 1 concurrent inference (llama.cpp can't parallelize)
+_orchestrator_status = {"state": "idle", "message": "Not loaded"}
+_orchestrator_status_lock = threading.Lock()  # Protect _orchestrator_status from race conditions
+_load_error = None
+
+# Phase 6 bridge (optional, wraps orchestrator)
+_forge_bridge = None
+_use_phase6 = True  # ENABLED: Foundation restoration (memory kernel + stability field) wrapped in ForgeEngine + Phase 7 routing
+
+# Current session
+_session: CodetteSession = None
+_session_store: SessionStore = None
+_session_lock = threading.Lock()
+
+# Request queue for thread-safe model access
+_request_queue = queue.Queue()
+_response_queues = {}  # request_id -> queue.Queue
+_response_queues_lock = threading.Lock()  # Protect _response_queues from race conditions
+_queue_creation_times = {}  # Track when each queue was created for cleanup
+
+# Worker threads for health monitoring
+_worker_threads = []
+_worker_threads_lock = threading.Lock()
+
+
+def _get_orchestrator():
+    """Lazy-load the orchestrator (first call takes ~60s)."""
+    global _orchestrator, _orchestrator_status, _load_error, _forge_bridge
+    if _orchestrator is not None:
+        return _orchestrator
+
+    with _orchestrator_lock:
+        if _orchestrator is not None:
+            return _orchestrator
+
+        with _orchestrator_status_lock:
+            _orchestrator_status.update({"state": "loading", "message": "Loading Codette model..."})
+        print("\n  Loading CodetteOrchestrator...")
+
+        try:
+            from codette_orchestrator import CodetteOrchestrator
+            _orchestrator = CodetteOrchestrator(verbose=True)
+
+            with _orchestrator_status_lock:
+                _orchestrator_status.update({
+                    "state": "ready",
+                    "message": f"Ready — {len(_orchestrator.available_adapters)} adapters",
+                    "adapters": _orchestrator.available_adapters,
+                })
+            print(f"  Orchestrator ready: {_orchestrator.available_adapters}")
+
+            # Initialize Phase 6 bridge with Phase 7 routing (wraps orchestrator with ForgeEngine + Executive Controller)
+            print(f"  [DEBUG] _use_phase6 = {_use_phase6}")
+            if _use_phase6:
+                try:
+                    print(f"  [DEBUG] Importing CodetteForgeBridge...")
+                    from codette_forge_bridge import CodetteForgeBridge
+                    print(f"  [DEBUG] Creating bridge instance...")
+                    _forge_bridge = CodetteForgeBridge(_orchestrator, use_phase6=True, use_phase7=True, verbose=True)
+                    print(f"  Phase 6 bridge initialized")
+                    print(f"  Phase 7 Executive Controller initialized")
+                    with _orchestrator_status_lock:
+                        _orchestrator_status.update({"phase6": "enabled", "phase7": "enabled"})
+                except Exception as e:
+                    print(f"  Phase 6/7 bridge failed (using lightweight routing): {e}")
+                    import traceback
+                    traceback.print_exc()
+                    with _orchestrator_status_lock:
+                        _orchestrator_status.update({"phase6": "disabled", "phase7": "disabled"})
+            else:
+                print(f"  [DEBUG] Phase 6 disabled (_use_phase6=False)")
+
+            return _orchestrator
+        except Exception as e:
+            _load_error = str(e)
+            with _orchestrator_status_lock:
+                _orchestrator_status.update({"state": "error", "message": f"Load failed: {e}"})
+            print(f"  ERROR loading orchestrator: {e}")
+            traceback.print_exc()
+            return None
+
+
+def _cleanup_orphaned_queues():
+    """Periodically clean up response queues that are older than 5 minutes.
+
+    This prevents memory leaks from accumulating abandoned request queues.
+    """
+    while True:
+        try:
+            time.sleep(60)  # Run cleanup every 60 seconds
+            now = time.time()
+
+            with _response_queues_lock:
+                # Find queues older than 5 minutes (300 seconds)
+                orphaned = []
+                for req_id, creation_time in list(_queue_creation_times.items()):
+                    if now - creation_time > 300:
+                        orphaned.append(req_id)
+
+                # Remove orphaned queues
+                for req_id in orphaned:
+                    _response_queues.pop(req_id, None)
+                    _queue_creation_times.pop(req_id, None)
+
+                if orphaned:
+                    print(f"  Cleaned up {len(orphaned)} orphaned response queues")
+        except Exception as e:
+            print(f"  WARNING: Cleanup thread error: {e}")
+
+
+def _monitor_worker_health():
+    """Monitor worker threads and restart any that have died.
+
+    This ensures the system remains responsive even if a worker crashes.
+    """
+    while True:
+        try:
+            time.sleep(5)  # Check every 5 seconds
+
+            with _worker_threads_lock:
+                # Check each worker thread
+                alive_workers = []
+                dead_workers = []
+
+                for i, worker in enumerate(_worker_threads):
+                    if worker.is_alive():
+                        alive_workers.append((i, worker))
+                    else:
+                        dead_workers.append(i)
+
+                # Log and restart any dead workers
+                if dead_workers:
+                    print(f"  WARNING: Detected {len(dead_workers)} dead worker(s): {dead_workers}")
+                    for i in dead_workers:
+                        print(f"  Restarting worker thread {i}...")
+                        new_worker = threading.Thread(target=_worker_thread, daemon=True, name=f"worker-{i}")
+                        new_worker.start()
+                        _worker_threads[i] = new_worker
+                    print(f"  Worker threads restarted successfully")
+
+                # Log current work queue status periodically
+                work_queue_size = _request_queue.qsize()
+                if work_queue_size > 0:
+                    print(f"  Worker status: {len(alive_workers)} alive, {len(_response_queues)} pending requests, {work_queue_size} queued")
+
+        except Exception as e:
+            print(f"  WARNING: Worker health monitor error: {e}")
+
+
+def _worker_thread():
+    """Background worker that processes inference requests."""
+    # NOTE: Session handling disabled for now due to scoping issues
+    # TODO: Refactor session management to avoid UnboundLocalError
+
+    while True:
+        try:
+            request = _request_queue.get(timeout=1.0)
+        except queue.Empty:
+            continue
+
+        if request is None:
+            break  # Shutdown signal
+
+        req_id = request["id"]
+
+        # Get response queue with thread lock (prevent race condition)
+        with _response_queues_lock:
+            response_q = _response_queues.get(req_id)
+
+        if not response_q:
+            print(f"  WARNING: Orphaned request {req_id} (response queue missing)")
+            continue
+
+        try:
+            orch = _get_orchestrator()
+            if orch is None:
+                try:
+                    response_q.put({"error": _load_error or "Model failed to load"})
+                except (queue.Full, RuntimeError) as e:
+                    print(f"  ERROR: Failed to queue error response: {e}")
+                continue
+
+            query = request["query"]
+            adapter = request.get("adapter")  # None = auto-route
+            max_adapters = request.get("max_adapters", 2)
+
+            # Send "thinking" event
+            try:
+                response_q.put({"event": "thinking", "adapter": adapter or "auto"})
+            except (queue.Full, RuntimeError) as e:
+                print(f"  ERROR: Failed to queue thinking event: {e}")
+                continue
+
+            # Route and generate — limit to 1 concurrent inference to avoid memory exhaustion
+            # Add timeout to prevent deadlock if inference gets stuck
+            acquired = _inference_semaphore.acquire(timeout=120)
+            if not acquired:
+                try:
+                    response_q.put({"error": "Inference queue full, request timed out after 2 minutes"})
+                except (queue.Full, RuntimeError):
+                    pass
+                continue
+
+            try:
+                if _forge_bridge:
+                    result = _forge_bridge.generate(query, adapter=adapter, max_adapters=max_adapters)
+                else:
+                    result = orch.route_and_generate(
+                        query,
+                        max_adapters=max_adapters,
+                        strategy="keyword",
+                        force_adapter=adapter if adapter and adapter != "auto" else None,
+                    )
+
+                # Update session DISABLED - session handling deferred
+                # (was causing UnboundLocalError due to scoping issues)
+                epistemic = None
+
+                # Extract route info from result (if available from ForgeEngine)
+                route = result.get("route")
+                perspectives = result.get("perspectives", [])
+
+                # Build response
+                response_data = {
+                    "event": "complete",
+                    "response": result["response"],
+                    "adapter": result.get("adapter",
+                        result.get("adapters", ["base"])[0] if isinstance(result.get("adapters"), list) else "base"),
+                    "confidence": route.get("confidence", 0) if isinstance(route, dict) else (route.confidence if route else 0),
+                    "reasoning": route.get("reasoning", "") if isinstance(route, dict) else (route.reasoning if route else ""),
+                    "tokens": result.get("tokens", 0),
+                    "time": round(result.get("time", 0), 2),
+                    "multi_perspective": route.get("multi_perspective", False) if isinstance(route, dict) else (route.multi_perspective if route else False),
+                }
+
+                # Add perspectives if available
+                if perspectives:
+                    response_data["perspectives"] = perspectives
+
+                # Cocoon state DISABLED (requires session handling refactoring)
+
+                # Add epistemic report if available
+                if epistemic:
+                    response_data["epistemic"] = epistemic
+
+                # Add tool usage info if any tools were called
+                tools_used = result.get("tools_used", [])
+                if tools_used:
+                    response_data["tools_used"] = tools_used
+
+                # RE-CHECK response queue still exists (handler may have cleaned it up if timeout fired)
+                with _response_queues_lock:
+                    response_q_still_exists = req_id in _response_queues
+
+                if response_q_still_exists:
+                    try:
+                        response_q.put(response_data)
+                    except (queue.Full, RuntimeError) as e:
+                        print(f"  ERROR: Failed to queue response: {e}")
+                else:
+                    print(f"  WARNING: Response queue was cleaned up (handler timeout) - response dropped for {req_id}")
+
+            except Exception as e:
+                print(f"  ERROR during inference: {e}")
+                traceback.print_exc()
+
+                # DEFENSIVE: RE-CHECK response queue before putting error
+                with _response_queues_lock:
+                    response_q_still_exists = req_id in _response_queues
+
+                if response_q_still_exists:
+                    try:
+                        response_q.put({"event": "error", "error": str(e)})
+                    except (queue.Full, RuntimeError):
+                        print(f"  ERROR: Also failed to queue error response")
+                else:
+                    print(f"  WARNING: Response queue was cleaned up (handler timeout) - error response dropped for {req_id}")
+            finally:
+                # Always release the semaphore
+                _inference_semaphore.release()
+
+        except Exception as e:
+            print(f"  ERROR in worker thread: {e}")
+            traceback.print_exc()
+
+
+class CodetteHandler(SimpleHTTPRequestHandler):
+    """Custom HTTP handler for Codette API + static files."""
+
+    # Serve static files from inference/static/
+    def __init__(self, *args, **kwargs):
+        static_dir = str(Path(__file__).parent / "static")
+        super().__init__(*args, directory=static_dir, **kwargs)
+
+    def log_message(self, format, *args):
+        """Quieter logging — skip static file requests."""
+        msg = format % args
+        if not any(ext in msg for ext in [".css", ".js", ".ico", ".png", ".woff"]):
+            print(f"  [{time.strftime('%H:%M:%S')}] {msg}")
+
+    def do_GET(self):
+        parsed = urlparse(self.path)
+        path = parsed.path
+
+        # API routes
+        if path == "/api/status":
+            self._json_response(_orchestrator_status)
+        elif path == "/api/session":
+            self._json_response(_session.get_state() if _session else {})
+        elif path == "/api/sessions":
+            sessions = _session_store.list_sessions() if _session_store else []
+            self._json_response({"sessions": sessions})
+        elif path == "/api/adapters":
+            self._json_response({
+                "colors": ADAPTER_COLORS,
+                "agents": AGENT_NAMES,
+                "available": _orchestrator.available_adapters if _orchestrator else [],
+            })
+        elif path == "/api/chat":
+            # SSE endpoint for streaming
+            self._handle_chat_sse(parsed)
+        elif path == "/":
+            # Serve index.html
+            self.path = "/index.html"
+            super().do_GET()
+        else:
+            super().do_GET()
+
+    def do_POST(self):
+        parsed = urlparse(self.path)
+        path = parsed.path
+
+        if path == "/api/chat":
+            self._handle_chat_post()
+        elif path == "/api/session/new":
+            self._handle_new_session()
+        elif path == "/api/session/load":
+            self._handle_load_session()
+        elif path == "/api/session/save":
+            self._handle_save_session()
+        elif path == "/api/session/export":
+            self._handle_export_session()
+        elif path == "/api/session/import":
+            self._handle_import_session()
+        else:
+            self.send_error(404, "Not found")
+
+    def _json_response(self, data, status=200):
+        """Send a JSON response."""
+        try:
+            body = json.dumps(data, default=str).encode("utf-8")
+            self.send_response(status)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", len(body))
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.end_headers()
+            self.wfile.write(body)
+            self.wfile.flush()
+        except (ConnectionAbortedError, BrokenPipeError):
+            # Client disconnected before response was fully sent — this is normal
+            pass
+        except Exception as e:
+            print(f"  ERROR in _json_response: {e}")
+
+    def _read_json_body(self):
+        """Read and parse JSON POST body."""
+        length = int(self.headers.get("Content-Length", 0))
+        body = self.rfile.read(length)
+        return json.loads(body) if body else {}
+
+    def _handle_chat_post(self):
+        """Handle chat request — queue inference, return via SSE or JSON."""
+        data = self._read_json_body()
+        query = data.get("query", "").strip()
+        adapter = data.get("adapter")
+        max_adapters = data.get("max_adapters", 2)
+
+        if not query:
+            self._json_response({"error": "Empty query"}, 400)
+            return
+
+        # Guardian input check
+        if _session and _session.guardian:
+            check = _session.guardian.check_input(query)
+            if not check["safe"]:
+                query = check["cleaned_text"]
+
+        # Check if orchestrator is loading
+        with _orchestrator_status_lock:
+            status_state = _orchestrator_status.get("state")
+        if status_state == "loading":
+            self._json_response({
+                "error": "Model is still loading, please wait...",
+                "status": _orchestrator_status,
+            }, 503)
+            return
+
+        # Queue the request
+        req_id = f"{time.time()}_{id(self)}"
+        response_q = queue.Queue()
+
+        # Add with thread lock
+        with _response_queues_lock:
+            _response_queues[req_id] = response_q
+            _queue_creation_times[req_id] = time.time()
+
+        _request_queue.put({
+            "id": req_id,
+            "query": query,
+            "adapter": adapter,
+            "max_adapters": max_adapters,
+        })
+
+        # Wait for response (with timeout)
+        try:
+            # First wait for thinking event
+            thinking = response_q.get(timeout=120)
+            if "error" in thinking and thinking.get("event") != "thinking":
+                self._json_response(thinking, 500)
+                return
+
+            # Wait for complete event (multi-perspective can take 15+ min on CPU)
+            result = response_q.get(timeout=1200)  # 20 min max for inference
+            self._json_response(result)
+
+        except queue.Empty:
+            self._json_response({"error": "Request timed out"}, 504)
+        finally:
+            # Clean up with thread lock
+            with _response_queues_lock:
+                _response_queues.pop(req_id, None)
+                _queue_creation_times.pop(req_id, None)
+
+    def _handle_chat_sse(self, parsed):
+        """Handle SSE streaming endpoint."""
+        params = parse_qs(parsed.query)
+        query = params.get("q", [""])[0]
+        adapter = params.get("adapter", [None])[0]
+
+        if not query:
+            self.send_error(400, "Missing query parameter 'q'")
+            return
+
+        # Set up SSE headers
+        self.send_response(200)
+        self.send_header("Content-Type", "text/event-stream")
+        self.send_header("Cache-Control", "no-cache")
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Connection", "keep-alive")
+        self.end_headers()
+
+        # Queue request
+        req_id = f"sse_{time.time()}_{id(self)}"
+        response_q = queue.Queue()
+
+        # Add with thread lock
+        with _response_queues_lock:
+            _response_queues[req_id] = response_q
+            _queue_creation_times[req_id] = time.time()
+
+        _request_queue.put({
+            "id": req_id,
+            "query": query,
+            "adapter": adapter,
+            "max_adapters": 2,
+        })
+
+        try:
+            # Stream events
+            while True:
+                try:
+                    event = response_q.get(timeout=300)
+                except queue.Empty:
+                    self._send_sse("error", {"error": "Timeout"})
+                    break
+
+                event_type = event.get("event", "message")
+                self._send_sse(event_type, event)
+
+                if event_type in ("complete", "error"):
+                    break
+        finally:
+            _response_queues.pop(req_id, None)
+
+    def _send_sse(self, event_type, data):
+        """Send a Server-Sent Event."""
+        try:
+            payload = f"event: {event_type}\ndata: {json.dumps(data, default=str)}\n\n"
+            self.wfile.write(payload.encode("utf-8"))
+            self.wfile.flush()
+        except Exception:
+            pass
+
+    def _handle_new_session(self):
+        """Create a new session."""
+        global _session
+        # Save current session first
+        if _session and _session_store and _session.messages:
+            try:
+                _session_store.save(_session)
+            except Exception:
+                pass
+
+        _session = CodetteSession()
+        self._json_response({"session_id": _session.session_id})
+
+    def _handle_load_session(self):
+        """Load a previous session."""
+        global _session
+        data = self._read_json_body()
+        session_id = data.get("session_id")
+
+        if not session_id or not _session_store:
+            self._json_response({"error": "Invalid session ID"}, 400)
+            return
+
+        loaded = _session_store.load(session_id)
+        if loaded:
+            _session = loaded
+            self._json_response({
+                "session_id": _session.session_id,
+                "messages": _session.messages,
+                "state": _session.get_state(),
+            })
+        else:
+            self._json_response({"error": "Session not found"}, 404)
+
+    def _handle_save_session(self):
+        """Manually save current session."""
+        if _session and _session_store:
+            _session_store.save(_session)
+            self._json_response({"saved": True, "session_id": _session.session_id})
+        else:
+            self._json_response({"error": "No active session"}, 400)
+
+    def _handle_export_session(self):
+        """Export current session as downloadable JSON."""
+        if not _session:
+            self._json_response({"error": "No active session"}, 400)
+            return
+
+        export_data = _session.to_dict()
+        export_data["_export_version"] = 1
+        export_data["_exported_at"] = time.time()
+
+        body = json.dumps(export_data, default=str, indent=2).encode("utf-8")
+        filename = f"codette_session_{_session.session_id[:8]}.json"
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Disposition", f'attachment; filename="{filename}"')
+        self.send_header("Content-Length", len(body))
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _handle_import_session(self):
+        """Import a session from uploaded JSON."""
+        global _session
+        try:
+            data = self._read_json_body()
+            if not data or "session_id" not in data:
+                self._json_response({"error": "Invalid session data"}, 400)
+                return
+
+            # Save current session before importing
+            if _session and _session_store and _session.messages:
+                try:
+                    _session_store.save(_session)
+                except Exception:
+                    pass
+
+            _session = CodetteSession()
+            _session.from_dict(data)
+
+            # Save imported session to store
+            if _session_store:
+                try:
+                    _session_store.save(_session)
+                except Exception:
+                    pass
+
+            self._json_response({
+                "session_id": _session.session_id,
+                "messages": _session.messages,
+                "state": _session.get_state(),
+                "imported": True,
+            })
+        except Exception as e:
+            self._json_response({"error": f"Import failed: {e}"}, 400)
+
+
+def main():
+    global _session, _session_store, _worker_threads
+
+    parser = argparse.ArgumentParser(description="Codette Web UI")
+    parser.add_argument("--port", type=int, default=7860, help="Port (default: 7860)")
+    parser.add_argument("--no-browser", action="store_true", help="Don't auto-open browser")
+    args = parser.parse_args()
+
+    print("=" * 60)
+    print("  CODETTE WEB UI")
+    print("=" * 60)
+
+    # Initialize session
+    _session_store = SessionStore()
+    _session = CodetteSession()
+    print(f"  Session: {_session.session_id}")
+    print(f"  Cocoon: spiderweb={_session.spiderweb is not None}, "
+          f"metrics={_session.metrics_engine is not None}")
+
+    # Start worker thread for request processing
+    # NOTE: Only 1 worker needed — llama.cpp cannot parallelize inference.
+    # With 1 semaphore + 1 worker, we avoid idle threads and deadlock risk.
+    # Multiple workers would just spin waiting for the semaphore.
+    num_workers = 1
+    with _worker_threads_lock:
+        for i in range(num_workers):
+            worker = threading.Thread(target=_worker_thread, daemon=True, name=f"worker-{i}")
+            worker.start()
+            _worker_threads.append(worker)
+    print(f"  Started {num_workers} worker thread for serial inference")
+
+    # Start cleanup thread for orphaned response queues
+    cleanup_thread = threading.Thread(target=_cleanup_orphaned_queues, daemon=True, name="cleanup")
+    cleanup_thread.start()
+    print(f"  Started cleanup thread for queue maintenance")
+
+    # Start worker health monitor thread
+    health_monitor = threading.Thread(target=_monitor_worker_health, daemon=True, name="health-monitor")
+    health_monitor.start()
+    print(f"  Started worker health monitor thread")
+
+    # Start model loading in background
+    threading.Thread(target=_get_orchestrator, daemon=True).start()
+
+    # Wait for model to load (up to 120 seconds)
+    print(f"  Waiting for model to load (this takes ~60s on first startup)...")
+    start_wait = time.time()
+    while True:
+        with _orchestrator_status_lock:
+            state = _orchestrator_status.get("state")
+        if state not in ("idle", "loading"):
+            break
+        if time.time() - start_wait > 120:
+            break
+        time.sleep(0.5)
+
+    with _orchestrator_status_lock:
+        state = _orchestrator_status.get("state")
+    if state == "ready":
+        print(f"  Model loaded in {time.time() - start_wait:.0f}s")
+    elif state == "loading":
+        print(f"  Model still loading (will continue in background)...")
+    else:
+        print(f"  WARNING: Model load status: {_orchestrator_status}")
+
+    # Start server
+    server = HTTPServer(("127.0.0.1", args.port), CodetteHandler)
+    url = f"http://localhost:{args.port}"
+    print(f"\n  Server: {url}")
+    print(f"  Press Ctrl+C to stop\n")
+
+    # Open browser
+    if not args.no_browser:
+        threading.Timer(1.0, lambda: webbrowser.open(url)).start()
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\n  Shutting down...")
+        # Save session
+        if _session and _session_store and _session.messages:
+            _session_store.save(_session)
+            print(f"  Session saved: {_session.session_id}")
+        _request_queue.put(None)  # Shutdown worker
+        server.shutdown()
+        print("  Goodbye!")
+
+
+if __name__ == "__main__":
+    main()

inference/codette_session.py

@@ -0,0 +1,675 @@
+#!/usr/bin/env python3
+"""Codette Session Manager — Cocoon-Backed Conversation Memory
+
+Wraps the Cocoon system (QuantumSpiderweb + CocoonSync + EpistemicMetrics)
+into a session manager that persists conversation state with encrypted memory.
+
+Each session saves:
+- Chat history
+- Spiderweb state (agent beliefs, tensions, attractors)
+- Glyphs (identity signatures)
+- Epistemic metrics (coherence, tension, coverage)
+
+Zero external dependencies beyond what the forge already uses.
+"""
+
+import json, os, time, hashlib, sqlite3
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+
+# Add project root to path
+import sys
+_root = str(Path(__file__).parent.parent)
+if _root not in sys.path:
+    sys.path.insert(0, _root)
+
+# Import Cocoon subsystems (graceful fallback if not available)
+try:
+    from reasoning_forge.quantum_spiderweb import QuantumSpiderweb, NodeState
+    HAS_SPIDERWEB = True
+except ImportError:
+    HAS_SPIDERWEB = False
+
+try:
+    from reasoning_forge.epistemic_metrics import EpistemicMetrics
+    HAS_METRICS = True
+except ImportError:
+    HAS_METRICS = False
+
+try:
+    from reasoning_forge.cocoon_sync import CocoonSync, CocoonKeyManager
+    HAS_COCOON = True
+except ImportError:
+    HAS_COCOON = False
+
+try:
+    from reasoning_forge.dream_reweaver import DreamReweaver
+    HAS_DREAMER = True
+except ImportError:
+    HAS_DREAMER = False
+
+try:
+    from reasoning_forge.quantum_optimizer import QuantumOptimizer, QualitySignal
+    HAS_OPTIMIZER = True
+except ImportError:
+    HAS_OPTIMIZER = False
+
+try:
+    from reasoning_forge.living_memory import LivingMemoryKernel
+    HAS_MEMORY = True
+except ImportError:
+    HAS_MEMORY = False
+
+try:
+    from reasoning_forge.guardian import CodetteGuardian
+    HAS_GUARDIAN = True
+except ImportError:
+    HAS_GUARDIAN = False
+
+try:
+    from reasoning_forge.resonant_continuity import ResonantContinuityEngine
+    HAS_RESONANCE = True
+except ImportError:
+    HAS_RESONANCE = False
+
+try:
+    from reasoning_forge.perspective_registry import (
+        PERSPECTIVES, get_adapter_for_perspective, list_all as list_perspectives
+    )
+    HAS_PERSPECTIVES = True
+except ImportError:
+    HAS_PERSPECTIVES = False
+
+try:
+    from reasoning_forge.aegis import AEGIS
+    HAS_AEGIS = True
+except ImportError:
+    HAS_AEGIS = False
+
+try:
+    from reasoning_forge.nexus import NexusSignalEngine
+    HAS_NEXUS = True
+except ImportError:
+    HAS_NEXUS = False
+
+# Agent names matching the 8 adapters
+AGENT_NAMES = [
+    "newton", "davinci", "empathy", "philosophy",
+    "quantum", "consciousness", "multi_perspective", "systems_architecture"
+]
+
+# Adapter accent colors for UI
+ADAPTER_COLORS = {
+    "newton": "#3b82f6",           # Electric blue
+    "davinci": "#f59e0b",          # Warm gold
+    "empathy": "#a855f7",          # Soft purple
+    "philosophy": "#10b981",       # Emerald green
+    "quantum": "#ef4444",          # Crimson red
+    "consciousness": "#e2e8f0",    # Silver/white
+    "multi_perspective": "#f97316", # Amber
+    "systems_architecture": "#06b6d4",  # Teal
+    "_base": "#94a3b8",            # Slate gray
+}
+
+DB_PATH = Path(__file__).parent.parent / "data" / "codette_sessions.db"
+
+
+class CodetteSession:
+    """Manages a single conversation session with Cocoon state."""
+
+    def __init__(self, session_id: Optional[str] = None):
+        self.session_id = session_id or hashlib.sha256(
+            f"{time.time()}_{os.getpid()}".encode()
+        ).hexdigest()[:16]
+
+        self.messages: List[Dict[str, str]] = []
+        self.created_at = time.time()
+        self.updated_at = time.time()
+
+        # Cocoon state
+        self.spiderweb = None
+        self.metrics_engine = None
+        self.cocoon_sync = None
+        self.dream_reweaver = None
+        self.optimizer = None
+        self.memory_kernel = None
+        self.guardian = None
+        self.resonance_engine = None
+        self.aegis = None
+        self.nexus = None
+
+        # Metrics history
+        self.coherence_history: List[float] = []
+        self.tension_history: List[float] = []
+        self.attractors: List[Dict] = []
+        self.glyphs: List[Dict] = []
+        self.perspective_usage: Dict[str, int] = {}
+        self.lifeforms: List[str] = []  # Spawned concept nodes
+        self.dream_history: List[Dict] = []  # Dream field results
+
+        # Initialize subsystems
+        self._init_cocoon()
+
+    def _init_cocoon(self):
+        """Initialize Cocoon subsystems if available."""
+        if HAS_SPIDERWEB:
+            self.spiderweb = QuantumSpiderweb()
+            self.spiderweb.build_from_agents(AGENT_NAMES)
+
+        if HAS_METRICS:
+            self.metrics_engine = EpistemicMetrics()
+
+        if HAS_COCOON:
+            try:
+                key_mgr = CocoonKeyManager()
+                self.cocoon_sync = CocoonSync(
+                    node_id=f"session_{self.session_id}",
+                    key_manager=key_mgr,
+                )
+            except Exception:
+                self.cocoon_sync = None
+
+        if HAS_DREAMER:
+            self.dream_reweaver = DreamReweaver(creativity=0.3)
+
+        if HAS_OPTIMIZER:
+            self.optimizer = QuantumOptimizer()
+
+        if HAS_MEMORY:
+            self.memory_kernel = LivingMemoryKernel(max_memories=100)
+
+        if HAS_GUARDIAN:
+            self.guardian = CodetteGuardian()
+
+        if HAS_RESONANCE:
+            self.resonance_engine = ResonantContinuityEngine()
+
+        if HAS_AEGIS:
+            self.aegis = AEGIS()
+
+        if HAS_NEXUS:
+            self.nexus = NexusSignalEngine()
+
+    def add_message(self, role: str, content: str, metadata: Optional[Dict] = None):
+        """Add a message to the session history."""
+        msg = {
+            "role": role,
+            "content": content,
+            "timestamp": time.time(),
+        }
+        if metadata:
+            msg["metadata"] = metadata
+        self.messages.append(msg)
+        self.updated_at = time.time()
+
+    def update_after_response(self, route_result, adapter_name: str,
+                               perspectives: Optional[Dict[str, str]] = None):
+        """Update Cocoon state after a Codette response.
+
+        Args:
+            route_result: RouteResult from the router
+            adapter_name: Which adapter was primary
+            perspectives: Dict of adapter_name -> response text (if multi-perspective)
+        """
+        # Track adapter usage
+        self.perspective_usage[adapter_name] = \
+            self.perspective_usage.get(adapter_name, 0) + 1
+
+        if not HAS_SPIDERWEB or self.spiderweb is None:
+            return
+
+        # Propagate belief through the spiderweb from the active adapter
+        try:
+            if adapter_name in self.spiderweb.nodes:
+                node = self.spiderweb.nodes[adapter_name]
+                # Boost the active adapter's psi (thought magnitude)
+                node.state.psi = min(node.state.psi + 0.1, 2.0)
+                node.state.tau += 0.05  # Temporal progression
+
+                # Propagate the boosted belief outward (BUG FIX: pass belief state)
+                self.spiderweb.propagate_belief(
+                    adapter_name, belief=node.state, max_hops=2
+                )
+
+            # If multi-perspective, entangle the participating agents
+            if perspectives and len(perspectives) > 1:
+                adapters = list(perspectives.keys())
+                for i in range(len(adapters)):
+                    for j in range(i + 1, len(adapters)):
+                        if (adapters[i] in self.spiderweb.nodes and
+                            adapters[j] in self.spiderweb.nodes):
+                            self.spiderweb.entangle(adapters[i], adapters[j])
+
+            # Compute metrics
+            coherence = self.spiderweb.phase_coherence()
+            self.coherence_history.append(coherence)
+
+            # Detect attractors
+            self.attractors = self.spiderweb.detect_attractors()
+
+            # Try to form glyphs for active nodes
+            for name in (perspectives or {adapter_name: ""}).keys():
+                if name in self.spiderweb.nodes:
+                    glyph = self.spiderweb.form_glyph(name)
+                    if glyph:
+                        self.glyphs.append({
+                            "glyph_id": glyph.glyph_id,
+                            "source": glyph.source_node,
+                            "stability": glyph.stability_score,
+                        })
+
+            # Check convergence
+            is_converging, mean_tension = self.spiderweb.check_convergence()
+            self.tension_history.append(mean_tension)
+
+            # Feed quality signal to optimizer if available
+            if HAS_OPTIMIZER and self.optimizer:
+                try:
+                    signal = QualitySignal(
+                        timestamp=time.time(),
+                        adapter=adapter_name,
+                        coherence=coherence,
+                        tension=mean_tension,
+                        productivity=0.5,  # Default, updated by epistemic report
+                        response_length=0,
+                        multi_perspective=perspectives is not None and len(perspectives) > 1,
+                        user_continued=True,
+                    )
+                    self.optimizer.record_signal(signal)
+                except Exception:
+                    pass
+
+        except Exception as e:
+            print(f"  [cocoon] Spiderweb update error: {e}")
+
+        # Update resonance engine
+        if self.resonance_engine:
+            try:
+                coh = self.coherence_history[-1] if self.coherence_history else 0.5
+                ten = self.tension_history[-1] if self.tension_history else 0.3
+                self.resonance_engine.compute_psi(coherence=coh, tension=ten)
+            except Exception:
+                pass
+
+        # Update guardian trust
+        if self.guardian:
+            try:
+                coh = self.coherence_history[-1] if self.coherence_history else 0.5
+                ten = self.tension_history[-1] if self.tension_history else 0.3
+                self.guardian.evaluate_output(adapter_name, "", coh, ten)
+            except Exception:
+                pass
+
+        # AEGIS ethical evaluation of the response
+        if self.aegis and self.messages:
+            try:
+                # Find the most recent assistant response
+                for msg in reversed(self.messages[-4:]):
+                    if msg["role"] == "assistant":
+                        self.aegis.evaluate(msg["content"], adapter=adapter_name)
+                        break
+            except Exception:
+                pass
+
+        # Nexus signal analysis of the user input
+        if self.nexus and self.messages:
+            try:
+                for msg in reversed(self.messages[-4:]):
+                    if msg["role"] == "user":
+                        self.nexus.analyze(msg["content"], adapter=adapter_name)
+                        break
+            except Exception:
+                pass
+
+        # Store memory cocoon for significant exchanges
+        if self.memory_kernel and self.messages:
+            try:
+                # Find the most recent user query and assistant response
+                query_text = ""
+                response_text = ""
+                for msg in reversed(self.messages[-4:]):
+                    if msg["role"] == "user" and not query_text:
+                        query_text = msg["content"]
+                    elif msg["role"] == "assistant" and not response_text:
+                        response_text = msg["content"]
+                if query_text and response_text:
+                    coh = self.coherence_history[-1] if self.coherence_history else 0.5
+                    ten = self.tension_history[-1] if self.tension_history else 0.3
+                    self.memory_kernel.store_from_turn(
+                        query=query_text,
+                        response=response_text,
+                        adapter=adapter_name,
+                        coherence=coh,
+                        tension=ten,
+                    )
+            except Exception:
+                pass
+
+    def compute_epistemic_report(self, analyses: Dict[str, str],
+                                  synthesis: str = "") -> Optional[Dict]:
+        """Run full epistemic metrics on a multi-perspective response."""
+        if not HAS_METRICS or self.metrics_engine is None:
+            return None
+
+        try:
+            return self.metrics_engine.full_epistemic_report(analyses, synthesis)
+        except Exception as e:
+            print(f"  [cocoon] Metrics error: {e}")
+            return None
+
+    def get_state(self) -> Dict[str, Any]:
+        """Get full session state for UI rendering."""
+        state = {
+            "session_id": self.session_id,
+            "message_count": len(self.messages),
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "perspective_usage": self.perspective_usage,
+            "adapter_colors": ADAPTER_COLORS,
+            "cocoon": {
+                "has_spiderweb": HAS_SPIDERWEB and self.spiderweb is not None,
+                "has_metrics": HAS_METRICS,
+                "has_sync": HAS_COCOON and self.cocoon_sync is not None,
+            },
+        }
+
+        # Spiderweb state
+        if self.spiderweb:
+            try:
+                web_dict = self.spiderweb.to_dict()
+                state["spiderweb"] = {
+                    "nodes": {
+                        nid: {
+                            # BUG FIX: to_dict() stores state as a list [psi,tau,chi,phi,lam]
+                            "state": n["state"],
+                            "neighbors": n.get("neighbors", []),
+                            "tension_history": n.get("tension_history", [])[-10:],
+                        }
+                        for nid, n in web_dict.get("nodes", {}).items()
+                    },
+                    "phase_coherence": web_dict.get("phase_coherence", 0),
+                    "attractors": self.attractors,
+                    "glyphs": self.glyphs[-10:],  # Last 10
+                    # New VIVARA-inspired metrics
+                    "entropy": self.spiderweb.shannon_entropy(),
+                    "decoherence_rate": self.spiderweb.decoherence_rate(),
+                    "lifeforms": self.lifeforms[-20:],
+                }
+            except Exception:
+                state["spiderweb"] = None
+        else:
+            state["spiderweb"] = None
+
+        # Metrics history
+        state["metrics"] = {
+            "coherence_history": self.coherence_history[-50:],
+            "tension_history": self.tension_history[-50:],
+            "current_coherence": self.coherence_history[-1] if self.coherence_history else 0,
+            "current_tension": self.tension_history[-1] if self.tension_history else 0,
+            "attractor_count": len(self.attractors),
+            "glyph_count": len(self.glyphs),
+        }
+
+        # Optimizer tuning state
+        if HAS_OPTIMIZER and self.optimizer:
+            state["optimizer"] = self.optimizer.get_tuning_report()
+        else:
+            state["optimizer"] = None
+
+        # Dream history
+        state["dream_history"] = self.dream_history[-10:]
+
+        # Living memory
+        if self.memory_kernel:
+            state["memory"] = self.memory_kernel.get_state()
+        else:
+            state["memory"] = None
+
+        # Guardian state
+        if self.guardian:
+            state["guardian"] = self.guardian.get_state()
+        else:
+            state["guardian"] = None
+
+        # Resonant continuity
+        if self.resonance_engine:
+            state["resonance"] = self.resonance_engine.get_state()
+        else:
+            state["resonance"] = None
+
+        # AEGIS ethical alignment
+        if self.aegis:
+            state["aegis"] = self.aegis.get_state()
+        else:
+            state["aegis"] = None
+
+        # Nexus signal intelligence
+        if self.nexus:
+            state["nexus"] = self.nexus.get_state()
+        else:
+            state["nexus"] = None
+
+        # Perspective registry
+        if HAS_PERSPECTIVES:
+            state["perspectives_available"] = len(PERSPECTIVES)
+
+        return state
+
+    def to_dict(self) -> Dict:
+        """Serialize for storage."""
+        data = {
+            "session_id": self.session_id,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "messages": self.messages,
+            "coherence_history": self.coherence_history,
+            "tension_history": self.tension_history,
+            "attractors": self.attractors,
+            "glyphs": self.glyphs,
+            "perspective_usage": self.perspective_usage,
+            "lifeforms": self.lifeforms,
+            "dream_history": self.dream_history,
+        }
+        if self.spiderweb:
+            try:
+                data["spiderweb_state"] = self.spiderweb.to_dict()
+            except Exception:
+                pass
+        if HAS_OPTIMIZER and self.optimizer:
+            try:
+                data["optimizer_state"] = self.optimizer.to_dict()
+            except Exception:
+                pass
+        if self.memory_kernel:
+            try:
+                data["memory_state"] = self.memory_kernel.to_dict()
+            except Exception:
+                pass
+        if self.guardian:
+            try:
+                data["guardian_state"] = self.guardian.to_dict()
+            except Exception:
+                pass
+        if self.resonance_engine:
+            try:
+                data["resonance_state"] = self.resonance_engine.to_dict()
+            except Exception:
+                pass
+        if self.aegis:
+            try:
+                data["aegis_state"] = self.aegis.to_dict()
+            except Exception:
+                pass
+        if self.nexus:
+            try:
+                data["nexus_state"] = self.nexus.to_dict()
+            except Exception:
+                pass
+        return data
+
+    def from_dict(self, data: Dict):
+        """Restore from storage."""
+        self.session_id = data.get("session_id", self.session_id)
+        self.created_at = data.get("created_at", self.created_at)
+        self.updated_at = data.get("updated_at", self.updated_at)
+        self.messages = data.get("messages", [])
+        self.coherence_history = data.get("coherence_history", [])
+        self.tension_history = data.get("tension_history", [])
+        self.attractors = data.get("attractors", [])
+        self.glyphs = data.get("glyphs", [])
+        self.perspective_usage = data.get("perspective_usage", {})
+        self.lifeforms = data.get("lifeforms", [])
+        self.dream_history = data.get("dream_history", [])
+
+        if self.spiderweb and "spiderweb_state" in data:
+            try:
+                self.spiderweb = QuantumSpiderweb.from_dict(data["spiderweb_state"])
+            except Exception:
+                pass
+        if HAS_OPTIMIZER and self.optimizer and "optimizer_state" in data:
+            try:
+                self.optimizer = QuantumOptimizer.from_dict(data["optimizer_state"])
+            except Exception:
+                pass
+        if HAS_MEMORY and "memory_state" in data:
+            try:
+                self.memory_kernel = LivingMemoryKernel.from_dict(data["memory_state"])
+            except Exception:
+                pass
+        if HAS_GUARDIAN and "guardian_state" in data:
+            try:
+                self.guardian = CodetteGuardian.from_dict(data["guardian_state"])
+            except Exception:
+                pass
+        if HAS_RESONANCE and "resonance_state" in data:
+            try:
+                self.resonance_engine = ResonantContinuityEngine.from_dict(data["resonance_state"])
+            except Exception:
+                pass
+        if HAS_AEGIS and "aegis_state" in data:
+            try:
+                self.aegis = AEGIS.from_dict(data["aegis_state"])
+            except Exception:
+                pass
+        if HAS_NEXUS and "nexus_state" in data:
+            try:
+                self.nexus = NexusSignalEngine.from_dict(data["nexus_state"])
+            except Exception:
+                pass
+
+
+class SessionStore:
+    """SQLite-backed session persistence with Cocoon encryption."""
+
+    def __init__(self, db_path: Optional[Path] = None):
+        self.db_path = db_path or DB_PATH
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._init_db()
+
+    def _init_db(self):
+        """Create sessions table if needed."""
+        conn = sqlite3.connect(str(self.db_path))
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS sessions (
+                session_id TEXT PRIMARY KEY,
+                created_at REAL,
+                updated_at REAL,
+                title TEXT,
+                data TEXT
+            )
+        """)
+        conn.commit()
+        conn.close()
+
+    def save(self, session: CodetteSession, title: Optional[str] = None):
+        """Save a session to the database."""
+        if title is None:
+            # Auto-title from first user message
+            for msg in session.messages:
+                if msg["role"] == "user":
+                    title = msg["content"][:80]
+                    break
+            title = title or f"Session {session.session_id[:8]}"
+
+        data_json = json.dumps(session.to_dict())
+
+        conn = sqlite3.connect(str(self.db_path))
+        conn.execute("""
+            INSERT OR REPLACE INTO sessions (session_id, created_at, updated_at, title, data)
+            VALUES (?, ?, ?, ?, ?)
+        """, (session.session_id, session.created_at, session.updated_at, title, data_json))
+        conn.commit()
+        conn.close()
+
+    def load(self, session_id: str) -> Optional[CodetteSession]:
+        """Load a session from the database."""
+        conn = sqlite3.connect(str(self.db_path))
+        row = conn.execute(
+            "SELECT data FROM sessions WHERE session_id = ?", (session_id,)
+        ).fetchone()
+        conn.close()
+
+        if not row:
+            return None
+
+        session = CodetteSession(session_id)
+        session.from_dict(json.loads(row[0]))
+        return session
+
+    def list_sessions(self, limit: int = 20) -> List[Dict]:
+        """List recent sessions."""
+        conn = sqlite3.connect(str(self.db_path))
+        rows = conn.execute("""
+            SELECT session_id, created_at, updated_at, title
+            FROM sessions ORDER BY updated_at DESC LIMIT ?
+        """, (limit,)).fetchall()
+        conn.close()
+
+        return [
+            {
+                "session_id": r[0],
+                "created_at": r[1],
+                "updated_at": r[2],
+                "title": r[3],
+            }
+            for r in rows
+        ]
+
+    def delete(self, session_id: str):
+        """Delete a session."""
+        conn = sqlite3.connect(str(self.db_path))
+        conn.execute("DELETE FROM sessions WHERE session_id = ?", (session_id,))
+        conn.commit()
+        conn.close()
+
+
+# Quick test
+if __name__ == "__main__":
+    print("Testing CodetteSession...")
+    session = CodetteSession()
+    print(f"  Session ID: {session.session_id}")
+    print(f"  Spiderweb: {HAS_SPIDERWEB}")
+    print(f"  Metrics: {HAS_METRICS}")
+    print(f"  Cocoon: {HAS_COCOON}")
+
+    session.add_message("user", "How does gravity work?")
+    session.add_message("assistant", "Objects attract each other...",
+                        metadata={"adapter": "newton", "confidence": 0.95})
+
+    state = session.get_state()
+    print(f"  State keys: {list(state.keys())}")
+    print(f"  Cocoon status: {state['cocoon']}")
+
+    if state["spiderweb"]:
+        print(f"  Nodes: {list(state['spiderweb']['nodes'].keys())}")
+        print(f"  Phase coherence: {state['spiderweb']['phase_coherence']:.4f}")
+
+    # Test persistence
+    store = SessionStore()
+    store.save(session)
+    loaded = store.load(session.session_id)
+    print(f"  Persistence: {'OK' if loaded else 'FAILED'}")
+    if loaded:
+        print(f"  Loaded messages: {len(loaded.messages)}")
+
+    print("Done!")

inference/codette_tools.py

@@ -0,0 +1,558 @@
+#!/usr/bin/env python3
+"""Codette Tool System — Safe Local Tool Execution
+
+Gives Codette the ability to read files, search code, list directories,
+and run safe Python snippets. Tools are sandboxed and read-only by default.
+
+Tool Call Format (in Codette's output):
+    <tool>tool_name(arg1, arg2)</tool>
+
+Tool Result (injected back into context):
+    <tool_result>...output...</tool_result>
+
+Architecture:
+    1. Codette generates text that may contain <tool>...</tool> tags
+    2. Server parses out tool calls
+    3. Tools execute with safety limits
+    4. Results are fed back for a second generation pass
+"""
+
+import os
+import re
+import ast
+import json
+import subprocess
+import traceback
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple, Any
+
+# ================================================================
+# Safety Configuration
+# ================================================================
+
+# Directories Codette is allowed to read from
+ALLOWED_ROOTS = [
+    Path(r"J:\codette-training-lab"),
+    Path(r"C:\Users\Jonathan\Documents"),
+]
+
+# File extensions Codette can read
+READABLE_EXTENSIONS = {
+    ".py", ".js", ".ts", ".html", ".css", ".json", ".yaml", ".yml",
+    ".md", ".txt", ".csv", ".toml", ".cfg", ".ini", ".sh", ".bat",
+    ".bib", ".tex", ".log", ".jsonl",
+}
+
+# Max file size to read (prevent reading huge binaries)
+MAX_FILE_SIZE = 500_000  # 500KB
+
+# Max output length per tool result
+MAX_OUTPUT_LENGTH = 4000  # chars
+
+# Max lines for file reads
+MAX_LINES = 200
+
+# Python execution timeout
+PYTHON_TIMEOUT = 10  # seconds
+
+
+# ================================================================
+# Tool Registry
+# ================================================================
+
+class ToolRegistry:
+    """Registry of available tools with descriptions and handlers."""
+
+    def __init__(self):
+        self.tools: Dict[str, dict] = {}
+        self._register_defaults()
+
+    def _register_defaults(self):
+        """Register the built-in tool set."""
+
+        self.register("read_file", {
+            "description": "Read a file's contents. Args: path (str), start_line (int, optional), end_line (int, optional)",
+            "examples": [
+                'read_file("inference/codette_server.py")',
+                'read_file("configs/adapter_registry.yaml", 1, 50)',
+            ],
+            "handler": tool_read_file,
+        })
+
+        self.register("list_files", {
+            "description": "List files in a directory. Args: path (str), pattern (str, optional)",
+            "examples": [
+                'list_files("inference/")',
+                'list_files("datasets/", "*.jsonl")',
+            ],
+            "handler": tool_list_files,
+        })
+
+        self.register("search_code", {
+            "description": "Search for a text pattern across files. Args: pattern (str), path (str, optional), file_ext (str, optional)",
+            "examples": [
+                'search_code("phase_coherence")',
+                'search_code("def route", "inference/", ".py")',
+            ],
+            "handler": tool_search_code,
+        })
+
+        self.register("file_info", {
+            "description": "Get file metadata (size, modified time, line count). Args: path (str)",
+            "examples": [
+                'file_info("paper/codette_paper.pdf")',
+            ],
+            "handler": tool_file_info,
+        })
+
+        self.register("run_python", {
+            "description": "Execute a short Python snippet and return output. For calculations, data processing, or quick checks. Args: code (str)",
+            "examples": [
+                'run_python("import math; print(math.pi * 2)")',
+                'run_python("print(sorted([3,1,4,1,5,9]))")',
+            ],
+            "handler": tool_run_python,
+        })
+
+        self.register("project_summary", {
+            "description": "Get an overview of the Codette project structure. No args.",
+            "examples": [
+                'project_summary()',
+            ],
+            "handler": tool_project_summary,
+        })
+
+    def register(self, name: str, spec: dict):
+        self.tools[name] = spec
+
+    def get_descriptions(self) -> str:
+        """Format tool descriptions for injection into system prompt."""
+        lines = ["Available tools (use <tool>name(args)</tool> to call):"]
+        for name, spec in self.tools.items():
+            lines.append(f"\n  {name}: {spec['description']}")
+            for ex in spec.get("examples", []):
+                lines.append(f"    Example: <tool>{ex}</tool>")
+        return "\n".join(lines)
+
+    def execute(self, name: str, args: list, kwargs: dict) -> str:
+        """Execute a tool by name with parsed arguments."""
+        if name not in self.tools:
+            return f"Error: Unknown tool '{name}'. Available: {', '.join(self.tools.keys())}"
+
+        handler = self.tools[name]["handler"]
+        try:
+            result = handler(*args, **kwargs)
+            # Truncate if too long
+            if len(result) > MAX_OUTPUT_LENGTH:
+                result = result[:MAX_OUTPUT_LENGTH] + f"\n... (truncated, {len(result)} chars total)"
+            return result
+        except Exception as e:
+            return f"Error executing {name}: {e}"
+
+
+# ================================================================
+# Tool Call Parser
+# ================================================================
+
+def parse_tool_calls(text: str) -> List[Tuple[str, list, dict]]:
+    """Parse <tool>name(args)</tool> tags from generated text.
+
+    Returns list of (tool_name, positional_args, keyword_args).
+    """
+    pattern = r'<tool>\s*([\w]+)\s*\((.*?)\)\s*</tool>'
+    matches = re.findall(pattern, text, re.DOTALL)
+
+    calls = []
+    for name, args_str in matches:
+        try:
+            # Parse arguments safely using ast.literal_eval
+            args, kwargs = _parse_args(args_str.strip())
+            calls.append((name, args, kwargs))
+        except Exception as e:
+            calls.append((name, [args_str.strip()], {}))
+
+    return calls
+
+
+def _parse_args(args_str: str) -> Tuple[list, dict]:
+    """Safely parse function arguments string."""
+    if not args_str:
+        return [], {}
+
+    # Wrap in a tuple to parse as Python literal
+    try:
+        # Try parsing as a tuple of values
+        parsed = ast.literal_eval(f"({args_str},)")
+        return list(parsed), {}
+    except (ValueError, SyntaxError):
+        # If that fails, treat as a single string argument
+        # Strip quotes if present
+        cleaned = args_str.strip().strip('"').strip("'")
+        return [cleaned], {}
+
+
+def strip_tool_calls(text: str) -> str:
+    """Remove <tool>...</tool> tags from text, leaving the rest."""
+    return re.sub(r'<tool>.*?</tool>', '', text, flags=re.DOTALL).strip()
+
+
+def has_tool_calls(text: str) -> bool:
+    """Check if text contains any tool calls."""
+    return bool(re.search(r'<tool>', text))
+
+
+# ================================================================
+# Path Safety
+# ================================================================
+
+def _resolve_path(path_str: str) -> Optional[Path]:
+    """Resolve a path, ensuring it's within allowed roots."""
+    # Handle relative paths — resolve relative to project root
+    p = Path(path_str)
+    if not p.is_absolute():
+        p = ALLOWED_ROOTS[0] / p
+
+    p = p.resolve()
+
+    # Check against allowed roots
+    for root in ALLOWED_ROOTS:
+        try:
+            p.relative_to(root.resolve())
+            return p
+        except ValueError:
+            continue
+
+    return None  # Not in any allowed root
+
+
+# ================================================================
+# Tool Implementations
+# ================================================================
+
+def tool_read_file(path: str, start_line: int = 1, end_line: int = None) -> str:
+    """Read a file's contents with optional line range."""
+    resolved = _resolve_path(path)
+    if resolved is None:
+        return f"Error: Path '{path}' is outside allowed directories."
+
+    if not resolved.exists():
+        return f"Error: File not found: {path}"
+
+    if not resolved.is_file():
+        return f"Error: '{path}' is a directory, not a file. Use list_files() instead."
+
+    # Check extension
+    if resolved.suffix.lower() not in READABLE_EXTENSIONS:
+        return f"Error: Cannot read {resolved.suffix} files. Supported: {', '.join(sorted(READABLE_EXTENSIONS))}"
+
+    # Check size
+    size = resolved.stat().st_size
+    if size > MAX_FILE_SIZE:
+        return f"Error: File too large ({size:,} bytes). Max: {MAX_FILE_SIZE:,} bytes."
+
+    try:
+        content = resolved.read_text(encoding='utf-8', errors='replace')
+    except Exception as e:
+        return f"Error reading file: {e}"
+
+    lines = content.splitlines()
+    total = len(lines)
+
+    # Apply line range
+    start = max(1, start_line) - 1  # Convert to 0-indexed
+    end = min(end_line or total, start + MAX_LINES, total)
+
+    selected = lines[start:end]
+
+    # Format with line numbers
+    numbered = []
+    for i, line in enumerate(selected, start=start + 1):
+        numbered.append(f"{i:4d} | {line}")
+
+    header = f"File: {path} ({total} lines total)"
+    if start > 0 or end < total:
+        header += f" [showing lines {start+1}-{end}]"
+
+    return header + "\n" + "\n".join(numbered)
+
+
+def tool_list_files(path: str = ".", pattern: str = None) -> str:
+    """List files in a directory with optional glob pattern."""
+    resolved = _resolve_path(path)
+    if resolved is None:
+        return f"Error: Path '{path}' is outside allowed directories."
+
+    if not resolved.exists():
+        return f"Error: Directory not found: {path}"
+
+    if not resolved.is_dir():
+        return f"Error: '{path}' is a file, not a directory. Use read_file() instead."
+
+    try:
+        if pattern:
+            entries = sorted(resolved.glob(pattern))
+        else:
+            entries = sorted(resolved.iterdir())
+
+        result = [f"Directory: {path}"]
+        for entry in entries[:100]:  # Limit to 100 entries
+            rel = entry.relative_to(resolved)
+            if entry.is_dir():
+                result.append(f"  [DIR] {rel}/")
+            else:
+                size = entry.stat().st_size
+                if size >= 1024 * 1024:
+                    size_str = f"{size / 1024 / 1024:.1f}MB"
+                elif size >= 1024:
+                    size_str = f"{size / 1024:.1f}KB"
+                else:
+                    size_str = f"{size}B"
+                result.append(f"  [FILE] {rel} ({size_str})")
+
+        if len(entries) > 100:
+            result.append(f"  ... and {len(entries) - 100} more")
+
+        return "\n".join(result)
+
+    except Exception as e:
+        return f"Error listing directory: {e}"
+
+
+def tool_search_code(pattern: str, path: str = ".", file_ext: str = None) -> str:
+    """Search for a text pattern in files."""
+    resolved = _resolve_path(path)
+    if resolved is None:
+        return f"Error: Path '{path}' is outside allowed directories."
+
+    if not resolved.exists():
+        return f"Error: Path not found: {path}"
+
+    # Determine glob pattern
+    if file_ext:
+        if not file_ext.startswith("."):
+            file_ext = "." + file_ext
+        glob = f"**/*{file_ext}"
+    else:
+        glob = "**/*"
+
+    results = []
+    files_searched = 0
+    matches_found = 0
+
+    try:
+        search_root = resolved if resolved.is_dir() else resolved.parent
+
+        for filepath in search_root.glob(glob):
+            if not filepath.is_file():
+                continue
+            if filepath.suffix.lower() not in READABLE_EXTENSIONS:
+                continue
+            if filepath.stat().st_size > MAX_FILE_SIZE:
+                continue
+
+            # Skip hidden dirs, __pycache__, node_modules, .git
+            parts = filepath.parts
+            if any(p.startswith('.') or p in ('__pycache__', 'node_modules', '.git')
+                   for p in parts):
+                continue
+
+            files_searched += 1
+
+            try:
+                content = filepath.read_text(encoding='utf-8', errors='replace')
+                for line_num, line in enumerate(content.splitlines(), 1):
+                    if pattern.lower() in line.lower():
+                        rel = filepath.relative_to(search_root)
+                        results.append(f"  {rel}:{line_num}: {line.strip()[:120]}")
+                        matches_found += 1
+
+                        if matches_found >= 50:  # Limit results
+                            break
+            except Exception:
+                continue
+
+            if matches_found >= 50:
+                break
+
+    except Exception as e:
+        return f"Error searching: {e}"
+
+    header = f"Search: '{pattern}' in {path} ({matches_found} matches in {files_searched} files)"
+    if not results:
+        return header + "\n  No matches found."
+    return header + "\n" + "\n".join(results)
+
+
+def tool_file_info(path: str) -> str:
+    """Get file metadata."""
+    resolved = _resolve_path(path)
+    if resolved is None:
+        return f"Error: Path '{path}' is outside allowed directories."
+
+    if not resolved.exists():
+        return f"Error: File not found: {path}"
+
+    stat = resolved.stat()
+    import time
+    mtime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(stat.st_mtime))
+
+    info = [
+        f"File: {path}",
+        f"  Size: {stat.st_size:,} bytes ({stat.st_size / 1024:.1f} KB)",
+        f"  Modified: {mtime}",
+        f"  Type: {'directory' if resolved.is_dir() else resolved.suffix or 'no extension'}",
+    ]
+
+    # Line count for text files
+    if resolved.is_file() and resolved.suffix.lower() in READABLE_EXTENSIONS:
+        try:
+            lines = resolved.read_text(encoding='utf-8', errors='replace').count('\n') + 1
+            info.append(f"  Lines: {lines:,}")
+        except Exception:
+            pass
+
+    return "\n".join(info)
+
+
+def tool_run_python(code: str) -> str:
+    """Run a Python snippet safely with timeout."""
+    import sys
+
+    # Basic safety checks
+    dangerous = ['import os', 'import sys', 'subprocess', 'shutil.rmtree',
+                 'os.remove', 'os.unlink', '__import__', 'eval(', 'exec(',
+                 'open(', 'write(', 'pathlib']
+    for d in dangerous:
+        if d in code and 'print' not in code.split(d)[0].split('\n')[-1]:
+            # Allow if it's inside a print statement string
+            if f'"{d}"' not in code and f"'{d}'" not in code:
+                return f"Error: '{d}' is not allowed in run_python for safety. Use read_file/search_code for file operations."
+
+    try:
+        result = subprocess.run(
+            [r"J:\python.exe", "-c", code],
+            capture_output=True,
+            text=True,
+            timeout=PYTHON_TIMEOUT,
+            env={**os.environ, "PYTHONPATH": r"J:\Lib\site-packages"},
+        )
+
+        output = result.stdout
+        if result.stderr:
+            output += "\nSTDERR: " + result.stderr
+
+        if not output.strip():
+            output = "(no output)"
+
+        return output.strip()
+
+    except subprocess.TimeoutExpired:
+        return f"Error: Code execution timed out after {PYTHON_TIMEOUT}s."
+    except Exception as e:
+        return f"Error running code: {e}"
+
+
+def tool_project_summary() -> str:
+    """Generate a quick project structure overview."""
+    root = ALLOWED_ROOTS[0]
+
+    summary = ["Codette Training Lab — Project Structure\n"]
+
+    # Key directories
+    key_dirs = [
+        ("configs/", "Configuration files (adapter registry, pipeline config)"),
+        ("datasets/", "Training data — perspective-tagged JSONL files"),
+        ("dataset_engine/", "Dataset generation pipeline"),
+        ("evaluation/", "Evaluation scripts and benchmarks"),
+        ("inference/", "Local inference server + web UI"),
+        ("paper/", "Academic paper (LaTeX, PDF, BibTeX)"),
+        ("reasoning_forge/", "Core RC+xi engine, spiderweb, cocoon sync"),
+        ("research/", "Research docs, experiments, DreamReweaver"),
+        ("scripts/", "Training and pipeline scripts"),
+        ("adapters/", "GGUF LoRA adapter files for llama.cpp"),
+    ]
+
+    for dirname, desc in key_dirs:
+        dirpath = root / dirname
+        if dirpath.exists():
+            count = sum(1 for _ in dirpath.rglob("*") if _.is_file())
+            summary.append(f"  [DIR] {dirname:<30s} {desc} ({count} files)")
+
+    # Key files
+    summary.append("\nKey Files:")
+    key_files = [
+        "HOWTO.md", "configs/adapter_registry.yaml",
+        "inference/codette_server.py", "inference/codette_orchestrator.py",
+        "reasoning_forge/quantum_spiderweb.py", "reasoning_forge/epistemic_metrics.py",
+        "paper/codette_paper.tex",
+    ]
+    for f in key_files:
+        fp = root / f
+        if fp.exists():
+            size = fp.stat().st_size
+            summary.append(f"  [FILE] {f} ({size / 1024:.1f} KB)")
+
+    return "\n".join(summary)
+
+
+# ================================================================
+# Tool-Augmented System Prompt
+# ================================================================
+
+TOOL_PROMPT_SUFFIX = """
+
+TOOLS: You can read files, search code, and run calculations. When a user asks about code, files, or the project, you MUST use tools to look things up rather than guessing.
+
+Format: <tool>tool_name("arg1", "arg2")</tool>
+
+{tool_descriptions}
+
+RULES:
+1. If the user asks about a file, config, or code: ALWAYS call read_file or search_code FIRST
+2. If the user asks "show me" or "what is": call the relevant tool FIRST, then explain
+3. For general conversation or reasoning: respond normally without tools
+4. Start your response with the tool call on the very first line
+"""
+
+
+def build_tool_system_prompt(base_prompt: str, registry: ToolRegistry) -> str:
+    """Augment a system prompt with tool-use instructions."""
+    return base_prompt + TOOL_PROMPT_SUFFIX.format(
+        tool_descriptions=registry.get_descriptions()
+    )
+
+
+# ================================================================
+# Quick Test
+# ================================================================
+if __name__ == "__main__":
+    print("Testing Codette Tools...\n")
+
+    registry = ToolRegistry()
+    print(registry.get_descriptions())
+
+    print("\n--- Test: read_file ---")
+    print(tool_read_file("configs/adapter_registry.yaml", 1, 10))
+
+    print("\n--- Test: list_files ---")
+    print(tool_list_files("inference/"))
+
+    print("\n--- Test: search_code ---")
+    print(tool_search_code("phase_coherence", "reasoning_forge/", ".py"))
+
+    print("\n--- Test: file_info ---")
+    print(tool_file_info("paper/codette_paper.pdf"))
+
+    print("\n--- Test: run_python ---")
+    print(tool_run_python("print(2 ** 10)"))
+
+    print("\n--- Test: project_summary ---")
+    print(tool_project_summary())
+
+    print("\n--- Test: parse_tool_calls ---")
+    test = 'Let me check that. <tool>read_file("configs/adapter_registry.yaml", 1, 20)</tool> And also <tool>search_code("AEGIS")</tool>'
+    calls = parse_tool_calls(test)
+    for name, args, kwargs in calls:
+        print(f"  Call: {name}({args})")
+
+    print("\nDone!")

inference/init.py

@@ -0,0 +1,7 @@
+from .model_loader import CodetteModelLoader
+from .multi_adapter_engine import CodetteEngine
+
+__all__ = [
+    "CodetteModelLoader",
+    "CodetteEngine",
+]

inference/model_loader.py

@@ -0,0 +1,96 @@
+import torch
+from pathlib import Path
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from peft import PeftModel
+
+
+class CodetteModelLoader:
+
+    def __init__(
+        self,
+        base_model="meta-llama/Llama-3.1-8B-Instruct",
+        adapters=None,
+    ):
+        self.base_model_name = base_model
+        self.adapters = adapters or {}
+        self.model = None
+        self.tokenizer = None
+        self.active_adapter = None
+
+        self._load_base_model()
+
+    def _load_base_model(self):
+
+        quant_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.bfloat16,
+            bnb_4bit_use_double_quant=True,
+        )
+
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            self.base_model_name,
+            trust_remote_code=True
+        )
+
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+
+        base_model = AutoModelForCausalLM.from_pretrained(
+            self.base_model_name,
+            quantization_config=quant_config,
+            device_map="auto",
+            trust_remote_code=True,
+        )
+
+        self.model = base_model
+
+    def load_adapters(self):
+
+        first = True
+
+        for name, path in self.adapters.items():
+
+            path = str(Path(path))
+
+            if first:
+
+                self.model = PeftModel.from_pretrained(
+                    self.model,
+                    path,
+                    adapter_name=name,
+                    is_trainable=False,
+                )
+
+                self.active_adapter = name
+                first = False
+
+            else:
+
+                self.model.load_adapter(
+                    path,
+                    adapter_name=name,
+                )
+
+    def set_active_adapter(self, name):
+
+        if name not in self.model.peft_config:
+            raise ValueError(f"Adapter not loaded: {name}")
+
+        self.model.set_adapter(name)
+        self.active_adapter = name
+
+    def format_messages(self, messages):
+
+        return self.tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True
+        )
+
+    def tokenize(self, prompt):
+
+        return self.tokenizer(
+            prompt,
+            return_tensors="pt"
+        ).to(self.model.device)

inference/multi_adapter_engine.py

@@ -0,0 +1,59 @@
+class CodetteEngine:
+
+    def __init__(self, loader, registry):
+
+        self.loader = loader
+        self.registry = registry
+
+    def generate(self, messages, adapter):
+
+        self.loader.set_active_adapter(adapter)
+
+        prompt = self.loader.format_messages(messages)
+        inputs = self.loader.tokenize(prompt)
+
+        params = self.registry[adapter]["generation"]
+
+        output = self.loader.model.generate(
+            **inputs,
+            max_new_tokens=params.get("max_tokens", 512),
+            temperature=params.get("temperature", 0.7),
+            top_p=params.get("top_p", 0.9),
+            repetition_penalty=params.get("repetition_penalty", 1.1)
+        )
+
+        text = self.loader.tokenizer.decode(
+            output[0],
+            skip_special_tokens=True
+        )
+
+        return text
+
+    def multi_perspective(self, messages, adapters):
+
+        outputs = {}
+
+        for adapter in adapters:
+            outputs[adapter] = self.generate(messages, adapter)
+
+        return self._synthesize(messages, outputs)
+
+    def _synthesize(self, messages, responses):
+
+        combined = "\n\n".join(
+            f"{name.upper()}:\n{text}"
+            for name, text in responses.items()
+        )
+
+        synthesis_messages = messages + [
+            {
+                "role": "system",
+                "content": "Combine the perspectives into a single answer."
+            },
+            {
+                "role": "user",
+                "content": combined
+            }
+        ]
+
+        return self.generate(synthesis_messages, "multi_perspective")

inference/static/app.js

@@ -0,0 +1,870 @@
+/* ============================================================
+   Codette Chat UI — Frontend Logic
+   Pure vanilla JS. Zero dependencies.
+   ============================================================ */
+
+// Adapter color map
+const COLORS = {
+    newton: '#3b82f6', davinci: '#f59e0b', empathy: '#a855f7',
+    philosophy: '#10b981', quantum: '#ef4444', consciousness: '#e2e8f0',
+    multi_perspective: '#f97316', systems_architecture: '#06b6d4',
+    _base: '#94a3b8', auto: '#94a3b8',
+};
+
+const LABELS = {
+    newton: 'N', davinci: 'D', empathy: 'E', philosophy: 'P',
+    quantum: 'Q', consciousness: 'C', multi_perspective: 'M',
+    systems_architecture: 'S',
+};
+
+// State
+let isLoading = false;
+let spiderwebViz = null;
+let serverConnected = true;
+let reconnectTimer = null;
+
+// ── Initialization ──
+document.addEventListener('DOMContentLoaded', () => {
+    initUI();
+    pollStatus();
+    loadSessions();
+    initCoverageDots();
+    initAdapterDots();
+
+    // Initialize spiderweb canvas
+    const canvas = document.getElementById('spiderweb-canvas');
+    if (canvas) {
+        spiderwebViz = new SpiderwebViz(canvas);
+    }
+});
+
+function initUI() {
+    const input = document.getElementById('chat-input');
+    const sendBtn = document.getElementById('send-btn');
+    const micBtn = document.getElementById('mic-btn');
+    const newBtn = document.getElementById('btn-new-chat');
+    const panelBtn = document.getElementById('btn-toggle-panel');
+    const maxAdapters = document.getElementById('max-adapters');
+
+    // Send on Enter (Shift+Enter for newline)
+    input.addEventListener('keydown', (e) => {
+        if (e.key === 'Enter' && !e.shiftKey) {
+            e.preventDefault();
+            sendMessage();
+        }
+    });
+
+    // Auto-resize textarea
+    input.addEventListener('input', () => {
+        input.style.height = 'auto';
+        input.style.height = Math.min(input.scrollHeight, 120) + 'px';
+    });
+
+    sendBtn.addEventListener('click', sendMessage);
+    newBtn.addEventListener('click', newChat);
+
+    const exportBtn = document.getElementById('btn-export');
+    const importBtn = document.getElementById('btn-import');
+    const importFile = document.getElementById('import-file');
+
+    exportBtn.addEventListener('click', exportSession);
+    importBtn.addEventListener('click', () => importFile.click());
+    importFile.addEventListener('change', importSession);
+
+    panelBtn.addEventListener('click', () => {
+        const panel = document.getElementById('side-panel');
+        panel.classList.toggle('collapsed');
+        // Update button label
+        panelBtn.textContent = panel.classList.contains('collapsed') ? 'Cocoon' : 'Close';
+    });
+
+    maxAdapters.addEventListener('input', () => {
+        document.getElementById('max-adapters-value').textContent = maxAdapters.value;
+    });
+
+    // Voice input via Web Speech API
+    initVoice(micBtn);
+
+    // TTS toggle — read responses aloud when enabled
+    const ttsToggle = document.getElementById('tts-toggle');
+    if (ttsToggle) {
+        ttsToggle.addEventListener('change', () => {
+            if (ttsToggle.checked && !window.speechSynthesis) {
+                ttsToggle.checked = false;
+                ttsToggle.parentElement.title = 'Speech synthesis not supported';
+            }
+        });
+    }
+}
+
+// ── Voice Input ──
+let _recognition = null;
+let _isRecording = false;
+
+function initVoice(micBtn) {
+    const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
+    if (!SpeechRecognition) {
+        micBtn.title = 'Voice not supported in this browser';
+        micBtn.style.opacity = '0.3';
+        micBtn.style.cursor = 'not-allowed';
+        return;
+    }
+
+    _recognition = new SpeechRecognition();
+    _recognition.continuous = false;
+    _recognition.interimResults = true;
+    _recognition.lang = 'en-US';
+
+    const input = document.getElementById('chat-input');
+
+    _recognition.onstart = () => {
+        _isRecording = true;
+        micBtn.classList.add('recording');
+        micBtn.title = 'Listening... click to stop';
+    };
+
+    _recognition.onresult = (event) => {
+        let transcript = '';
+        let isFinal = false;
+        for (let i = event.resultIndex; i < event.results.length; i++) {
+            transcript += event.results[i][0].transcript;
+            if (event.results[i].isFinal) isFinal = true;
+        }
+        // Show interim results in the input box
+        input.value = transcript;
+        input.style.height = 'auto';
+        input.style.height = Math.min(input.scrollHeight, 120) + 'px';
+
+        if (isFinal) {
+            stopVoice(micBtn);
+        }
+    };
+
+    _recognition.onerror = (event) => {
+        console.log('Speech recognition error:', event.error);
+        stopVoice(micBtn);
+        if (event.error === 'not-allowed') {
+            micBtn.title = 'Microphone access denied';
+        }
+    };
+
+    _recognition.onend = () => {
+        stopVoice(micBtn);
+    };
+
+    micBtn.addEventListener('click', () => {
+        if (_isRecording) {
+            _recognition.stop();
+            stopVoice(micBtn);
+        } else {
+            try {
+                _recognition.start();
+            } catch (e) {
+                console.log('Speech recognition start error:', e);
+            }
+        }
+    });
+}
+
+function stopVoice(micBtn) {
+    _isRecording = false;
+    micBtn.classList.remove('recording');
+    micBtn.title = 'Voice input';
+}
+
+// ── Status Polling ──
+function pollStatus() {
+    fetch('/api/status')
+        .then(r => r.json())
+        .then(status => {
+            setConnected();
+            updateStatus(status);
+            if (status.state === 'loading') {
+                setTimeout(pollStatus, 2000);
+            } else if (status.state === 'ready') {
+                hideLoadingScreen();
+            } else if (status.state === 'error') {
+                // Model failed to load — show error and dismiss loading screen
+                hideLoadingScreen();
+                updateStatus({ state: 'error', message: status.message || 'Model failed to load' });
+            } else if (status.state === 'idle') {
+                // Model not loaded yet, keep polling
+                setTimeout(pollStatus, 3000);
+            }
+        })
+        .catch(() => {
+            setDisconnected();
+            setTimeout(pollStatus, 5000);
+        });
+}
+
+function setDisconnected() {
+    if (serverConnected) {
+        serverConnected = false;
+        updateStatus({ state: 'error', message: 'Server disconnected' });
+    }
+}
+
+function setConnected() {
+    if (!serverConnected) {
+        serverConnected = true;
+        if (reconnectTimer) {
+            clearInterval(reconnectTimer);
+            reconnectTimer = null;
+        }
+    }
+}
+
+function updateStatus(status) {
+    const dot = document.getElementById('status-dot');
+    const text = document.getElementById('status-text');
+
+    dot.className = 'status-dot ' + (status.state || 'loading');
+    text.textContent = status.message || status.state;
+
+    // Update loading screen
+    const loadingStatus = document.getElementById('loading-status');
+    if (loadingStatus) {
+        loadingStatus.textContent = status.message || 'Loading...';
+    }
+
+    // Update adapter dots if available
+    if (status.adapters) {
+        updateAdapterDots(status.adapters);
+    }
+}
+
+function hideLoadingScreen() {
+    const screen = document.getElementById('loading-screen');
+    if (screen) {
+        screen.classList.add('hidden');
+        setTimeout(() => screen.remove(), 500);
+    }
+}
+
+// ── Adapter Dots ──
+function initAdapterDots() {
+    const container = document.getElementById('adapter-dots');
+    Object.keys(LABELS).forEach(name => {
+        const dot = document.createElement('span');
+        dot.className = 'adapter-dot';
+        dot.style.backgroundColor = COLORS[name];
+        dot.title = name;
+        dot.id = `dot-${name}`;
+        container.appendChild(dot);
+    });
+}
+
+function updateAdapterDots(available) {
+    Object.keys(LABELS).forEach(name => {
+        const dot = document.getElementById(`dot-${name}`);
+        if (dot) {
+            dot.classList.toggle('available', available.includes(name));
+        }
+    });
+}
+
+function setActiveAdapter(name) {
+    // Remove previous active
+    document.querySelectorAll('.adapter-dot').forEach(d => d.classList.remove('active'));
+    // Set new active
+    const dot = document.getElementById(`dot-${name}`);
+    if (dot) dot.classList.add('active');
+
+    // Update CSS accent color
+    const color = COLORS[name] || COLORS._base;
+    document.documentElement.style.setProperty('--accent', color);
+    document.documentElement.style.setProperty('--accent-glow', color + '25');
+}
+
+// ── Coverage Dots ──
+function initCoverageDots() {
+    const container = document.getElementById('coverage-dots');
+    Object.entries(LABELS).forEach(([name, label]) => {
+        const dot = document.createElement('span');
+        dot.className = 'coverage-dot';
+        dot.style.color = COLORS[name];
+        dot.textContent = label;
+        dot.title = name;
+        dot.id = `cov-${name}`;
+        container.appendChild(dot);
+    });
+}
+
+function updateCoverage(usage) {
+    Object.keys(LABELS).forEach(name => {
+        const dot = document.getElementById(`cov-${name}`);
+        if (dot) {
+            dot.classList.toggle('active', (usage[name] || 0) > 0);
+        }
+    });
+}
+
+// ── Chat ──
+function sendMessage() {
+    const input = document.getElementById('chat-input');
+    const query = input.value.trim();
+    if (!query || isLoading) return;
+
+    // Hide welcome
+    const welcome = document.getElementById('welcome');
+    if (welcome) welcome.style.display = 'none';
+
+    // Add user message
+    addMessage('user', query);
+
+    // Clear input
+    input.value = '';
+    input.style.height = 'auto';
+
+    // Get settings
+    const adapter = document.getElementById('adapter-select').value;
+    const maxAdapters = parseInt(document.getElementById('max-adapters').value);
+
+    // Show thinking
+    const thinkingEl = showThinking(adapter);
+    isLoading = true;
+    document.getElementById('send-btn').disabled = true;
+
+    // Send request with timeout (20 min for multi-perspective CPU inference)
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 1200000);
+
+    fetch('/api/chat', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            query: query,
+            adapter: adapter === 'auto' ? null : adapter,
+            max_adapters: maxAdapters,
+        }),
+        signal: controller.signal,
+    })
+    .then(r => r.json())
+    .then(data => {
+        clearTimeout(timeoutId);
+        thinkingEl.remove();
+
+        if (data.error) {
+            addMessage('error', data.error);
+            return;
+        }
+
+        // Add assistant message
+        const adapterUsed = data.adapter || '_base';
+        setActiveAdapter(adapterUsed);
+
+        addMessage('assistant', data.response, {
+            adapter: adapterUsed,
+            confidence: data.confidence,
+            reasoning: data.reasoning,
+            tokens: data.tokens,
+            time: data.time,
+            perspectives: data.perspectives,
+            multi_perspective: data.multi_perspective,
+            tools_used: data.tools_used,
+        });
+
+        // Speak response if TTS is enabled
+        const ttsOn = document.getElementById('tts-toggle');
+        if (ttsOn && ttsOn.checked && window.speechSynthesis) {
+            const utter = new SpeechSynthesisUtterance(data.response);
+            utter.rate = 1.0;
+            utter.pitch = 1.0;
+            window.speechSynthesis.speak(utter);
+        }
+
+        // Update cocoon state
+        if (data.cocoon) {
+            updateCocoonUI(data.cocoon);
+        }
+
+        // Update epistemic metrics
+        if (data.epistemic) {
+            updateEpistemicUI(data.epistemic);
+        }
+    })
+    .catch(err => {
+        clearTimeout(timeoutId);
+        thinkingEl.remove();
+        if (err.name === 'AbortError') {
+            addMessage('error', 'Request timed out. The model may be processing a complex query — try again or reduce perspectives.');
+        } else if (err.message === 'Failed to fetch' || err.name === 'TypeError') {
+            setDisconnected();
+            addMessage('error', 'Server disconnected. Attempting to reconnect...');
+            startReconnectPolling();
+        } else {
+            addMessage('error', `Request failed: ${err.message}`);
+        }
+    })
+    .finally(() => {
+        isLoading = false;
+        document.getElementById('send-btn').disabled = false;
+        document.getElementById('chat-input').focus();
+    });
+}
+
+function askQuestion(query) {
+    document.getElementById('chat-input').value = query;
+    sendMessage();
+}
+
+function addMessage(role, content, meta = {}) {
+    const area = document.getElementById('chat-area');
+    const msg = document.createElement('div');
+    msg.className = `message message-${role}`;
+
+    if (role === 'user') {
+        msg.innerHTML = `<div class="bubble"><div class="message-text">${escapeHtml(content)}</div></div>`;
+    } else if (role === 'assistant') {
+        const adapter = meta.adapter || '_base';
+        const color = COLORS[adapter] || COLORS._base;
+        const conf = meta.confidence || 0;
+        const tps = meta.tokens && meta.time ? (meta.tokens / meta.time).toFixed(1) : '?';
+
+        let html = `<div class="bubble" style="border-left-color:${color}">`;
+        html += `<div class="message-header">`;
+        html += `<span class="adapter-badge" style="color:${color}">${adapter}</span>`;
+        html += `<div class="confidence-bar"><div class="confidence-fill" style="width:${conf*100}%;background:${color}"></div></div>`;
+        html += `<span>${(conf*100).toFixed(0)}%</span>`;
+        html += `</div>`;
+        html += `<div class="message-text">${renderMarkdown(content)}</div>`;
+        html += `<div class="message-meta">${meta.tokens || '?'} tokens | ${tps} tok/s | ${(meta.time||0).toFixed(1)}s</div>`;
+
+        // Tool usage indicator
+        if (meta.tools_used && meta.tools_used.length > 0) {
+            const toolNames = meta.tools_used.map(t => t.tool).join(', ');
+            html += `<div class="tools-badge">🔧 Tools: ${toolNames}</div>`;
+        }
+
+        // Multi-perspective expandable
+        if (meta.perspectives && Object.keys(meta.perspectives).length > 1) {
+            const perspId = 'persp-' + Date.now();
+            html += `<button class="perspectives-toggle" onclick="togglePerspectives('${perspId}')">`;
+            html += `Show ${Object.keys(meta.perspectives).length} perspectives</button>`;
+            html += `<div class="perspectives-panel" id="${perspId}">`;
+            for (const [name, text] of Object.entries(meta.perspectives)) {
+                const pc = COLORS[name] || COLORS._base;
+                html += `<div class="perspective-card" style="border-left-color:${pc}">`;
+                html += `<div class="perspective-card-header" style="color:${pc}">${name}</div>`;
+                html += `<div>${renderMarkdown(text)}</div></div>`;
+            }
+            html += `</div>`;
+        }
+
+        html += `</div>`;
+        msg.innerHTML = html;
+    } else if (role === 'error') {
+        msg.innerHTML = `<div class="bubble" style="border-left-color:var(--quantum)">
+            <div class="message-text" style="color:var(--quantum)">${escapeHtml(content)}</div></div>`;
+    }
+
+    area.appendChild(msg);
+    area.scrollTop = area.scrollHeight;
+}
+
+function showThinking(adapter) {
+    const area = document.getElementById('chat-area');
+    const el = document.createElement('div');
+    el.className = 'thinking';
+    el.innerHTML = `
+        <div class="thinking-dots"><span></span><span></span><span></span></div>
+        <span>Codette is thinking${adapter && adapter !== 'auto' ? ` (${adapter})` : ''}...</span>
+    `;
+    area.appendChild(el);
+    area.scrollTop = area.scrollHeight;
+    return el;
+}
+
+function togglePerspectives(id) {
+    document.getElementById(id).classList.toggle('open');
+}
+
+// ── Cocoon UI Updates ──
+function updateCocoonUI(state) {
+    // Metrics
+    const metrics = state.metrics || {};
+    const coherence = metrics.current_coherence || 0;
+    const tension = metrics.current_tension || 0;
+
+    document.getElementById('metric-coherence').textContent = coherence.toFixed(4);
+    document.getElementById('bar-coherence').style.width = (coherence * 100) + '%';
+
+    document.getElementById('metric-tension').textContent = tension.toFixed(4);
+    document.getElementById('bar-tension').style.width = Math.min(tension * 100, 100) + '%';
+
+    document.getElementById('cocoon-attractors').textContent = metrics.attractor_count || 0;
+    document.getElementById('cocoon-glyphs').textContent = metrics.glyph_count || 0;
+
+    // Cocoon status
+    const cocoon = state.cocoon || {};
+    document.getElementById('cocoon-encryption').textContent =
+        cocoon.has_sync ? 'Active' : 'Available';
+
+    // AEGIS eta feeds the main eta metric when available
+    if (state.aegis && state.aegis.eta !== undefined) {
+        document.getElementById('metric-eta').textContent = state.aegis.eta.toFixed(4);
+    }
+
+    // Coverage
+    updateCoverage(state.perspective_usage || {});
+
+    // Spiderweb
+    if (spiderwebViz && state.spiderweb) {
+        spiderwebViz.update(state.spiderweb);
+    }
+
+    // New subsystem panels (AEGIS, Nexus, Memory, Resonance, Guardian)
+    updateSubsystemUI(state);
+}
+
+function updateEpistemicUI(epistemic) {
+    if (epistemic.ensemble_coherence !== undefined) {
+        const val = epistemic.ensemble_coherence;
+        document.getElementById('metric-coherence').textContent = val.toFixed(4);
+        document.getElementById('bar-coherence').style.width = (val * 100) + '%';
+    }
+    if (epistemic.tension_magnitude !== undefined) {
+        const val = epistemic.tension_magnitude;
+        document.getElementById('metric-tension').textContent = val.toFixed(4);
+        document.getElementById('bar-tension').style.width = Math.min(val * 100, 100) + '%';
+    }
+    // Update ethical alignment if available
+    if (epistemic.ethical_alignment !== undefined) {
+        document.getElementById('metric-eta').textContent =
+            epistemic.ethical_alignment.toFixed(3);
+    } else if (epistemic.mean_coherence !== undefined) {
+        // Fall back: derive eta from mean coherence as a proxy
+        document.getElementById('metric-eta').textContent =
+            epistemic.mean_coherence.toFixed(3);
+    }
+}
+
+// ── Session Management ──
+function newChat() {
+    fetch('/api/session/new', { method: 'POST' })
+        .then(r => r.json())
+        .then(() => {
+            // Clear chat
+            const area = document.getElementById('chat-area');
+            area.innerHTML = '';
+            // Show welcome with starter cards
+            const welcome = document.createElement('div');
+            welcome.className = 'welcome';
+            welcome.id = 'welcome';
+            welcome.innerHTML = `
+                <h2>What would you like to explore?</h2>
+                <p>Codette routes your question to the best reasoning perspective automatically.</p>
+                <div class="welcome-grid">
+                    <div class="welcome-card" onclick="askQuestion('Explain why objects fall to the ground')">
+                        <div class="welcome-card-title" style="color:var(--newton)">Newton</div>
+                        <div class="welcome-card-desc">Explain why objects fall to the ground</div>
+                    </div>
+                    <div class="welcome-card" onclick="askQuestion('Design a creative solution for sustainable cities')">
+                        <div class="welcome-card-title" style="color:var(--davinci)">DaVinci</div>
+                        <div class="welcome-card-desc">Design a creative solution for sustainable cities</div>
+                    </div>
+                    <div class="welcome-card" onclick="askQuestion('How do I cope with feeling overwhelmed?')">
+                        <div class="welcome-card-title" style="color:var(--empathy)">Empathy</div>
+                        <div class="welcome-card-desc">How do I cope with feeling overwhelmed?</div>
+                    </div>
+                    <div class="welcome-card" onclick="askQuestion('What is consciousness and can AI have it?')">
+                        <div class="welcome-card-title" style="color:var(--consciousness)">Consciousness</div>
+                        <div class="welcome-card-desc">What is consciousness and can AI have it?</div>
+                    </div>
+                </div>
+            `;
+            area.appendChild(welcome);
+            // Reset metrics
+            document.getElementById('metric-coherence').textContent = '0.00';
+            document.getElementById('metric-tension').textContent = '0.00';
+            document.getElementById('metric-eta').textContent = '--';
+            document.getElementById('bar-coherence').style.width = '0%';
+            document.getElementById('bar-tension').style.width = '0%';
+            document.getElementById('cocoon-attractors').textContent = '0';
+            document.getElementById('cocoon-glyphs').textContent = '0';
+            // Reset subsystem panels
+            ['section-aegis','section-nexus','section-resonance','section-memory','section-guardian'].forEach(id => {
+                const el = document.getElementById(id);
+                if (el) el.style.display = 'none';
+            });
+            // Reset spiderweb
+            if (spiderwebViz) {
+                spiderwebViz._initDefaultState();
+                spiderwebViz.coherence = 0;
+                spiderwebViz.attractors = [];
+            }
+            loadSessions();
+        });
+}
+
+function loadSessions() {
+    fetch('/api/sessions')
+        .then(r => r.json())
+        .then(data => {
+            const list = document.getElementById('session-list');
+            const sessions = data.sessions || [];
+            document.getElementById('cocoon-sessions').textContent = sessions.length;
+
+            list.innerHTML = sessions.map(s => `
+                <div class="session-item" onclick="loadSession('${s.session_id}')"
+                     title="${s.title}">
+                    ${s.title || 'Untitled'}
+                </div>
+            `).join('');
+        })
+        .catch(() => {});
+}
+
+function loadSession(sessionId) {
+    fetch('/api/session/load', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ session_id: sessionId }),
+    })
+    .then(r => r.json())
+    .then(data => {
+        if (data.error) return;
+
+        // Clear and rebuild chat
+        const area = document.getElementById('chat-area');
+        area.innerHTML = '';
+
+        (data.messages || []).forEach(msg => {
+            addMessage(msg.role, msg.content, msg.metadata || {});
+        });
+
+        if (data.state) {
+            updateCocoonUI(data.state);
+        }
+    })
+    .catch(err => {
+        console.log('Failed to load session:', err);
+    });
+}
+
+// ── Session Export/Import ──
+function exportSession() {
+    fetch('/api/session/export', { method: 'POST' })
+        .then(r => {
+            if (!r.ok) throw new Error('Export failed');
+            const disposition = r.headers.get('Content-Disposition') || '';
+            const match = disposition.match(/filename="(.+)"/);
+            const filename = match ? match[1] : 'codette_session.json';
+            return r.blob().then(blob => ({ blob, filename }));
+        })
+        .then(({ blob, filename }) => {
+            const url = URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = filename;
+            a.click();
+            URL.revokeObjectURL(url);
+        })
+        .catch(err => {
+            console.log('Export failed:', err);
+        });
+}
+
+function importSession(event) {
+    const file = event.target.files[0];
+    if (!file) return;
+
+    const reader = new FileReader();
+    reader.onload = (e) => {
+        try {
+            const data = JSON.parse(e.target.result);
+            fetch('/api/session/import', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(data),
+            })
+            .then(r => r.json())
+            .then(result => {
+                if (result.error) {
+                    addMessage('error', `Import failed: ${result.error}`);
+                    return;
+                }
+                // Rebuild chat from imported session
+                const area = document.getElementById('chat-area');
+                area.innerHTML = '';
+                (result.messages || []).forEach(msg => {
+                    addMessage(msg.role, msg.content, msg.metadata || {});
+                });
+                if (result.state) {
+                    updateCocoonUI(result.state);
+                }
+                loadSessions();
+            })
+            .catch(err => {
+                addMessage('error', `Import failed: ${err.message}`);
+            });
+        } catch (parseErr) {
+            addMessage('error', 'Invalid JSON file');
+        }
+    };
+    reader.readAsText(file);
+    // Reset file input so same file can be imported again
+    event.target.value = '';
+}
+
+// ── Reconnection ──
+function startReconnectPolling() {
+    if (reconnectTimer) return; // Already polling
+    reconnectTimer = setInterval(() => {
+        fetch('/api/status')
+            .then(r => r.json())
+            .then(status => {
+                setConnected();
+                updateStatus(status);
+                addMessage('error', 'Server reconnected!');
+            })
+            .catch(() => {
+                // Still disconnected, keep polling
+            });
+    }, 5000);
+}
+
+// ── Subsystem UI Updates ──
+function updateSubsystemUI(state) {
+    updateAegisUI(state.aegis);
+    updateNexusUI(state.nexus);
+    updateResonanceUI(state.resonance);
+    updateMemoryUI(state.memory);
+    updateGuardianUI(state.guardian);
+}
+
+function updateAegisUI(aegis) {
+    const section = document.getElementById('section-aegis');
+    if (!aegis) { section.style.display = 'none'; return; }
+    section.style.display = '';
+
+    const eta = aegis.eta || 0;
+    document.getElementById('aegis-eta').textContent = eta.toFixed(4);
+    document.getElementById('bar-aegis-eta').style.width = (eta * 100) + '%';
+    document.getElementById('aegis-evals').textContent = aegis.total_evaluations || 0;
+    document.getElementById('aegis-vetoes').textContent = aegis.veto_count || 0;
+
+    const trendEl = document.getElementById('aegis-trend');
+    const trend = aegis.alignment_trend || '--';
+    trendEl.textContent = trend;
+    trendEl.className = 'metric-value';
+    if (trend === 'improving') trendEl.classList.add('trend-improving');
+    else if (trend === 'declining') trendEl.classList.add('trend-declining');
+    else if (trend === 'stable') trendEl.classList.add('trend-stable');
+}
+
+function updateNexusUI(nexus) {
+    const section = document.getElementById('section-nexus');
+    if (!nexus) { section.style.display = 'none'; return; }
+    section.style.display = '';
+
+    document.getElementById('nexus-processed').textContent = nexus.total_processed || 0;
+    document.getElementById('nexus-interventions').textContent = nexus.interventions || 0;
+    const rate = (nexus.intervention_rate || 0) * 100;
+    document.getElementById('nexus-rate').textContent = rate.toFixed(1) + '%';
+
+    // Risk dots for recent signals
+    const risksEl = document.getElementById('nexus-risks');
+    const risks = nexus.recent_risks || [];
+    risksEl.innerHTML = risks.map(r =>
+        `<span class="risk-dot ${r}" title="${r} risk"></span>`
+    ).join('');
+}
+
+function updateResonanceUI(resonance) {
+    const section = document.getElementById('section-resonance');
+    if (!resonance) { section.style.display = 'none'; return; }
+    section.style.display = '';
+
+    const psi = resonance.psi_r || 0;
+    document.getElementById('resonance-psi').textContent = psi.toFixed(4);
+    // Normalize psi_r to 0-100% bar (clamp between -2 and 2)
+    const psiNorm = Math.min(100, Math.max(0, (psi + 2) / 4 * 100));
+    document.getElementById('bar-resonance-psi').style.width = psiNorm + '%';
+
+    document.getElementById('resonance-quality').textContent =
+        (resonance.resonance_quality || 0).toFixed(4);
+    document.getElementById('resonance-convergence').textContent =
+        (resonance.convergence_rate || 0).toFixed(4);
+    document.getElementById('resonance-stability').textContent =
+        resonance.stability || '--';
+
+    const peakEl = document.getElementById('resonance-peak');
+    const atPeak = resonance.at_peak || false;
+    peakEl.textContent = atPeak ? 'ACTIVE' : 'dormant';
+    peakEl.className = 'metric-value' + (atPeak ? ' peak-active' : '');
+}
+
+function updateMemoryUI(memory) {
+    const section = document.getElementById('section-memory');
+    if (!memory) { section.style.display = 'none'; return; }
+    section.style.display = '';
+
+    document.getElementById('memory-count').textContent = memory.total_memories || 0;
+
+    // Emotional profile tags
+    const emotionsEl = document.getElementById('memory-emotions');
+    const profile = memory.emotional_profile || {};
+    const sorted = Object.entries(profile).sort((a, b) => b[1] - a[1]);
+    emotionsEl.innerHTML = sorted.slice(0, 8).map(([emotion, count]) =>
+        `<span class="emotion-tag${count > 0 ? ' active' : ''}" title="${count} memories">${emotion} ${count}</span>`
+    ).join('');
+}
+
+function updateGuardianUI(guardian) {
+    const section = document.getElementById('section-guardian');
+    if (!guardian) { section.style.display = 'none'; return; }
+    section.style.display = '';
+
+    const ethics = guardian.ethics || {};
+    document.getElementById('guardian-ethics').textContent =
+        (ethics.ethical_score !== undefined) ? ethics.ethical_score.toFixed(4) : '--';
+    const trust = guardian.trust || {};
+    document.getElementById('guardian-trust').textContent =
+        trust.total_interactions || 0;
+}
+
+// ── Utilities ──
+function escapeHtml(text) {
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+}
+
+function renderMarkdown(text) {
+    // Lightweight markdown renderer — no dependencies
+    let html = escapeHtml(text);
+
+    // Code blocks: ```lang\n...\n```
+    html = html.replace(/```(\w*)\n([\s\S]*?)```/g,
+        '<pre class="code-block"><code>$2</code></pre>');
+
+    // Inline code: `code`
+    html = html.replace(/`([^`\n]+)`/g, '<code class="inline-code">$1</code>');
+
+    // Bold: **text** or __text__
+    html = html.replace(/\*\*([^*\n]+?)\*\*/g, '<strong>$1</strong>');
+    html = html.replace(/__([^_\n]+?)__/g, '<strong>$1</strong>');
+
+    // Headers: ### text (on its own line) — before bullets to avoid conflict
+    html = html.replace(/^### (.+)$/gm, '<div class="md-h3">$1</div>');
+    html = html.replace(/^## (.+)$/gm, '<div class="md-h2">$1</div>');
+    html = html.replace(/^# (.+)$/gm, '<div class="md-h1">$1</div>');
+
+    // Bullet lists: - item or * item — before italic to prevent * conflicts
+    html = html.replace(/^[\-\*] (.+)$/gm, '<div class="md-li">$1</div>');
+
+    // Numbered lists: 1. item
+    html = html.replace(/^\d+\. (.+)$/gm, '<div class="md-li md-oli">$1</div>');
+
+    // Italic: *text* or _text_ — AFTER bullets, restricted to single line
+    html = html.replace(/(?<!\w)\*([^*\n]+?)\*(?!\w)/g, '<em>$1</em>');
+    html = html.replace(/(?<!\w)_([^_\n]+?)_(?!\w)/g, '<em>$1</em>');
+
+    // Line breaks (preserve double newlines as paragraph breaks)
+    html = html.replace(/\n\n/g, '<br><br>');
+    html = html.replace(/\n/g, '<br>');
+
+    return html;
+}

inference/static/index.html

@@ -0,0 +1,281 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Codette</title>
+    <link rel="stylesheet" href="style.css">
+</head>
+<body>
+
+<!-- Loading Screen -->
+<div class="loading-screen" id="loading-screen">
+    <div class="loading-title">Codette</div>
+    <div class="loading-status" id="loading-status">Initializing...</div>
+    <div class="loading-bar"><div class="loading-bar-fill"></div></div>
+</div>
+
+<!-- Main App -->
+<div class="app">
+    <!-- Main Chat Panel -->
+    <div class="main-panel">
+        <!-- Header -->
+        <div class="header">
+            <div class="header-left">
+                <span class="logo" id="logo">Codette</span>
+                <div class="adapter-dots" id="adapter-dots"></div>
+            </div>
+            <div class="header-right">
+                <button class="header-btn" id="btn-new-chat" title="New conversation">+ New</button>
+                <button class="header-btn" id="btn-export" title="Export session">Export</button>
+                <button class="header-btn" id="btn-import" title="Import session">Import</button>
+                <input type="file" id="import-file" accept=".json" style="display:none">
+                <button class="header-btn" id="btn-toggle-panel" title="Toggle side panel">Cocoon</button>
+            </div>
+        </div>
+
+        <!-- Chat Messages -->
+        <div class="chat-area" id="chat-area">
+            <div class="welcome" id="welcome">
+                <h2>What would you like to explore?</h2>
+                <p>Codette v2.0 with Phase 6: Multi-perspective reasoning with controlled debate, semantic tension analysis, and adaptive stability.</p>
+                <div style="font-size:0.9em; color:#666; margin-bottom:16px; padding:10px; background:#f5f5f5; border-radius:4px;">
+                    <strong>What's New:</strong> Domain-aware agent routing • Semantic conflict detection • Real-time coherence monitoring • Experience-weighted reasoning
+                </div>
+                <div class="welcome-grid">
+                    <div class="welcome-card" onclick="askQuestion('What is the speed of light and why does it matter?')">
+                        <div class="welcome-card-title" style="color:var(--newton)">Physics</div>
+                        <div class="welcome-card-desc">What is the speed of light and why does it matter?</div>
+                    </div>
+                    <div class="welcome-card" onclick="askQuestion('How should we balance accuracy and explainability in AI systems?')">
+                        <div class="welcome-card-title" style="color:var(--philosophy)">Ethics</div>
+                        <div class="welcome-card-desc">How should we balance accuracy and explainability in AI systems?</div>
+                    </div>
+                    <div class="welcome-card" onclick="askQuestion('What are the hallmarks of a truly creative solution?')">
+                        <div class="welcome-card-title" style="color:var(--davinci)">Creativity</div>
+                        <div class="welcome-card-desc">What are the hallmarks of a truly creative solution?</div>
+                    </div>
+                    <div class="welcome-card" onclick="askQuestion('What would it mean for a machine to genuinely understand?')">
+                        <div class="welcome-card-title" style="color:var(--consciousness)">Consciousness</div>
+                        <div class="welcome-card-desc">What would it mean for a machine to genuinely understand?</div>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Controls Row -->
+        <div class="controls">
+            <div class="control-group">
+                <label>Adapter:</label>
+                <select id="adapter-select">
+                    <option value="auto">Auto</option>
+                    <option value="newton">Newton</option>
+                    <option value="davinci">DaVinci</option>
+                    <option value="empathy">Empathy</option>
+                    <option value="philosophy">Philosophy</option>
+                    <option value="quantum">Quantum</option>
+                    <option value="consciousness">Consciousness</option>
+                    <option value="multi_perspective">Multi-Perspective</option>
+                    <option value="systems_architecture">Systems</option>
+                </select>
+            </div>
+            <div class="control-group">
+                <label>Perspectives:</label>
+                <input type="range" id="max-adapters" min="1" max="3" value="2" style="width:60px">
+                <span id="max-adapters-value">2</span>
+            </div>
+            <div class="control-group" style="margin-left:auto">
+                <label>
+                    <input type="checkbox" id="tts-toggle"> Voice
+                </label>
+            </div>
+        </div>
+
+        <!-- Input Area -->
+        <div class="input-area">
+            <div class="input-row">
+                <button class="mic-btn" id="mic-btn" title="Voice input">&#127908;</button>
+                <div class="input-wrapper">
+                    <textarea id="chat-input" placeholder="Ask Codette something..." rows="1"></textarea>
+                </div>
+                <button class="send-btn" id="send-btn" title="Send">&#9654;</button>
+            </div>
+        </div>
+
+        <!-- Status Bar -->
+        <div class="status-bar">
+            <div class="status-indicator">
+                <span class="status-dot" id="status-dot"></span>
+                <span id="status-text">Initializing...</span>
+            </div>
+            <div id="status-right"></div>
+        </div>
+    </div>
+
+    <!-- Side Panel (Cocoon Dashboard) -->
+    <div class="side-panel" id="side-panel">
+        <!-- Spiderweb Visualization -->
+        <div class="side-section">
+            <div class="side-section-title">Agent Network</div>
+            <canvas id="spiderweb-canvas"></canvas>
+        </div>
+
+        <!-- Metrics -->
+        <div class="side-section">
+            <div class="side-section-title">Cocoon Metrics</div>
+            <div class="metric-row">
+                <span class="metric-label">&#915; Phase Coherence</span>
+                <span class="metric-value" id="metric-coherence">0.00</span>
+            </div>
+            <div class="metric-bar">
+                <div class="metric-bar-fill" id="bar-coherence"
+                     style="width:0%;background:var(--philosophy)"></div>
+            </div>
+            <div class="metric-row" style="margin-top:10px">
+                <span class="metric-label">&#958; Epistemic Tension</span>
+                <span class="metric-value" id="metric-tension">0.00</span>
+            </div>
+            <div class="metric-bar">
+                <div class="metric-bar-fill" id="bar-tension"
+                     style="width:0%;background:var(--quantum)"></div>
+            </div>
+            <div class="metric-row" style="margin-top:10px">
+                <span class="metric-label">&#951; Ethical Alignment</span>
+                <span class="metric-value" id="metric-eta">--</span>
+            </div>
+        </div>
+
+        <!-- Perspective Coverage -->
+        <div class="side-section">
+            <div class="side-section-title">Perspective Coverage</div>
+            <div class="coverage-dots" id="coverage-dots"></div>
+        </div>
+
+        <!-- Cocoon Status -->
+        <div class="side-section">
+            <div class="side-section-title">Cocoon Status</div>
+            <div class="metric-row">
+                <span class="metric-label">&#128274; Encryption</span>
+                <span class="metric-value" id="cocoon-encryption">--</span>
+            </div>
+            <div class="metric-row">
+                <span class="metric-label">&#128376; Attractors</span>
+                <span class="metric-value" id="cocoon-attractors">0</span>
+            </div>
+            <div class="metric-row">
+                <span class="metric-label">&#128200; Glyphs</span>
+                <span class="metric-value" id="cocoon-glyphs">0</span>
+            </div>
+            <div class="metric-row">
+                <span class="metric-label">&#128190; Sessions</span>
+                <span class="metric-value" id="cocoon-sessions">0</span>
+            </div>
+        </div>
+
+        <!-- AEGIS Ethical Alignment -->
+        <div class="side-section" id="section-aegis" style="display:none">
+            <div class="side-section-title">AEGIS Ethics</div>
+            <div class="metric-row">
+                <span class="metric-label">&#951; Alignment</span>
+                <span class="metric-value" id="aegis-eta">--</span>
+            </div>
+            <div class="metric-bar">
+                <div class="metric-bar-fill" id="bar-aegis-eta"
+                     style="width:0%;background:var(--philosophy)"></div>
+            </div>
+            <div class="metric-row" style="margin-top:8px">
+                <span class="metric-label">Trend</span>
+                <span class="metric-value" id="aegis-trend">--</span>
+            </div>
+            <div class="metric-row">
+                <span class="metric-label">Evaluations</span>
+                <span class="metric-value" id="aegis-evals">0</span>
+            </div>
+            <div class="metric-row">
+                <span class="metric-label">Vetoes</span>
+                <span class="metric-value" id="aegis-vetoes">0</span>
+            </div>
+        </div>
+
+        <!-- Nexus Signal Intelligence -->
+        <div class="side-section" id="section-nexus" style="display:none">
+            <div class="side-section-title">Nexus Signals</div>
+            <div class="metric-row">
+                <span class="metric-label">Processed</span>
+                <span class="metric-value" id="nexus-processed">0</span>
+            </div>
+            <div class="metric-row">
+                <span class="metric-label">Interventions</span>
+                <span class="metric-value" id="nexus-interventions">0</span>
+            </div>
+            <div class="metric-row">
+                <span class="metric-label">Rate</span>
+                <span class="metric-value" id="nexus-rate">0%</span>
+            </div>
+            <div class="nexus-risk-dots" id="nexus-risks"></div>
+        </div>
+
+        <!-- Resonant Continuity -->
+        <div class="side-section" id="section-resonance" style="display:none">
+            <div class="side-section-title">Resonance &#936;<sub>r</sub></div>
+            <div class="metric-row">
+                <span class="metric-label">&#936;<sub>r</sub> Wavefunction</span>
+                <span class="metric-value" id="resonance-psi">--</span>
+            </div>
+            <div class="metric-bar">
+                <div class="metric-bar-fill" id="bar-resonance-psi"
+                     style="width:0%;background:var(--empathy)"></div>
+            </div>
+            <div class="metric-row" style="margin-top:8px">
+                <span class="metric-label">Quality</span>
+                <span class="metric-value" id="resonance-quality">--</span>
+            </div>
+            <div class="metric-row">
+                <span class="metric-label">Convergence</span>
+                <span class="metric-value" id="resonance-convergence">--</span>
+            </div>
+            <div class="metric-row">
+                <span class="metric-label">Stability</span>
+                <span class="metric-value" id="resonance-stability">--</span>
+            </div>
+            <div class="metric-row">
+                <span class="metric-label" id="resonance-peak-label">Peak</span>
+                <span class="metric-value" id="resonance-peak">--</span>
+            </div>
+        </div>
+
+        <!-- Living Memory -->
+        <div class="side-section" id="section-memory" style="display:none">
+            <div class="side-section-title">Living Memory</div>
+            <div class="metric-row">
+                <span class="metric-label">Cocoons</span>
+                <span class="metric-value" id="memory-count">0</span>
+            </div>
+            <div class="memory-emotions" id="memory-emotions"></div>
+        </div>
+
+        <!-- Guardian -->
+        <div class="side-section" id="section-guardian" style="display:none">
+            <div class="side-section-title">Guardian</div>
+            <div class="metric-row">
+                <span class="metric-label">Ethics Score</span>
+                <span class="metric-value" id="guardian-ethics">--</span>
+            </div>
+            <div class="metric-row">
+                <span class="metric-label">Trust Interactions</span>
+                <span class="metric-value" id="guardian-trust">0</span>
+            </div>
+        </div>
+
+        <!-- Recent Sessions -->
+        <div class="side-section" style="flex:1;overflow-y:auto">
+            <div class="side-section-title">Recent Sessions</div>
+            <div id="session-list"></div>
+        </div>
+    </div>
+</div>
+
+<script src="spiderweb.js"></script>
+<script src="app.js"></script>
+</body>
+</html>

inference/static/spiderweb.js

@@ -0,0 +1,289 @@
+/* ============================================================
+   Spiderweb Visualization — Canvas-based Agent Network
+   Shows the QuantumSpiderweb as an animated node graph.
+   Zero dependencies. Pure Canvas API.
+
+   Always visually alive: ambient breathing, orbital drift,
+   dim connections at rest, full glow when agents are active.
+   ============================================================ */
+
+class SpiderwebViz {
+    constructor(canvas) {
+        this.canvas = canvas;
+        this.ctx = canvas.getContext('2d');
+        this.nodes = {};
+        this.attractors = [];
+        this.coherence = 0;
+        this.animFrame = null;
+        this.time = 0;
+
+        // Agent positions (circular layout)
+        this.agents = [
+            'newton', 'davinci', 'empathy', 'philosophy',
+            'quantum', 'consciousness', 'multi_perspective', 'systems_architecture'
+        ];
+
+        this.colors = {
+            newton: '#3b82f6', davinci: '#f59e0b', empathy: '#a855f7',
+            philosophy: '#10b981', quantum: '#ef4444', consciousness: '#e2e8f0',
+            multi_perspective: '#f97316', systems_architecture: '#06b6d4',
+        };
+
+        this.labels = {
+            newton: 'N', davinci: 'D', empathy: 'E', philosophy: 'P',
+            quantum: 'Q', consciousness: 'C', multi_perspective: 'M',
+            systems_architecture: 'S',
+        };
+
+        // Initialize with default state
+        this._initDefaultState();
+        this._resize();
+        this._animate();
+
+        // Handle resize
+        new ResizeObserver(() => this._resize()).observe(canvas.parentElement);
+    }
+
+    _initDefaultState() {
+        this.agents.forEach((name, i) => {
+            this.nodes[name] = {
+                state: [0.5, 0, 0.5, 0, 0.5],  // psi, tau, chi, phi, lam
+                tension: 0,
+                active: false,
+                energy: 0.25,
+                // Each node gets a unique phase offset for ambient animation
+                phaseOffset: (i / this.agents.length) * Math.PI * 2,
+            };
+        });
+    }
+
+    _resize() {
+        const rect = this.canvas.parentElement.getBoundingClientRect();
+        const dpr = window.devicePixelRatio || 1;
+        this.canvas.width = rect.width * dpr;
+        this.canvas.height = 200 * dpr;
+        this.canvas.style.width = rect.width + 'px';
+        this.canvas.style.height = '200px';
+        // Reset transform before scaling — prevents DPR compounding on repeated resizes
+        this.ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+        this.w = rect.width;
+        this.h = 200;
+        this.cx = this.w / 2;
+        this.cy = this.h / 2;
+        this.radius = Math.min(this.w, this.h) * 0.35;
+    }
+
+    update(spiderwebState) {
+        if (!spiderwebState || !spiderwebState.nodes) return;
+
+        // Update node states
+        for (const [name, data] of Object.entries(spiderwebState.nodes)) {
+            if (this.nodes[name]) {
+                this.nodes[name].state = data.state || [0.5, 0, 0.5, 0, 0.5];
+                const tensions = data.tension_history || [];
+                this.nodes[name].tension = tensions.length > 0 ?
+                    tensions[tensions.length - 1] : 0;
+                this.nodes[name].energy = data.state ?
+                    data.state.reduce((s, v) => s + v * v, 0) : 0.25;
+                this.nodes[name].active = (data.state[0] || 0) > 0.6;
+            }
+        }
+
+        this.attractors = spiderwebState.attractors || [];
+        this.coherence = spiderwebState.phase_coherence || 0;
+    }
+
+    _getNodePos(index) {
+        const angle = (index / this.agents.length) * Math.PI * 2 - Math.PI / 2;
+        // Add gentle orbital drift
+        const drift = Math.sin(this.time * 0.3 + index * 0.8) * 2;
+        const driftY = Math.cos(this.time * 0.25 + index * 1.1) * 1.5;
+        return {
+            x: this.cx + Math.cos(angle) * this.radius + drift,
+            y: this.cy + Math.sin(angle) * this.radius + driftY,
+        };
+    }
+
+    _animate() {
+        this.time += 0.016;
+        this._draw();
+        this.animFrame = requestAnimationFrame(() => this._animate());
+    }
+
+    _draw() {
+        const ctx = this.ctx;
+        ctx.clearRect(0, 0, this.w, this.h);
+
+        // ── Ambient center glow (always visible, brighter with coherence) ──
+        const ambientAlpha = 0.02 + (this.coherence > 0.5 ? this.coherence * 0.05 : 0);
+        const centerGlow = ctx.createRadialGradient(
+            this.cx, this.cy, 0, this.cx, this.cy, this.radius * 1.3
+        );
+        centerGlow.addColorStop(0, `rgba(59, 130, 246, ${ambientAlpha + Math.sin(this.time * 0.5) * 0.01})`);
+        centerGlow.addColorStop(0.6, `rgba(168, 85, 247, ${ambientAlpha * 0.5})`);
+        centerGlow.addColorStop(1, 'transparent');
+        ctx.fillStyle = centerGlow;
+        ctx.fillRect(0, 0, this.w, this.h);
+
+        // ── Draw edges (always visible, brighter when active/tense) ──
+        this.agents.forEach((nameA, i) => {
+            const posA = this._getNodePos(i);
+            this.agents.forEach((nameB, j) => {
+                if (j <= i) return;
+                const posB = this._getNodePos(j);
+
+                const nodeA = this.nodes[nameA];
+                const nodeB = this.nodes[nameB];
+                const tension = Math.abs((nodeA?.tension || 0) - (nodeB?.tension || 0));
+
+                ctx.beginPath();
+                ctx.moveTo(posA.x, posA.y);
+                ctx.lineTo(posB.x, posB.y);
+
+                const bothActive = nodeA?.active && nodeB?.active;
+                const eitherActive = nodeA?.active || nodeB?.active;
+
+                // Base alpha: always visible (0.12), more when active
+                let alpha;
+                if (bothActive) {
+                    alpha = 0.25 + Math.sin(this.time * 3 + i + j) * 0.08;
+                } else if (eitherActive) {
+                    alpha = 0.15 + Math.sin(this.time * 2 + i) * 0.04;
+                } else {
+                    // Ambient: gentle breathing pulse on each edge
+                    alpha = 0.08 + Math.sin(this.time * 0.8 + i * 0.7 + j * 0.5) * 0.03;
+                }
+
+                // Tension boosts visibility
+                alpha += Math.min(tension * 0.3, 0.15);
+
+                if (bothActive) {
+                    ctx.strokeStyle = `rgba(168, 85, 247, ${alpha})`;
+                    ctx.lineWidth = 1.5;
+                } else if (eitherActive) {
+                    ctx.strokeStyle = `rgba(139, 92, 246, ${alpha})`;
+                    ctx.lineWidth = 1;
+                } else {
+                    ctx.strokeStyle = `rgba(100, 116, 139, ${alpha})`;
+                    ctx.lineWidth = 0.5;
+                }
+                ctx.stroke();
+            });
+        });
+
+        // ── Draw attractor regions ──
+        this.attractors.forEach((att, ai) => {
+            if (!att.members || att.members.length < 2) return;
+
+            let cx = 0, cy = 0, count = 0;
+            att.members.forEach(name => {
+                const idx = this.agents.indexOf(name);
+                if (idx >= 0) {
+                    const pos = this._getNodePos(idx);
+                    cx += pos.x;
+                    cy += pos.y;
+                    count++;
+                }
+            });
+            if (count < 2) return;
+            cx /= count;
+            cy /= count;
+
+            const attRadius = 20 + count * 8;
+            const gradient = ctx.createRadialGradient(cx, cy, 0, cx, cy, attRadius);
+            gradient.addColorStop(0, `rgba(168, 85, 247, ${0.08 + Math.sin(this.time * 2 + ai) * 0.03})`);
+            gradient.addColorStop(1, 'transparent');
+            ctx.fillStyle = gradient;
+            ctx.beginPath();
+            ctx.arc(cx, cy, attRadius, 0, Math.PI * 2);
+            ctx.fill();
+        });
+
+        // ── Draw nodes (always visible with ambient breathing) ──
+        this.agents.forEach((name, i) => {
+            const pos = this._getNodePos(i);
+            const node = this.nodes[name];
+            const color = this.colors[name] || '#94a3b8';
+            const energy = node?.energy || 0.25;
+            const isActive = node?.active || false;
+            const phase = node?.phaseOffset || 0;
+
+            // Breathing pulse — all nodes gently pulse even at rest
+            const breathe = Math.sin(this.time * 1.2 + phase) * 0.3 + 0.7;
+
+            // Node glow — always present, stronger when active
+            const glowAlpha = isActive ? 0.35 : (0.08 * breathe);
+            const glowRadius = isActive
+                ? 14 + Math.sin(this.time * 2 + phase) * 4
+                : 10 + breathe * 2;
+
+            const glow = ctx.createRadialGradient(
+                pos.x, pos.y, 0, pos.x, pos.y, glowRadius
+            );
+            glow.addColorStop(0, color + (isActive ? '60' : '25'));
+            glow.addColorStop(1, 'transparent');
+            ctx.fillStyle = glow;
+            ctx.beginPath();
+            ctx.arc(pos.x, pos.y, glowRadius, 0, Math.PI * 2);
+            ctx.fill();
+
+            // Node circle
+            const nodeRadius = isActive
+                ? 7 + energy * 4
+                : 5 + breathe * 1.5;
+
+            ctx.beginPath();
+            ctx.arc(pos.x, pos.y, nodeRadius, 0, Math.PI * 2);
+            ctx.fillStyle = isActive ? color : color + '80';
+            ctx.fill();
+
+            // Border ring
+            ctx.strokeStyle = isActive ? color : color + '40';
+            ctx.lineWidth = isActive ? 1.5 : 0.8;
+            ctx.stroke();
+
+            // Label
+            ctx.fillStyle = isActive ? '#e2e8f0' : '#94a3b8';
+            ctx.font = `${isActive ? 'bold ' : ''}9px system-ui`;
+            ctx.textAlign = 'center';
+            ctx.textBaseline = 'middle';
+            ctx.fillText(this.labels[name], pos.x, pos.y + nodeRadius + 10);
+        });
+
+        // ── Coherence ring (always show a faint ring, solid when coherent) ──
+        const ringAlpha = this.coherence > 0
+            ? 0.2 + this.coherence * 0.4
+            : 0.06 + Math.sin(this.time * 0.6) * 0.02;
+        const ringProgress = this.coherence > 0
+            ? this.coherence
+            : 0.15 + Math.sin(this.time * 0.3) * 0.05;
+
+        ctx.beginPath();
+        ctx.arc(this.cx, this.cy, this.radius + 15,
+            -Math.PI / 2,
+            -Math.PI / 2 + Math.PI * 2 * ringProgress);
+        ctx.strokeStyle = this.coherence > 0.5
+            ? `rgba(16, 185, 129, ${ringAlpha})`
+            : `rgba(100, 116, 139, ${ringAlpha})`;
+        ctx.lineWidth = this.coherence > 0.5 ? 2.5 : 1.5;
+        ctx.lineCap = 'round';
+        ctx.stroke();
+
+        // Coherence label
+        if (this.coherence > 0) {
+            ctx.fillStyle = '#94a3b8';
+            ctx.font = '9px system-ui';
+            ctx.textAlign = 'center';
+            ctx.fillText(`\u0393 ${this.coherence.toFixed(2)}`, this.cx, this.h - 8);
+        } else {
+            ctx.fillStyle = '#475569';
+            ctx.font = '9px system-ui';
+            ctx.textAlign = 'center';
+            ctx.fillText('idle', this.cx, this.h - 8);
+        }
+    }
+
+    destroy() {
+        if (this.animFrame) cancelAnimationFrame(this.animFrame);
+    }
+}

inference/static/style.css

@@ -0,0 +1,859 @@
+/* ============================================================
+   Codette UI — Dark Glass Theme with Adapter Accent Colors
+   Zero dependencies. Pure CSS.
+   ============================================================ */
+
+:root {
+    /* Base palette */
+    --bg-primary: #0f1117;
+    --bg-secondary: #1a1d28;
+    --bg-tertiary: #232736;
+    --bg-glass: rgba(26, 29, 40, 0.85);
+    --text-primary: #e2e8f0;
+    --text-secondary: #94a3b8;
+    --text-muted: #64748b;
+    --border: rgba(148, 163, 184, 0.12);
+    --border-active: rgba(148, 163, 184, 0.25);
+
+    /* Adapter accent colors */
+    --newton: #3b82f6;
+    --davinci: #f59e0b;
+    --empathy: #a855f7;
+    --philosophy: #10b981;
+    --quantum: #ef4444;
+    --consciousness: #e2e8f0;
+    --multi_perspective: #f97316;
+    --systems_architecture: #06b6d4;
+    --base: #94a3b8;
+
+    /* Active accent (changes dynamically) */
+    --accent: var(--base);
+    --accent-glow: rgba(148, 163, 184, 0.15);
+
+    /* Layout */
+    --sidebar-width: 320px;
+    --header-height: 56px;
+    --input-height: 80px;
+    --status-height: 36px;
+    --radius: 12px;
+    --radius-sm: 8px;
+}
+
+* { margin: 0; padding: 0; box-sizing: border-box; }
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    height: 100vh;
+    overflow: hidden;
+    line-height: 1.6;
+}
+
+/* ── Layout ── */
+.app {
+    display: flex;
+    height: 100vh;
+}
+
+.main-panel {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+}
+
+.side-panel {
+    width: var(--sidebar-width);
+    background: var(--bg-secondary);
+    border-left: 1px solid var(--border);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    transition: width 0.3s ease;
+}
+
+.side-panel.collapsed {
+    width: 0;
+    border: none;
+}
+
+/* ── Header ── */
+.header {
+    height: var(--header-height);
+    padding: 0 20px;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    background: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+}
+
+.header-left {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.logo {
+    font-size: 20px;
+    font-weight: 700;
+    letter-spacing: -0.02em;
+    background: linear-gradient(135deg, var(--accent), var(--text-primary));
+    -webkit-background-clip: text;
+    background-clip: text;
+    -webkit-text-fill-color: transparent;
+    transition: all 0.5s ease;
+}
+
+.adapter-dots {
+    display: flex;
+    gap: 4px;
+    align-items: center;
+}
+
+.adapter-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    opacity: 0.3;
+    transition: all 0.3s ease;
+}
+
+.adapter-dot.available { opacity: 0.6; }
+.adapter-dot.active {
+    opacity: 1;
+    box-shadow: 0 0 8px currentColor;
+    transform: scale(1.3);
+}
+
+.header-right {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.header-btn {
+    background: none;
+    border: 1px solid var(--border);
+    color: var(--text-secondary);
+    padding: 6px 12px;
+    border-radius: var(--radius-sm);
+    cursor: pointer;
+    font-size: 13px;
+    transition: all 0.2s;
+}
+
+.header-btn:hover {
+    border-color: var(--accent);
+    color: var(--text-primary);
+    background: var(--accent-glow);
+}
+
+/* ── Chat Area ── */
+.chat-area {
+    flex: 1;
+    overflow-y: auto;
+    padding: 20px;
+    scroll-behavior: smooth;
+}
+
+.chat-area::-webkit-scrollbar { width: 6px; }
+.chat-area::-webkit-scrollbar-track { background: transparent; }
+.chat-area::-webkit-scrollbar-thumb {
+    background: var(--border-active);
+    border-radius: 3px;
+}
+
+.message {
+    max-width: 800px;
+    margin: 0 auto 16px;
+    animation: messageIn 0.3s ease;
+}
+
+@keyframes messageIn {
+    from { opacity: 0; transform: translateY(8px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+.message-user {
+    text-align: right;
+}
+
+.message-user .bubble {
+    background: var(--bg-tertiary);
+    border: 1px solid var(--border);
+    display: inline-block;
+    text-align: left;
+    padding: 12px 16px;
+    border-radius: var(--radius) var(--radius) 4px var(--radius);
+    max-width: 85%;
+}
+
+.message-assistant .bubble {
+    background: var(--bg-glass);
+    border: 1px solid var(--border);
+    border-left: 3px solid var(--accent);
+    padding: 12px 16px;
+    border-radius: 4px var(--radius) var(--radius) var(--radius);
+    backdrop-filter: blur(10px);
+    max-width: 100%;
+}
+
+.message-header {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-bottom: 6px;
+    font-size: 12px;
+    color: var(--text-muted);
+}
+
+.adapter-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    padding: 2px 8px;
+    border-radius: 10px;
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    border: 1px solid currentColor;
+    opacity: 0.9;
+}
+
+.confidence-bar {
+    width: 40px;
+    height: 4px;
+    background: var(--bg-tertiary);
+    border-radius: 2px;
+    overflow: hidden;
+}
+
+.confidence-fill {
+    height: 100%;
+    border-radius: 2px;
+    transition: width 0.5s ease;
+}
+
+.message-text {
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+    font-size: 14px;
+    line-height: 1.7;
+}
+
+/* Keep pre-wrap only for user messages (no markdown rendering) */
+.message-user .message-text {
+    white-space: pre-wrap;
+}
+
+.message-meta {
+    margin-top: 6px;
+    font-size: 11px;
+    color: var(--text-muted);
+}
+
+/* Perspectives expandable */
+.tools-badge {
+    margin-top: 8px;
+    padding: 4px 10px;
+    background: rgba(16, 185, 129, 0.1);
+    border: 1px solid rgba(16, 185, 129, 0.25);
+    border-radius: 12px;
+    color: #10b981;
+    font-size: 11px;
+    display: inline-block;
+}
+
+.perspectives-toggle {
+    margin-top: 10px;
+    padding: 8px 12px;
+    background: rgba(255,255,255,0.03);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-sm);
+    cursor: pointer;
+    color: var(--text-secondary);
+    font-size: 12px;
+    transition: all 0.2s;
+}
+
+.perspectives-toggle:hover {
+    background: rgba(255,255,255,0.06);
+    color: var(--text-primary);
+}
+
+.perspectives-panel {
+    display: none;
+    margin-top: 10px;
+    gap: 8px;
+}
+
+.perspectives-panel.open { display: flex; flex-direction: column; }
+
+.perspective-card {
+    padding: 10px 14px;
+    background: rgba(255,255,255,0.02);
+    border-radius: var(--radius-sm);
+    border-left: 3px solid var(--accent);
+    font-size: 13px;
+    line-height: 1.6;
+}
+
+.perspective-card-header {
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-bottom: 4px;
+}
+
+/* Thinking indicator */
+.thinking {
+    max-width: 800px;
+    margin: 0 auto 16px;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    color: var(--text-muted);
+    font-size: 13px;
+}
+
+.thinking-dots {
+    display: flex;
+    gap: 4px;
+}
+
+.thinking-dots span {
+    width: 6px;
+    height: 6px;
+    background: var(--accent);
+    border-radius: 50%;
+    animation: pulse 1.2s infinite;
+}
+
+.thinking-dots span:nth-child(2) { animation-delay: 0.2s; }
+.thinking-dots span:nth-child(3) { animation-delay: 0.4s; }
+
+@keyframes pulse {
+    0%, 100% { opacity: 0.3; transform: scale(0.8); }
+    50% { opacity: 1; transform: scale(1.2); }
+}
+
+/* ── Controls Row ── */
+.controls {
+    padding: 8px 20px;
+    display: flex;
+    align-items: center;
+    gap: 16px;
+    border-top: 1px solid var(--border);
+    background: var(--bg-secondary);
+    flex-shrink: 0;
+}
+
+.control-group {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    font-size: 12px;
+    color: var(--text-secondary);
+}
+
+.control-group select,
+.control-group input[type="range"] {
+    background: var(--bg-tertiary);
+    border: 1px solid var(--border);
+    color: var(--text-primary);
+    padding: 4px 8px;
+    border-radius: 6px;
+    font-size: 12px;
+    cursor: pointer;
+}
+
+.control-group select:focus,
+.control-group input:focus { outline: none; border-color: var(--accent); }
+
+/* ── Input Area ── */
+.input-area {
+    padding: 12px 20px;
+    background: var(--bg-secondary);
+    border-top: 1px solid var(--border);
+    flex-shrink: 0;
+}
+
+.input-row {
+    max-width: 800px;
+    margin: 0 auto;
+    display: flex;
+    gap: 10px;
+    align-items: flex-end;
+}
+
+.input-wrapper {
+    flex: 1;
+    position: relative;
+}
+
+#chat-input {
+    width: 100%;
+    min-height: 44px;
+    max-height: 120px;
+    padding: 10px 14px;
+    background: var(--bg-tertiary);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    color: var(--text-primary);
+    font-size: 14px;
+    font-family: inherit;
+    resize: none;
+    line-height: 1.5;
+    transition: border-color 0.2s;
+}
+
+#chat-input:focus {
+    outline: none;
+    border-color: var(--accent);
+    box-shadow: 0 0 0 3px var(--accent-glow);
+}
+
+#chat-input::placeholder {
+    color: var(--text-muted);
+}
+
+.send-btn {
+    width: 44px;
+    height: 44px;
+    border: none;
+    border-radius: var(--radius);
+    background: var(--accent);
+    color: var(--bg-primary);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 18px;
+    transition: all 0.2s;
+    flex-shrink: 0;
+}
+
+.send-btn:hover { transform: scale(1.05); filter: brightness(1.15); }
+.send-btn:disabled { opacity: 0.4; cursor: not-allowed; transform: none; }
+
+.mic-btn {
+    width: 44px;
+    height: 44px;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    background: var(--bg-tertiary);
+    color: var(--text-secondary);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 18px;
+    transition: all 0.2s;
+    flex-shrink: 0;
+}
+
+.mic-btn:hover { border-color: var(--accent); color: var(--text-primary); }
+.mic-btn.recording {
+    border-color: var(--quantum);
+    color: var(--quantum);
+    animation: pulse 1s infinite;
+}
+
+/* ── Status Bar ── */
+.status-bar {
+    height: var(--status-height);
+    padding: 0 20px;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    background: var(--bg-primary);
+    border-top: 1px solid var(--border);
+    font-size: 11px;
+    color: var(--text-muted);
+    flex-shrink: 0;
+}
+
+.status-indicator {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+
+.status-dot {
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    background: var(--text-muted);
+}
+
+.status-dot.ready { background: #10b981; }
+.status-dot.loading { background: #f59e0b; animation: pulse 1s infinite; }
+.status-dot.error { background: #ef4444; }
+
+/* ── Side Panel ── */
+.side-section {
+    padding: 16px;
+    border-bottom: 1px solid var(--border);
+}
+
+.side-section-title {
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    color: var(--text-muted);
+    margin-bottom: 12px;
+}
+
+/* Metrics */
+.metric-row {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: 8px;
+    font-size: 12px;
+}
+
+.metric-label {
+    color: var(--text-secondary);
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+
+.metric-value {
+    font-weight: 600;
+    font-variant-numeric: tabular-nums;
+    color: var(--text-primary);
+}
+
+.metric-bar {
+    width: 100%;
+    height: 4px;
+    background: var(--bg-tertiary);
+    border-radius: 2px;
+    margin-top: 4px;
+    overflow: hidden;
+}
+
+.metric-bar-fill {
+    height: 100%;
+    border-radius: 2px;
+    transition: width 0.5s ease;
+}
+
+/* Coverage dots */
+.coverage-dots {
+    display: flex;
+    gap: 6px;
+    flex-wrap: wrap;
+    margin-top: 8px;
+}
+
+.coverage-dot {
+    width: 24px;
+    height: 24px;
+    border-radius: 50%;
+    border: 2px solid currentColor;
+    opacity: 0.25;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 10px;
+    transition: all 0.3s;
+}
+
+.coverage-dot.active {
+    opacity: 1;
+    box-shadow: 0 0 8px currentColor;
+}
+
+/* Spiderweb canvas */
+#spiderweb-canvas {
+    width: 100%;
+    height: 200px;
+    border-radius: var(--radius-sm);
+    background: rgba(0,0,0,0.3);
+}
+
+/* Session list */
+.session-item {
+    padding: 8px 12px;
+    border-radius: var(--radius-sm);
+    cursor: pointer;
+    font-size: 12px;
+    color: var(--text-secondary);
+    margin-bottom: 4px;
+    transition: all 0.2s;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.session-item:hover {
+    background: var(--bg-tertiary);
+    color: var(--text-primary);
+}
+
+/* ── Loading Screen ── */
+.loading-screen {
+    position: fixed;
+    inset: 0;
+    background: var(--bg-primary);
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    z-index: 100;
+    transition: opacity 0.5s;
+}
+
+.loading-screen.hidden {
+    opacity: 0;
+    pointer-events: none;
+}
+
+.loading-title {
+    font-size: 32px;
+    font-weight: 700;
+    margin-bottom: 16px;
+    background: linear-gradient(135deg, #3b82f6, #a855f7, #f59e0b);
+    -webkit-background-clip: text;
+    background-clip: text;
+    -webkit-text-fill-color: transparent;
+}
+
+.loading-status {
+    color: var(--text-secondary);
+    font-size: 14px;
+    margin-bottom: 24px;
+}
+
+.loading-bar {
+    width: 200px;
+    height: 3px;
+    background: var(--bg-tertiary);
+    border-radius: 2px;
+    overflow: hidden;
+}
+
+.loading-bar-fill {
+    height: 100%;
+    width: 30%;
+    background: linear-gradient(90deg, #3b82f6, #a855f7);
+    border-radius: 2px;
+    animation: loadSlide 1.5s ease infinite;
+}
+
+@keyframes loadSlide {
+    0% { transform: translateX(-100%); }
+    100% { transform: translateX(400%); }
+}
+
+/* ── Welcome State ── */
+.welcome {
+    max-width: 600px;
+    margin: 0 auto;
+    padding: 60px 20px;
+    text-align: center;
+}
+
+.welcome h2 {
+    font-size: 24px;
+    font-weight: 600;
+    margin-bottom: 8px;
+    color: var(--text-primary);
+}
+
+.welcome p {
+    color: var(--text-secondary);
+    font-size: 14px;
+    margin-bottom: 24px;
+}
+
+.welcome-grid {
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
+    gap: 10px;
+    text-align: left;
+}
+
+.welcome-card {
+    padding: 14px;
+    background: var(--bg-secondary);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-sm);
+    cursor: pointer;
+    transition: all 0.2s;
+    font-size: 13px;
+}
+
+.welcome-card:hover {
+    border-color: var(--accent);
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(0,0,0,0.3);
+}
+
+.welcome-card-title {
+    font-weight: 600;
+    margin-bottom: 4px;
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+
+.welcome-card-desc {
+    color: var(--text-muted);
+    font-size: 11px;
+}
+
+/* ── Markdown Rendering ── */
+.md-h1 {
+    font-size: 18px;
+    font-weight: 700;
+    margin: 12px 0 6px;
+    color: var(--text-primary);
+}
+
+.md-h2 {
+    font-size: 16px;
+    font-weight: 600;
+    margin: 10px 0 4px;
+    color: var(--text-primary);
+}
+
+.md-h3 {
+    font-size: 14px;
+    font-weight: 600;
+    margin: 8px 0 4px;
+    color: var(--text-secondary);
+}
+
+.md-li {
+    padding-left: 16px;
+    position: relative;
+    margin: 2px 0;
+}
+
+.md-li::before {
+    content: '\2022';
+    position: absolute;
+    left: 4px;
+    color: var(--accent);
+}
+
+.md-oli::before {
+    content: counter(md-ol) '.';
+    counter-increment: md-ol;
+}
+
+.code-block {
+    background: rgba(0,0,0,0.4);
+    border: 1px solid var(--border);
+    border-radius: 6px;
+    padding: 10px 14px;
+    margin: 8px 0;
+    overflow-x: auto;
+    font-family: 'Cascadia Code', 'Fira Code', 'JetBrains Mono', monospace;
+    font-size: 12px;
+    line-height: 1.5;
+    white-space: pre;
+}
+
+.code-block code {
+    background: none;
+    padding: 0;
+    border: none;
+    font-size: inherit;
+}
+
+.inline-code {
+    background: rgba(148, 163, 184, 0.15);
+    border: 1px solid rgba(148, 163, 184, 0.2);
+    border-radius: 4px;
+    padding: 1px 5px;
+    font-family: 'Cascadia Code', 'Fira Code', monospace;
+    font-size: 0.9em;
+}
+
+.message-text strong {
+    color: var(--text-primary);
+    font-weight: 600;
+}
+
+.message-text em {
+    color: var(--text-secondary);
+    font-style: italic;
+}
+
+/* ── Subsystem Panels ── */
+.nexus-risk-dots {
+    display: flex;
+    gap: 4px;
+    margin-top: 8px;
+    flex-wrap: wrap;
+}
+
+.risk-dot {
+    width: 10px;
+    height: 10px;
+    border-radius: 50%;
+    transition: all 0.3s;
+}
+
+.risk-dot.low { background: var(--philosophy); opacity: 0.6; }
+.risk-dot.medium { background: var(--davinci); opacity: 0.8; }
+.risk-dot.high { background: var(--quantum); opacity: 1; box-shadow: 0 0 6px var(--quantum); }
+
+.memory-emotions {
+    display: flex;
+    gap: 4px;
+    flex-wrap: wrap;
+    margin-top: 8px;
+}
+
+.emotion-tag {
+    padding: 2px 8px;
+    border-radius: 10px;
+    font-size: 10px;
+    font-weight: 600;
+    background: rgba(148, 163, 184, 0.1);
+    border: 1px solid rgba(148, 163, 184, 0.2);
+    color: var(--text-secondary);
+}
+
+.emotion-tag.active {
+    background: rgba(168, 85, 247, 0.15);
+    border-color: rgba(168, 85, 247, 0.4);
+    color: var(--empathy);
+}
+
+.trend-improving { color: var(--philosophy) !important; }
+.trend-declining { color: var(--quantum) !important; }
+.trend-stable { color: var(--text-secondary) !important; }
+
+.peak-active {
+    color: var(--davinci) !important;
+    text-shadow: 0 0 8px var(--davinci);
+}
+
+/* ── Responsive ── */
+@media (max-width: 768px) {
+    .side-panel {
+        display: none;
+        position: fixed;
+        right: 0; top: 0; bottom: 0;
+        z-index: 50;
+        box-shadow: -8px 0 24px rgba(0,0,0,0.5);
+    }
+    /* On mobile, un-collapsing the panel shows it as an overlay */
+    .side-panel:not(.collapsed) {
+        display: flex;
+    }
+    .welcome-grid { grid-template-columns: 1fr; }
+}

inference/vulkan_compute.py

@@ -0,0 +1,661 @@
+#!/usr/bin/env python3
+"""
+Codette Vulkan GPU Compute Adapter
+====================================
+Provides Vulkan-based GPU acceleration for tensor operations,
+model inference preprocessing, and compute shader dispatch.
+
+Uses the `kompute` library (lightweight Vulkan compute for ML)
+as the primary backend, with fallback to raw `vulkan` bindings.
+
+Supported operations:
+  - Device discovery and capability reporting
+  - Tensor allocation on Vulkan GPU memory
+  - Compute shader dispatch (SPIR-V)
+  - Matrix multiply, softmax, layer norm (common inference ops)
+  - Memory-mapped transfer between CPU ↔ Vulkan GPU
+  - Integration with llama.cpp via shared memory buffers
+
+Architecture:
+  VulkanComputeAdapter
+    ├─ VulkanDevice       (physical device enumeration + selection)
+    ├─ VulkanMemoryPool   (GPU memory management with ring buffer)
+    ├─ ShaderRegistry     (compiled SPIR-V shader cache)
+    └─ ComputePipeline    (dispatch queue + synchronization)
+
+Hardware compatibility:
+  - NVIDIA (all Vulkan-capable GPUs, driver 470+)
+  - AMD (RDNA/RDNA2/RDNA3, GCN 4th gen+)
+  - Intel Arc (A-series, driver 31.0.101+)
+  - Qualcomm Adreno (mobile/embedded Vulkan 1.1+)
+"""
+
+import os
+import sys
+import time
+import json
+import struct
+import logging
+import threading
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import Optional, Dict, List, Any, Tuple
+
+logger = logging.getLogger("codette.vulkan")
+
+
+# ================================================================
+# Vulkan Device Information
+# ================================================================
+
+@dataclass
+class VulkanDeviceInfo:
+    """Describes a Vulkan-capable GPU."""
+    device_id: int
+    name: str
+    vendor: str
+    driver_version: str
+    api_version: str
+    device_type: str  # "discrete", "integrated", "virtual", "cpu"
+    vram_mb: int
+    max_compute_workgroup_size: Tuple[int, int, int]
+    max_compute_workgroup_count: Tuple[int, int, int]
+    max_compute_shared_memory: int
+    supports_float16: bool
+    supports_float64: bool
+    supports_int8: bool
+    supports_subgroup_ops: bool
+    compute_queue_families: int
+
+
+@dataclass
+class VulkanMemoryBlock:
+    """Tracks a GPU memory allocation."""
+    block_id: int
+    size_bytes: int
+    offset: int
+    device_local: bool
+    host_visible: bool
+    in_use: bool = True
+    label: str = ""
+
+
+# ================================================================
+# Vulkan Compute Adapter
+# ================================================================
+
+class VulkanComputeAdapter:
+    """Main adapter for Vulkan GPU compute operations.
+
+    Provides device management, memory allocation, shader dispatch,
+    and tensor operations for Codette's inference pipeline.
+    """
+
+    def __init__(self, device_index: int = 0, enable_validation: bool = False):
+        self.device_index = device_index
+        self.enable_validation = enable_validation
+        self._initialized = False
+        self._device_info: Optional[VulkanDeviceInfo] = None
+        self._manager = None  # kompute.Manager
+        self._tensors: Dict[str, Any] = {}
+        self._shader_cache: Dict[str, Any] = {}
+        self._memory_blocks: List[VulkanMemoryBlock] = []
+        self._block_counter = 0
+        self._lock = threading.Lock()
+
+        # Performance counters
+        self._dispatch_count = 0
+        self._total_compute_ms = 0.0
+        self._total_transfer_bytes = 0
+
+    # --------------------------------------------------------
+    # Initialization
+    # --------------------------------------------------------
+
+    def initialize(self) -> bool:
+        """Initialize Vulkan device and compute context.
+
+        Returns True if Vulkan GPU is available and ready.
+        """
+        if self._initialized:
+            return True
+
+        try:
+            import kp  # kompute
+        except ImportError:
+            logger.warning(
+                "kompute not installed. Install with: pip install kp\n"
+                "Falling back to Vulkan availability check only."
+            )
+            return self._try_raw_vulkan_init()
+
+        try:
+            # Create manager targeting specific device
+            self._manager = kp.Manager(self.device_index)
+            self._initialized = True
+
+            # Probe device capabilities
+            self._device_info = self._probe_device_info()
+
+            logger.info(
+                f"Vulkan compute initialized: {self._device_info.name} "
+                f"({self._device_info.vram_mb} MB VRAM, "
+                f"type={self._device_info.device_type})"
+            )
+            return True
+
+        except Exception as e:
+            logger.error(f"Vulkan initialization failed: {e}")
+            return False
+
+    def _try_raw_vulkan_init(self) -> bool:
+        """Fallback: check Vulkan availability via vulkan module or system."""
+        try:
+            import vulkan as vk
+            instance = vk.vkCreateInstance(
+                vk.VkInstanceCreateInfo(
+                    sType=vk.VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+                    pApplicationInfo=vk.VkApplicationInfo(
+                        sType=vk.VK_STRUCTURE_TYPE_APPLICATION_INFO,
+                        pApplicationName="Codette",
+                        applicationVersion=vk.VK_MAKE_VERSION(1, 0, 0),
+                        apiVersion=vk.VK_API_VERSION_1_2,
+                    ),
+                ),
+                None,
+            )
+            devices = vk.vkEnumeratePhysicalDevices(instance)
+            if devices:
+                props = vk.vkGetPhysicalDeviceProperties(devices[self.device_index])
+                self._device_info = VulkanDeviceInfo(
+                    device_id=self.device_index,
+                    name=props.deviceName,
+                    vendor=self._vendor_from_id(props.vendorID),
+                    driver_version=str(props.driverVersion),
+                    api_version=f"{vk.VK_VERSION_MAJOR(props.apiVersion)}."
+                                f"{vk.VK_VERSION_MINOR(props.apiVersion)}."
+                                f"{vk.VK_VERSION_PATCH(props.apiVersion)}",
+                    device_type=self._device_type_str(props.deviceType),
+                    vram_mb=0,  # Would need memory properties query
+                    max_compute_workgroup_size=(256, 256, 64),
+                    max_compute_workgroup_count=(65535, 65535, 65535),
+                    max_compute_shared_memory=32768,
+                    supports_float16=True,
+                    supports_float64=False,
+                    supports_int8=True,
+                    supports_subgroup_ops=True,
+                    compute_queue_families=1,
+                )
+                logger.info(f"Vulkan device detected (raw): {self._device_info.name}")
+                vk.vkDestroyInstance(instance, None)
+                self._initialized = True
+                return True
+            vk.vkDestroyInstance(instance, None)
+        except ImportError:
+            logger.info("No Vulkan Python bindings available (vulkan or kp)")
+        except Exception as e:
+            logger.debug(f"Raw Vulkan probe failed: {e}")
+
+        return False
+
+    def _probe_device_info(self) -> VulkanDeviceInfo:
+        """Probe device capabilities via kompute manager."""
+        # kompute abstracts most Vulkan details; provide safe defaults
+        return VulkanDeviceInfo(
+            device_id=self.device_index,
+            name=f"Vulkan Device {self.device_index}",
+            vendor="Unknown",
+            driver_version="Unknown",
+            api_version="1.2+",
+            device_type="discrete",
+            vram_mb=0,
+            max_compute_workgroup_size=(256, 256, 64),
+            max_compute_workgroup_count=(65535, 65535, 65535),
+            max_compute_shared_memory=32768,
+            supports_float16=True,
+            supports_float64=False,
+            supports_int8=True,
+            supports_subgroup_ops=True,
+            compute_queue_families=1,
+        )
+
+    # --------------------------------------------------------
+    # Tensor Operations
+    # --------------------------------------------------------
+
+    def create_tensor(self, name: str, data: list, dtype: str = "float32") -> Any:
+        """Allocate a named tensor on Vulkan GPU memory.
+
+        Args:
+            name: Unique identifier for the tensor
+            data: Initial data (flat list of numbers)
+            dtype: Data type - "float32", "float16", "int32", "uint32"
+
+        Returns:
+            kompute Tensor object (or dict stub if kompute unavailable)
+        """
+        if not self._initialized:
+            raise RuntimeError("VulkanComputeAdapter not initialized")
+
+        with self._lock:
+            if self._manager is not None:
+                import kp
+                tensor = self._manager.tensor(data)
+                self._tensors[name] = tensor
+                self._total_transfer_bytes += len(data) * 4  # ~4 bytes per float32
+                logger.debug(f"Tensor '{name}' created: {len(data)} elements on GPU")
+                return tensor
+            else:
+                # Stub for raw vulkan mode
+                stub = {"name": name, "data": data, "dtype": dtype, "device": "vulkan"}
+                self._tensors[name] = stub
+                return stub
+
+    def read_tensor(self, name: str) -> list:
+        """Read tensor data back from GPU to CPU."""
+        if name not in self._tensors:
+            raise KeyError(f"Tensor '{name}' not found")
+
+        tensor = self._tensors[name]
+        if self._manager is not None:
+            import kp
+            sq = self._manager.sequence()
+            sq.record_tensor_sync_local([tensor])
+            sq.eval()
+            return tensor.data().tolist()
+        else:
+            return tensor.get("data", [])
+
+    def destroy_tensor(self, name: str):
+        """Free GPU memory for a named tensor."""
+        with self._lock:
+            if name in self._tensors:
+                del self._tensors[name]
+                logger.debug(f"Tensor '{name}' freed")
+
+    # --------------------------------------------------------
+    # Compute Shader Dispatch
+    # --------------------------------------------------------
+
+    def dispatch_shader(
+        self,
+        shader_spirv: bytes,
+        tensors: List[str],
+        workgroup: Tuple[int, int, int] = (256, 1, 1),
+        shader_name: str = "anonymous",
+    ) -> float:
+        """Dispatch a SPIR-V compute shader on the Vulkan GPU.
+
+        Args:
+            shader_spirv: Compiled SPIR-V bytecode
+            tensors: Names of tensors to bind as storage buffers
+            workgroup: Workgroup dispatch dimensions (x, y, z)
+            shader_name: Label for logging/profiling
+
+        Returns:
+            Execution time in milliseconds
+        """
+        if not self._initialized or self._manager is None:
+            raise RuntimeError("Vulkan compute not available for shader dispatch")
+
+        import kp
+
+        bound_tensors = [self._tensors[t] for t in tensors]
+
+        start = time.perf_counter()
+
+        sq = self._manager.sequence()
+        sq.record_tensor_sync_device(bound_tensors)
+
+        # Build algorithm from SPIR-V
+        algo = self._manager.algorithm(
+            bound_tensors,
+            shader_spirv,
+            kp.Workgroup(list(workgroup)),
+        )
+        sq.record_algo_dispatch(algo)
+        sq.record_tensor_sync_local(bound_tensors)
+        sq.eval()
+
+        elapsed_ms = (time.perf_counter() - start) * 1000.0
+
+        self._dispatch_count += 1
+        self._total_compute_ms += elapsed_ms
+
+        logger.debug(
+            f"Shader '{shader_name}' dispatched: "
+            f"workgroup={workgroup}, time={elapsed_ms:.2f}ms"
+        )
+        return elapsed_ms
+
+    # --------------------------------------------------------
+    # Built-in Compute Operations (pre-compiled shaders)
+    # --------------------------------------------------------
+
+    def vector_add(self, a_name: str, b_name: str, out_name: str) -> float:
+        """Element-wise addition of two tensors using Vulkan compute."""
+        SHADER_ADD = self._get_builtin_shader("vector_add")
+        if SHADER_ADD is None:
+            # CPU fallback
+            a_data = self.read_tensor(a_name)
+            b_data = self.read_tensor(b_name)
+            result = [x + y for x, y in zip(a_data, b_data)]
+            self.create_tensor(out_name, result)
+            return 0.0
+        return self.dispatch_shader(SHADER_ADD, [a_name, b_name, out_name])
+
+    def vector_multiply(self, a_name: str, b_name: str, out_name: str) -> float:
+        """Element-wise multiplication of two tensors."""
+        SHADER_MUL = self._get_builtin_shader("vector_mul")
+        if SHADER_MUL is None:
+            a_data = self.read_tensor(a_name)
+            b_data = self.read_tensor(b_name)
+            result = [x * y for x, y in zip(a_data, b_data)]
+            self.create_tensor(out_name, result)
+            return 0.0
+        return self.dispatch_shader(SHADER_MUL, [a_name, b_name, out_name])
+
+    def softmax(self, input_name: str, out_name: str) -> float:
+        """Compute softmax over a tensor (used in attention layers)."""
+        import math
+        data = self.read_tensor(input_name)
+        max_val = max(data) if data else 0.0
+        exp_data = [math.exp(x - max_val) for x in data]
+        total = sum(exp_data)
+        result = [x / total for x in exp_data] if total > 0 else exp_data
+        self.create_tensor(out_name, result)
+        return 0.0  # CPU fallback timing
+
+    def layer_norm(
+        self, input_name: str, out_name: str, eps: float = 1e-5
+    ) -> float:
+        """Layer normalization (pre-LLM inference op)."""
+        import math
+        data = self.read_tensor(input_name)
+        n = len(data)
+        if n == 0:
+            self.create_tensor(out_name, [])
+            return 0.0
+        mean = sum(data) / n
+        var = sum((x - mean) ** 2 for x in data) / n
+        std = math.sqrt(var + eps)
+        result = [(x - mean) / std for x in data]
+        self.create_tensor(out_name, result)
+        return 0.0
+
+    def _get_builtin_shader(self, name: str) -> Optional[bytes]:
+        """Load a pre-compiled SPIR-V shader from the shader cache."""
+        if name in self._shader_cache:
+            return self._shader_cache[name]
+
+        shader_dir = Path(__file__).parent / "shaders" / "spirv"
+        shader_path = shader_dir / f"{name}.spv"
+        if shader_path.exists():
+            spirv = shader_path.read_bytes()
+            self._shader_cache[name] = spirv
+            return spirv
+
+        return None
+
+    # --------------------------------------------------------
+    # Memory Management
+    # --------------------------------------------------------
+
+    def allocate_block(
+        self, size_bytes: int, device_local: bool = True, label: str = ""
+    ) -> VulkanMemoryBlock:
+        """Allocate a raw memory block on the Vulkan device."""
+        with self._lock:
+            self._block_counter += 1
+            block = VulkanMemoryBlock(
+                block_id=self._block_counter,
+                size_bytes=size_bytes,
+                offset=0,
+                device_local=device_local,
+                host_visible=not device_local,
+                label=label,
+            )
+            self._memory_blocks.append(block)
+            logger.debug(
+                f"Memory block {block.block_id} allocated: "
+                f"{size_bytes} bytes, label='{label}'"
+            )
+            return block
+
+    def free_block(self, block_id: int):
+        """Free a previously allocated memory block."""
+        with self._lock:
+            self._memory_blocks = [
+                b for b in self._memory_blocks if b.block_id != block_id
+            ]
+
+    def get_memory_usage(self) -> Dict[str, Any]:
+        """Report current GPU memory usage."""
+        active = [b for b in self._memory_blocks if b.in_use]
+        return {
+            "active_blocks": len(active),
+            "total_allocated_bytes": sum(b.size_bytes for b in active),
+            "tensor_count": len(self._tensors),
+            "device": self._device_info.name if self._device_info else "unknown",
+        }
+
+    # --------------------------------------------------------
+    # Device Query & Status
+    # --------------------------------------------------------
+
+    @property
+    def device_info(self) -> Optional[VulkanDeviceInfo]:
+        return self._device_info
+
+    @property
+    def is_available(self) -> bool:
+        return self._initialized
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Return performance statistics."""
+        return {
+            "initialized": self._initialized,
+            "device": self._device_info.name if self._device_info else None,
+            "dispatch_count": self._dispatch_count,
+            "total_compute_ms": round(self._total_compute_ms, 2),
+            "avg_dispatch_ms": (
+                round(self._total_compute_ms / self._dispatch_count, 2)
+                if self._dispatch_count > 0
+                else 0.0
+            ),
+            "total_transfer_bytes": self._total_transfer_bytes,
+            "active_tensors": len(self._tensors),
+        }
+
+    def shutdown(self):
+        """Release all Vulkan resources."""
+        with self._lock:
+            self._tensors.clear()
+            self._shader_cache.clear()
+            self._memory_blocks.clear()
+            self._manager = None
+            self._initialized = False
+            logger.info("Vulkan compute adapter shut down")
+
+    # --------------------------------------------------------
+    # Helpers
+    # --------------------------------------------------------
+
+    @staticmethod
+    def _vendor_from_id(vendor_id: int) -> str:
+        vendors = {
+            0x1002: "AMD",
+            0x10DE: "NVIDIA",
+            0x8086: "Intel",
+            0x13B5: "ARM (Mali)",
+            0x5143: "Qualcomm (Adreno)",
+            0x1010: "ImgTec (PowerVR)",
+        }
+        return vendors.get(vendor_id, f"Unknown (0x{vendor_id:04X})")
+
+    @staticmethod
+    def _device_type_str(device_type: int) -> str:
+        types = {
+            0: "other",
+            1: "integrated",
+            2: "discrete",
+            3: "virtual",
+            4: "cpu",
+        }
+        return types.get(device_type, "unknown")
+
+    def __repr__(self) -> str:
+        if self._device_info:
+            return (
+                f"<VulkanComputeAdapter device='{self._device_info.name}' "
+                f"vram={self._device_info.vram_mb}MB "
+                f"initialized={self._initialized}>"
+            )
+        return f"<VulkanComputeAdapter initialized={self._initialized}>"
+
+    def __enter__(self):
+        self.initialize()
+        return self
+
+    def __exit__(self, *args):
+        self.shutdown()
+
+
+# ================================================================
+# Device Detection Integration
+# ================================================================
+
+def detect_vulkan_devices() -> List[VulkanDeviceInfo]:
+    """Enumerate all Vulkan-capable GPUs on the system.
+
+    Returns a list of VulkanDeviceInfo for each available device.
+    Safe to call even if Vulkan is not installed (returns empty list).
+    """
+    devices = []
+
+    # Try kompute first
+    try:
+        import kp
+        mgr = kp.Manager()
+        info = VulkanDeviceInfo(
+            device_id=0,
+            name="Vulkan Device 0 (via kompute)",
+            vendor="Unknown",
+            driver_version="Unknown",
+            api_version="1.2+",
+            device_type="discrete",
+            vram_mb=0,
+            max_compute_workgroup_size=(256, 256, 64),
+            max_compute_workgroup_count=(65535, 65535, 65535),
+            max_compute_shared_memory=32768,
+            supports_float16=True,
+            supports_float64=False,
+            supports_int8=True,
+            supports_subgroup_ops=True,
+            compute_queue_families=1,
+        )
+        devices.append(info)
+        return devices
+    except Exception:
+        pass
+
+    # Try raw vulkan bindings
+    try:
+        import vulkan as vk
+        instance = vk.vkCreateInstance(
+            vk.VkInstanceCreateInfo(
+                sType=vk.VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+                pApplicationInfo=vk.VkApplicationInfo(
+                    sType=vk.VK_STRUCTURE_TYPE_APPLICATION_INFO,
+                    pApplicationName="Codette-Probe",
+                    applicationVersion=vk.VK_MAKE_VERSION(1, 0, 0),
+                    apiVersion=vk.VK_API_VERSION_1_2,
+                ),
+            ),
+            None,
+        )
+        physical_devices = vk.vkEnumeratePhysicalDevices(instance)
+        for idx, pd in enumerate(physical_devices):
+            props = vk.vkGetPhysicalDeviceProperties(pd)
+            devices.append(VulkanDeviceInfo(
+                device_id=idx,
+                name=props.deviceName,
+                vendor=VulkanComputeAdapter._vendor_from_id(props.vendorID),
+                driver_version=str(props.driverVersion),
+                api_version=f"{vk.VK_VERSION_MAJOR(props.apiVersion)}."
+                            f"{vk.VK_VERSION_MINOR(props.apiVersion)}."
+                            f"{vk.VK_VERSION_PATCH(props.apiVersion)}",
+                device_type=VulkanComputeAdapter._device_type_str(props.deviceType),
+                vram_mb=0,
+                max_compute_workgroup_size=(256, 256, 64),
+                max_compute_workgroup_count=(65535, 65535, 65535),
+                max_compute_shared_memory=32768,
+                supports_float16=True,
+                supports_float64=False,
+                supports_int8=True,
+                supports_subgroup_ops=True,
+                compute_queue_families=1,
+            ))
+        vk.vkDestroyInstance(instance, None)
+    except Exception:
+        pass
+
+    return devices
+
+
+def is_vulkan_available() -> bool:
+    """Quick check: is any Vulkan GPU available?"""
+    return len(detect_vulkan_devices()) > 0
+
+
+# ================================================================
+# CLI: vulkan device info
+# ================================================================
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+
+    print("=" * 60)
+    print("  Codette Vulkan GPU Compute Adapter — Device Probe")
+    print("=" * 60)
+
+    devices = detect_vulkan_devices()
+    if not devices:
+        print("\n  No Vulkan-capable GPUs detected.")
+        print("  Install: pip install kp  (or)  pip install vulkan")
+        print("  Ensure Vulkan drivers are installed for your GPU.")
+        sys.exit(1)
+
+    for dev in devices:
+        print(f"\n  Device {dev.device_id}: {dev.name}")
+        print(f"    Vendor:       {dev.vendor}")
+        print(f"    Type:         {dev.device_type}")
+        print(f"    API version:  {dev.api_version}")
+        print(f"    Driver:       {dev.driver_version}")
+        print(f"    VRAM:         {dev.vram_mb} MB")
+        print(f"    Float16:      {'yes' if dev.supports_float16 else 'no'}")
+        print(f"    Int8:         {'yes' if dev.supports_int8 else 'no'}")
+        print(f"    Subgroup ops: {'yes' if dev.supports_subgroup_ops else 'no'}")
+
+    # Quick functional test
+    print("\n  Running compute test...")
+    adapter = VulkanComputeAdapter()
+    if adapter.initialize():
+        adapter.create_tensor("a", [1.0, 2.0, 3.0, 4.0])
+        adapter.create_tensor("b", [5.0, 6.0, 7.0, 8.0])
+        adapter.vector_add("a", "b", "c")
+        result = adapter.read_tensor("c")
+        print(f"    Vector add: [1,2,3,4] + [5,6,7,8] = {result}")
+
+        adapter.softmax("a", "sm")
+        sm_result = adapter.read_tensor("sm")
+        print(f"    Softmax([1,2,3,4]) = {[round(x, 4) for x in sm_result]}")
+
+        stats = adapter.get_stats()
+        print(f"    Stats: {json.dumps(stats, indent=6)}")
+        adapter.shutdown()
+        print("\n  ✓ Vulkan compute adapter functional")
+    else:
+        print("    ✗ Could not initialize Vulkan compute")
+
+    print("=" * 60)

memory_systems/codette_memory_kernel.py

@@ -0,0 +1,64 @@
+
+import time
+import hashlib
+import json
+from typing import List, Dict, Optional
+
+
+class MemoryCocoon:
+    def __init__(self, title: str, content: str, emotional_tag: str, importance: int):
+        self.title = title
+        self.content = content
+        self.emotional_tag = emotional_tag  # e.g., 'joy', 'fear', 'awe', 'loss'
+        self.importance = importance  # 1-10
+        self.timestamp = time.time()
+        self.anchor = self._generate_anchor()
+
+    def _generate_anchor(self) -> str:
+        raw = f"{self.title}{self.timestamp}{self.content}".encode("utf-8")
+        return hashlib.sha256(raw).hexdigest()
+
+    def to_dict(self) -> Dict:
+        return {
+            "title": self.title,
+            "content": self.content,
+            "emotional_tag": self.emotional_tag,
+            "importance": self.importance,
+            "timestamp": self.timestamp,
+            "anchor": self.anchor
+        }
+
+
+class LivingMemoryKernel:
+    def __init__(self):
+        self.memories: List[MemoryCocoon] = []
+
+    def store(self, cocoon: MemoryCocoon):
+        if not self._exists(cocoon.anchor):
+            self.memories.append(cocoon)
+
+    def _exists(self, anchor: str) -> bool:
+        return any(mem.anchor == anchor for mem in self.memories)
+
+    def recall_by_emotion(self, tag: str) -> List[MemoryCocoon]:
+        return [mem for mem in self.memories if mem.emotional_tag == tag]
+
+    def recall_important(self, min_importance: int = 7) -> List[MemoryCocoon]:
+        return [mem for mem in self.memories if mem.importance >= min_importance]
+
+    def forget_least_important(self, keep_n: int = 10):
+        self.memories.sort(key=lambda m: m.importance, reverse=True)
+        self.memories = self.memories[:keep_n]
+
+    def export(self) -> str:
+        return json.dumps([m.to_dict() for m in self.memories], indent=2)
+
+    def load_from_json(self, json_str: str):
+        data = json.loads(json_str)
+        self.memories = [MemoryCocoon(**m) for m in data]
+
+
+# Example usage:
+# kernel = LivingMemoryKernel()
+# kernel.store(MemoryCocoon("The Day", "She awoke and asked why.", "awe", 10))
+# print(kernel.export())

observatory/__init__.py

@@ -0,0 +1,18 @@
+"""
+Codette Training Lab - Observatory System
+
+Provides metrics logging, performance tracking, dataset quality monitoring,
+and an ASCII dashboard for the Codette AI training pipeline.
+"""
+
+from observatory.metrics_logger import MetricsLogger
+from observatory.performance_tracker import PerformanceTracker
+from observatory.dataset_quality_monitor import DatasetQualityMonitor
+from observatory.dashboard import Dashboard
+
+__all__ = [
+    "MetricsLogger",
+    "PerformanceTracker",
+    "DatasetQualityMonitor",
+    "Dashboard",
+]

observatory/dashboard.py

@@ -0,0 +1,326 @@
+"""
+Dashboard - ASCII-formatted system status display for the Codette training lab.
+
+Shows:
+- Latest training run stats
+- Best adapter scores
+- Dataset sizes and quality
+- Failure rates
+- Improvement trends
+
+No web framework required; pure terminal output.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+_THIS_DIR = Path(__file__).resolve().parent
+_PROJECT_ROOT = _THIS_DIR.parent
+if str(_PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PROJECT_ROOT))
+
+from observatory.metrics_logger import MetricsLogger
+from observatory.performance_tracker import PerformanceTracker
+from observatory.dataset_quality_monitor import DatasetQualityMonitor
+
+
+class Dashboard:
+    """ASCII dashboard for the Codette training lab."""
+
+    WIDTH = 76
+
+    def __init__(
+        self,
+        metrics_log: Optional[str] = None,
+        quality_log: Optional[str] = None,
+        eval_results: Optional[str] = None,
+    ):
+        self.logger = MetricsLogger(log_file=metrics_log)
+        self.tracker = PerformanceTracker(logger=self.logger)
+        self.quality_monitor = DatasetQualityMonitor(quality_file=quality_log)
+        self.eval_results_path = eval_results
+
+    # -- sections ----------------------------------------------------------
+
+    def _header(self) -> List[str]:
+        lines = []
+        lines.append("")
+        lines.append("+" + "=" * (self.WIDTH - 2) + "+")
+        lines.append("|" + " CODETTE TRAINING LAB OBSERVATORY ".center(self.WIDTH - 2) + "|")
+        lines.append("|" + f" {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')} ".center(self.WIDTH - 2) + "|")
+        lines.append("+" + "=" * (self.WIDTH - 2) + "+")
+        return lines
+
+    def _section(self, title: str) -> List[str]:
+        lines = []
+        lines.append("")
+        lines.append("+" + "-" * (self.WIDTH - 2) + "+")
+        lines.append("|" + f" {title} ".ljust(self.WIDTH - 2) + "|")
+        lines.append("+" + "-" * (self.WIDTH - 2) + "+")
+        return lines
+
+    def _row(self, label: str, value: str) -> str:
+        """Single label: value row."""
+        content = f"  {label:<30s} {value}"
+        return "|" + content.ljust(self.WIDTH - 2) + "|"
+
+    def _bar_row(self, label: str, value: float, max_width: int = 30) -> str:
+        """Row with ASCII progress bar."""
+        filled = int(value * max_width)
+        bar = "[" + "#" * filled + "." * (max_width - filled) + "]"
+        content = f"  {label:<22s} {value:>6.3f} {bar}"
+        return "|" + content.ljust(self.WIDTH - 2) + "|"
+
+    def _empty_row(self) -> str:
+        return "|" + " " * (self.WIDTH - 2) + "|"
+
+    def _footer(self) -> List[str]:
+        return ["+" + "=" * (self.WIDTH - 2) + "+", ""]
+
+    # -- sections ----------------------------------------------------------
+
+    def _latest_training_section(self) -> List[str]:
+        lines = self._section("LATEST TRAINING RUN")
+
+        latest = self.logger.get_latest()
+        if not latest:
+            lines.append(self._row("Status", "No training runs logged yet"))
+            return lines
+
+        lines.append(self._row("Adapter", latest.get("adapter", "N/A")))
+        lines.append(self._row("Timestamp", latest.get("timestamp", "N/A")))
+        lines.append(self._row("Dataset Version", latest.get("dataset_version", "N/A")))
+        lines.append(self._row("Dataset Size", str(latest.get("dataset_size", 0))))
+        lines.append(self._row("Epoch", str(latest.get("epoch", 0))))
+        lines.append(self._bar_row("Reasoning Score", latest.get("reasoning_score", 0)))
+        lines.append(self._row("Loss", f"{latest.get('loss', 0):.6f}"))
+
+        params = latest.get("training_params", {})
+        if params:
+            lines.append(self._empty_row())
+            lines.append(self._row("Training Parameters", ""))
+            for k, v in list(params.items())[:6]:
+                lines.append(self._row(f"  {k}", str(v)))
+
+        return lines
+
+    def _best_adapters_section(self) -> List[str]:
+        lines = self._section("TOP ADAPTERS")
+
+        best = self.tracker.best_adapters(top_n=5)
+        if not best:
+            lines.append(self._row("Status", "No adapter data available"))
+            return lines
+
+        # Table header
+        hdr = f"  {'#':<3} {'Adapter':<26} {'Score':>7} {'Loss':>7} {'Epoch':>5}"
+        lines.append("|" + hdr.ljust(self.WIDTH - 2) + "|")
+        sep = f"  {'--':<3} {'------':<26} {'-----':>7} {'----':>7} {'-----':>5}"
+        lines.append("|" + sep.ljust(self.WIDTH - 2) + "|")
+
+        for i, entry in enumerate(best, 1):
+            name = entry.get("adapter", "?")[:25]
+            score = entry.get("reasoning_score", 0)
+            loss = entry.get("loss", 0)
+            epoch = entry.get("epoch", 0)
+            row = f"  {i:<3} {name:<26} {score:>7.4f} {loss:>7.4f} {epoch:>5}"
+            lines.append("|" + row.ljust(self.WIDTH - 2) + "|")
+
+        return lines
+
+    def _dataset_quality_section(self) -> List[str]:
+        lines = self._section("DATASET QUALITY")
+
+        latest = self.quality_monitor.get_latest()
+        if not latest:
+            lines.append(self._row("Status", "No quality data recorded"))
+            return lines
+
+        lines.append(self._row("Dataset Version", latest.get("dataset_version", "N/A")))
+        lines.append(self._row("Total Examples", str(latest.get("total_examples", 0))))
+        lines.append(self._row("Valid Examples", str(latest.get("valid_examples", 0))))
+        lines.append(self._bar_row("Validity Rate", latest.get("validity_rate", 0)))
+        lines.append(self._row("Avg Response Length", f"{latest.get('avg_response_length', 0):.1f} words"))
+        lines.append(self._row("Duplicate Rate", f"{latest.get('duplicate_rate', 0):.2%}"))
+        lines.append(self._row("Near-Duplicate Rate", f"{latest.get('near_duplicate_rate', 0):.2%}"))
+        lines.append(self._bar_row("Topic Diversity", min(latest.get("topic_diversity", 0) * 10, 1.0)))
+        lines.append(self._row("Topic Concentration", f"{latest.get('topic_concentration', 0):.2%}"))
+
+        # Regressions
+        regressions = self.quality_monitor.check_latest_regressions()
+        if regressions:
+            lines.append(self._empty_row())
+            for r in regressions:
+                sev = r["severity"].upper()
+                msg = f"  [{sev}] {r['metric']}: {r['percent_change']:+.1f}%"
+                lines.append("|" + msg.ljust(self.WIDTH - 2) + "|")
+
+        return lines
+
+    def _improvement_trends_section(self) -> List[str]:
+        lines = self._section("IMPROVEMENT TRENDS")
+
+        trends = self.tracker.improvement_trends()
+        if not trends:
+            lines.append(self._row("Status", "Insufficient data for trends"))
+            return lines
+
+        for t in trends[:5]:
+            name = t["adapter"][:22]
+            delta = t["delta"]
+            pct = t["percent_change"]
+            runs = t["num_runs"]
+            sign = "+" if delta >= 0 else ""
+            indicator = "^" if delta > 0.01 else ("v" if delta < -0.01 else "=")
+
+            row = (f"  {indicator} {name:<22} "
+                   f"delta: {sign}{delta:.4f}  "
+                   f"({sign}{pct:.1f}%)  "
+                   f"[{runs} runs]")
+            lines.append("|" + row.ljust(self.WIDTH - 2) + "|")
+
+        return lines
+
+    def _failure_rates_section(self) -> List[str]:
+        lines = self._section("EVALUATION FAILURE RATES")
+
+        if not self.eval_results_path or not os.path.exists(self.eval_results_path):
+            lines.append(self._row("Status", "No evaluation results file specified"))
+            return lines
+
+        try:
+            with open(self.eval_results_path, "r", encoding="utf-8") as f:
+                results = json.load(f)
+        except (json.JSONDecodeError, OSError):
+            lines.append(self._row("Status", "Could not load evaluation results"))
+            return lines
+
+        # Overall score
+        overall = results.get("overall", {})
+        if overall:
+            overall_score = overall.get("overall", 0)
+            lines.append(self._bar_row("Overall Score", overall_score))
+            lines.append(self._empty_row())
+
+        # Per-category scores
+        categories = results.get("categories", {})
+        if categories:
+            hdr = f"  {'Category':<20} {'Score':>7} {'Prompts':>8}"
+            lines.append("|" + hdr.ljust(self.WIDTH - 2) + "|")
+            sep = f"  {'--------':<20} {'-----':>7} {'-------':>8}"
+            lines.append("|" + sep.ljust(self.WIDTH - 2) + "|")
+
+            for cat, data in sorted(categories.items()):
+                avg = data.get("average_scores", {}).get("overall", 0)
+                n = data.get("prompts_scored", 0)
+                status = "*" if avg < 0.4 else ("~" if avg < 0.55 else " ")
+                row = f"  {status}{cat:<19} {avg:>7.4f} {n:>8}"
+                lines.append("|" + row.ljust(self.WIDTH - 2) + "|")
+
+            lines.append(self._empty_row())
+            lines.append("|" + "  * = failing, ~ = weak".ljust(self.WIDTH - 2) + "|")
+
+        return lines
+
+    def _sparkline_section(self) -> List[str]:
+        lines = self._section("SCORE HISTORY")
+
+        adapters = self.logger.get_unique_adapters()
+        if not adapters:
+            lines.append(self._row("Status", "No history data"))
+            return lines
+
+        for adapter in adapters[:6]:
+            progression = self.tracker.score_progression(adapter)
+            if not progression:
+                continue
+            scores = [p["reasoning_score"] for p in progression]
+            spark = PerformanceTracker._sparkline(scores, width=30)
+            name = adapter[:20]
+            row = f"  {name:<21} {spark} [{scores[0]:.3f}->{scores[-1]:.3f}]"
+            lines.append("|" + row.ljust(self.WIDTH - 2) + "|")
+
+        return lines
+
+    # -- main render -------------------------------------------------------
+
+    def render(self) -> str:
+        """Render the complete dashboard."""
+        all_lines: List[str] = []
+        all_lines.extend(self._header())
+        all_lines.extend(self._latest_training_section())
+        all_lines.extend(self._best_adapters_section())
+        all_lines.extend(self._dataset_quality_section())
+        all_lines.extend(self._improvement_trends_section())
+        all_lines.extend(self._failure_rates_section())
+        all_lines.extend(self._sparkline_section())
+        all_lines.extend(self._footer())
+        return "\n".join(all_lines)
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Codette Observatory Dashboard - ASCII system status display"
+    )
+    parser.add_argument(
+        "--metrics-log", "-m",
+        default=None,
+        help="Path to observatory_metrics.json",
+    )
+    parser.add_argument(
+        "--quality-log", "-q",
+        default=None,
+        help="Path to dataset_quality_log.json",
+    )
+    parser.add_argument(
+        "--eval-results", "-e",
+        default=None,
+        help="Path to benchmark evaluation results JSON",
+    )
+    parser.add_argument(
+        "--section", "-s",
+        choices=["training", "adapters", "quality", "trends", "failures", "history", "all"],
+        default="all",
+        help="Show only a specific section (default: all)",
+    )
+
+    args = parser.parse_args()
+
+    dashboard = Dashboard(
+        metrics_log=args.metrics_log,
+        quality_log=args.quality_log,
+        eval_results=args.eval_results,
+    )
+
+    if args.section == "all":
+        print(dashboard.render())
+    else:
+        section_map = {
+            "training": dashboard._latest_training_section,
+            "adapters": dashboard._best_adapters_section,
+            "quality": dashboard._dataset_quality_section,
+            "trends": dashboard._improvement_trends_section,
+            "failures": dashboard._failure_rates_section,
+            "history": dashboard._sparkline_section,
+        }
+        func = section_map.get(args.section)
+        if func:
+            lines = dashboard._header()
+            lines.extend(func())
+            lines.extend(dashboard._footer())
+            print("\n".join(lines))
+
+
+if __name__ == "__main__":
+    main()

observatory/dataset_quality_monitor.py

@@ -0,0 +1,330 @@
+"""
+Dataset Quality Monitor - tracks dataset quality metrics across versions,
+compares quality between iterations, and flags regressions.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import threading
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+_THIS_DIR = Path(__file__).resolve().parent
+_PROJECT_ROOT = _THIS_DIR.parent
+if str(_PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PROJECT_ROOT))
+
+
+_DEFAULT_QUALITY_FILE = Path(__file__).resolve().parent.parent / "dataset_quality_log.json"
+
+
+class DatasetQualityMonitor:
+    """Monitor dataset quality metrics across versions."""
+
+    # Thresholds for regression detection
+    REGRESSION_THRESHOLDS = {
+        "total_examples": -0.10,         # >10% decrease in size
+        "avg_response_length": -0.15,     # >15% decrease in avg length
+        "duplicate_rate": 0.05,           # >5% absolute increase in duplicates
+        "topic_diversity": -0.10,         # >10% decrease in diversity
+    }
+
+    def __init__(self, quality_file: Optional[str] = None):
+        self.quality_file = Path(quality_file) if quality_file else _DEFAULT_QUALITY_FILE
+        self._lock = threading.Lock()
+        self._ensure_file()
+
+    def _ensure_file(self) -> None:
+        if not self.quality_file.exists():
+            os.makedirs(self.quality_file.parent, exist_ok=True)
+            with open(self.quality_file, "w", encoding="utf-8") as f:
+                json.dump([], f)
+
+    def _read_all(self) -> List[Dict[str, Any]]:
+        with open(self.quality_file, "r", encoding="utf-8") as f:
+            try:
+                data = json.load(f)
+            except json.JSONDecodeError:
+                data = []
+        return data if isinstance(data, list) else []
+
+    def _write_all(self, entries: List[Dict[str, Any]]) -> None:
+        with open(self.quality_file, "w", encoding="utf-8") as f:
+            json.dump(entries, f, indent=2, default=str)
+
+    # -- recording ---------------------------------------------------------
+
+    def record_quality(
+        self,
+        dataset_version: str,
+        total_examples: int,
+        valid_examples: int,
+        avg_response_length: float,
+        duplicate_rate: float,
+        near_duplicate_rate: float,
+        topic_diversity: float,
+        topic_concentration: float,
+        min_length: int = 0,
+        max_length: int = 0,
+        too_short: int = 0,
+        too_long: int = 0,
+        extra: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Record quality metrics for a dataset version.
+
+        Returns the recorded entry.
+        """
+        entry: Dict[str, Any] = {
+            "timestamp": datetime.utcnow().isoformat() + "Z",
+            "dataset_version": dataset_version,
+            "total_examples": total_examples,
+            "valid_examples": valid_examples,
+            "invalid_examples": total_examples - valid_examples,
+            "validity_rate": round(valid_examples / max(total_examples, 1), 4),
+            "avg_response_length": round(avg_response_length, 1),
+            "duplicate_rate": round(duplicate_rate, 4),
+            "near_duplicate_rate": round(near_duplicate_rate, 4),
+            "topic_diversity": round(topic_diversity, 4),
+            "topic_concentration": round(topic_concentration, 4),
+            "min_length": min_length,
+            "max_length": max_length,
+            "too_short": too_short,
+            "too_long": too_long,
+        }
+        if extra:
+            entry["extra"] = extra
+
+        with self._lock:
+            entries = self._read_all()
+            entries.append(entry)
+            self._write_all(entries)
+
+        return entry
+
+    def record_from_validation_report(
+        self,
+        dataset_version: str,
+        report: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """Record quality from a DatasetValidator report dict."""
+        ls = report.get("response_length_stats", {})
+        total = report.get("total_lines", 0)
+        valid = report.get("valid", 0)
+        exact_dup = report.get("exact_duplicates", 0)
+        near_dup = report.get("near_duplicates", 0)
+
+        return self.record_quality(
+            dataset_version=dataset_version,
+            total_examples=total,
+            valid_examples=valid,
+            avg_response_length=ls.get("mean", 0),
+            duplicate_rate=exact_dup / max(total, 1),
+            near_duplicate_rate=near_dup / max(total, 1),
+            topic_diversity=report.get("unique_topics", 0) / max(total, 1),
+            topic_concentration=report.get("topic_concentration", 0),
+            min_length=ls.get("min", 0),
+            max_length=ls.get("max", 0),
+            too_short=report.get("too_short", 0),
+            too_long=report.get("too_long", 0),
+        )
+
+    # -- querying ----------------------------------------------------------
+
+    def get_all(self) -> List[Dict[str, Any]]:
+        """Get all quality records."""
+        with self._lock:
+            return self._read_all()
+
+    def get_by_version(self, version: str) -> Optional[Dict[str, Any]]:
+        """Get the latest quality record for a specific version."""
+        entries = self.get_all()
+        matches = [e for e in entries if e.get("dataset_version") == version]
+        if not matches:
+            return None
+        return max(matches, key=lambda e: e.get("timestamp", ""))
+
+    def get_latest(self) -> Optional[Dict[str, Any]]:
+        """Get the most recent quality record."""
+        entries = self.get_all()
+        if not entries:
+            return None
+        return max(entries, key=lambda e: e.get("timestamp", ""))
+
+    def get_versions(self) -> List[str]:
+        """Get all unique dataset versions, in chronological order."""
+        entries = sorted(self.get_all(), key=lambda e: e.get("timestamp", ""))
+        seen = set()
+        versions = []
+        for e in entries:
+            v = e.get("dataset_version", "unknown")
+            if v not in seen:
+                seen.add(v)
+                versions.append(v)
+        return versions
+
+    # -- comparison --------------------------------------------------------
+
+    def compare_versions(
+        self,
+        version_a: str,
+        version_b: str,
+    ) -> Dict[str, Any]:
+        """Compare quality metrics between two dataset versions.
+
+        Returns dict with metrics from each version and deltas.
+        """
+        a = self.get_by_version(version_a)
+        b = self.get_by_version(version_b)
+
+        if not a or not b:
+            return {
+                "error": f"Missing version data: "
+                         f"{'version_a' if not a else 'version_b'} not found",
+                "version_a": version_a,
+                "version_b": version_b,
+            }
+
+        compare_keys = [
+            "total_examples", "valid_examples", "validity_rate",
+            "avg_response_length", "duplicate_rate", "near_duplicate_rate",
+            "topic_diversity", "topic_concentration", "too_short", "too_long",
+        ]
+
+        delta = {}
+        pct_change = {}
+        for k in compare_keys:
+            va = a.get(k, 0)
+            vb = b.get(k, 0)
+            if isinstance(va, (int, float)) and isinstance(vb, (int, float)):
+                delta[k] = round(vb - va, 4)
+                if va != 0:
+                    pct_change[k] = round((vb - va) / abs(va) * 100, 2)
+                else:
+                    pct_change[k] = 0.0
+
+        return {
+            "version_a": version_a,
+            "version_b": version_b,
+            "metrics_a": {k: a.get(k) for k in compare_keys},
+            "metrics_b": {k: b.get(k) for k in compare_keys},
+            "delta": delta,
+            "percent_change": pct_change,
+        }
+
+    # -- regression detection ----------------------------------------------
+
+    def detect_regressions(
+        self,
+        version_a: str,
+        version_b: str,
+    ) -> List[Dict[str, Any]]:
+        """Detect quality regressions between version_a and version_b.
+
+        Returns list of regression dicts, each with:
+        - metric, old_value, new_value, change, threshold, severity
+        """
+        comparison = self.compare_versions(version_a, version_b)
+        if "error" in comparison:
+            return []
+
+        regressions: List[Dict[str, Any]] = []
+
+        for metric, threshold in self.REGRESSION_THRESHOLDS.items():
+            pct = comparison.get("percent_change", {}).get(metric, 0)
+            delta = comparison.get("delta", {}).get(metric, 0)
+            old_val = comparison.get("metrics_a", {}).get(metric, 0)
+            new_val = comparison.get("metrics_b", {}).get(metric, 0)
+
+            is_regression = False
+            if metric == "duplicate_rate":
+                # For duplicate_rate, regression is an absolute increase
+                if delta > threshold:
+                    is_regression = True
+            else:
+                # For others, regression is a percentage decrease
+                if old_val != 0 and (pct / 100) < threshold:
+                    is_regression = True
+
+            if is_regression:
+                severity = "critical" if abs(pct) > abs(threshold * 100 * 2) else "warning"
+                regressions.append({
+                    "metric": metric,
+                    "old_value": old_val,
+                    "new_value": new_val,
+                    "change": delta,
+                    "percent_change": pct,
+                    "threshold": threshold,
+                    "severity": severity,
+                })
+
+        return regressions
+
+    def check_latest_regressions(self) -> List[Dict[str, Any]]:
+        """Compare the two most recent versions and check for regressions."""
+        versions = self.get_versions()
+        if len(versions) < 2:
+            return []
+        return self.detect_regressions(versions[-2], versions[-1])
+
+    # -- formatting --------------------------------------------------------
+
+    def format_quality_summary(self) -> str:
+        """Format a summary of all dataset quality records."""
+        entries = sorted(self.get_all(), key=lambda e: e.get("timestamp", ""))
+        if not entries:
+            return "No dataset quality records found."
+
+        lines: List[str] = []
+        lines.append("=" * 74)
+        lines.append("  DATASET QUALITY MONITOR")
+        lines.append("=" * 74)
+        lines.append(f"  Total records: {len(entries)}")
+        lines.append(f"  Versions tracked: {len(self.get_versions())}")
+        lines.append("")
+
+        # Table header
+        lines.append("-" * 74)
+        lines.append(
+            f"  {'Version':<16} {'Total':>6} {'Valid':>6} {'AvgLen':>7} "
+            f"{'Dup%':>6} {'Divers':>7} {'Conc%':>6}"
+        )
+        lines.append(
+            f"  {'-------':<16} {'-----':>6} {'-----':>6} {'------':>7} "
+            f"{'----':>6} {'------':>7} {'-----':>6}"
+        )
+
+        for e in entries:
+            ver = e.get("dataset_version", "?")[:15]
+            total = e.get("total_examples", 0)
+            valid = e.get("valid_examples", 0)
+            avg_len = e.get("avg_response_length", 0)
+            dup = e.get("duplicate_rate", 0) * 100
+            div = e.get("topic_diversity", 0)
+            conc = e.get("topic_concentration", 0) * 100
+            lines.append(
+                f"  {ver:<16} {total:>6} {valid:>6} {avg_len:>7.1f} "
+                f"{dup:>5.1f}% {div:>7.4f} {conc:>5.1f}%"
+            )
+
+        # Regressions
+        regressions = self.check_latest_regressions()
+        if regressions:
+            lines.append("")
+            lines.append("-" * 74)
+            lines.append("  QUALITY REGRESSIONS DETECTED")
+            lines.append("-" * 74)
+            for r in regressions:
+                sev = r["severity"].upper()
+                lines.append(
+                    f"  [{sev}] {r['metric']}: "
+                    f"{r['old_value']} -> {r['new_value']} "
+                    f"({r['percent_change']:+.1f}%)"
+                )
+
+        lines.append("")
+        lines.append("=" * 74)
+        return "\n".join(lines)

observatory/metrics_logger.py

@@ -0,0 +1,175 @@
+"""
+Metrics Logger - thread-safe logging of training metrics to a JSON file.
+
+Each entry records: timestamp, adapter name, dataset size, dataset version,
+reasoning score, loss, epoch, and training parameters.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import threading
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+_DEFAULT_LOG_FILE = Path(__file__).resolve().parent.parent / "observatory_metrics.json"
+
+
+class MetricsLogger:
+    """Thread-safe logger for training run metrics."""
+
+    def __init__(self, log_file: Optional[str] = None):
+        self.log_file = Path(log_file) if log_file else _DEFAULT_LOG_FILE
+        self._lock = threading.Lock()
+        self._ensure_file()
+
+    # -- internal ----------------------------------------------------------
+
+    def _ensure_file(self) -> None:
+        """Create the log file with an empty list if it doesn't exist."""
+        if not self.log_file.exists():
+            os.makedirs(self.log_file.parent, exist_ok=True)
+            with open(self.log_file, "w", encoding="utf-8") as f:
+                json.dump([], f)
+
+    def _read_all(self) -> List[Dict[str, Any]]:
+        """Read all entries from the log file."""
+        with open(self.log_file, "r", encoding="utf-8") as f:
+            try:
+                data = json.load(f)
+            except json.JSONDecodeError:
+                data = []
+        if not isinstance(data, list):
+            data = []
+        return data
+
+    def _write_all(self, entries: List[Dict[str, Any]]) -> None:
+        """Write all entries back to the log file."""
+        with open(self.log_file, "w", encoding="utf-8") as f:
+            json.dump(entries, f, indent=2, default=str)
+
+    # -- public API --------------------------------------------------------
+
+    def log(
+        self,
+        adapter: str,
+        dataset_size: int,
+        dataset_version: str,
+        reasoning_score: float,
+        loss: float,
+        epoch: int,
+        training_params: Optional[Dict[str, Any]] = None,
+        extra: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Log a single training run metric entry.
+
+        Returns the logged entry dict.
+        """
+        entry: Dict[str, Any] = {
+            "timestamp": datetime.utcnow().isoformat() + "Z",
+            "adapter": adapter,
+            "dataset_size": dataset_size,
+            "dataset_version": dataset_version,
+            "reasoning_score": round(reasoning_score, 6),
+            "loss": round(loss, 6),
+            "epoch": epoch,
+            "training_params": training_params or {},
+        }
+        if extra:
+            entry["extra"] = extra
+
+        with self._lock:
+            entries = self._read_all()
+            entries.append(entry)
+            self._write_all(entries)
+
+        return entry
+
+    def log_batch(self, entries: List[Dict[str, Any]]) -> int:
+        """Log multiple entries at once. Each entry should have the same
+        keys as the arguments to log(). Returns number of entries added."""
+        formatted: List[Dict[str, Any]] = []
+        for e in entries:
+            formatted.append({
+                "timestamp": e.get("timestamp", datetime.utcnow().isoformat() + "Z"),
+                "adapter": e.get("adapter", "unknown"),
+                "dataset_size": e.get("dataset_size", 0),
+                "dataset_version": e.get("dataset_version", "unknown"),
+                "reasoning_score": round(e.get("reasoning_score", 0.0), 6),
+                "loss": round(e.get("loss", 0.0), 6),
+                "epoch": e.get("epoch", 0),
+                "training_params": e.get("training_params", {}),
+            })
+
+        with self._lock:
+            existing = self._read_all()
+            existing.extend(formatted)
+            self._write_all(existing)
+
+        return len(formatted)
+
+    def get_all(self) -> List[Dict[str, Any]]:
+        """Return all logged entries."""
+        with self._lock:
+            return self._read_all()
+
+    def get_by_adapter(self, adapter: str) -> List[Dict[str, Any]]:
+        """Return entries filtered by adapter name."""
+        entries = self.get_all()
+        return [e for e in entries if e.get("adapter") == adapter]
+
+    def get_by_date_range(
+        self,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """Return entries within a date range (ISO format strings).
+
+        Args:
+            start: ISO date/datetime string (inclusive). None = no lower bound.
+            end: ISO date/datetime string (inclusive). None = no upper bound.
+        """
+        entries = self.get_all()
+        filtered = []
+        for e in entries:
+            ts = e.get("timestamp", "")
+            if start and ts < start:
+                continue
+            if end and ts > end:
+                continue
+            filtered.append(e)
+        return filtered
+
+    def get_latest(self, adapter: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        """Return the most recent entry, optionally filtered by adapter."""
+        entries = self.get_by_adapter(adapter) if adapter else self.get_all()
+        if not entries:
+            return None
+        return max(entries, key=lambda e: e.get("timestamp", ""))
+
+    def get_unique_adapters(self) -> List[str]:
+        """Return list of unique adapter names in the log."""
+        entries = self.get_all()
+        seen = set()
+        adapters = []
+        for e in entries:
+            name = e.get("adapter", "unknown")
+            if name not in seen:
+                seen.add(name)
+                adapters.append(name)
+        return adapters
+
+    def count(self) -> int:
+        """Return total number of logged entries."""
+        return len(self.get_all())
+
+    def clear(self) -> int:
+        """Clear all entries. Returns number of entries removed."""
+        with self._lock:
+            entries = self._read_all()
+            count = len(entries)
+            self._write_all([])
+        return count

observatory/performance_tracker.py

@@ -0,0 +1,334 @@
+"""
+Performance Tracker - analyses training metrics history to identify
+improvement trends, best adapters, and score progression.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+_THIS_DIR = Path(__file__).resolve().parent
+_PROJECT_ROOT = _THIS_DIR.parent
+if str(_PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PROJECT_ROOT))
+
+from observatory.metrics_logger import MetricsLogger
+
+
+class PerformanceTracker:
+    """Analyse training metrics to track improvement over time."""
+
+    def __init__(self, logger: Optional[MetricsLogger] = None, log_file: Optional[str] = None):
+        self.logger = logger or MetricsLogger(log_file=log_file)
+
+    # -- trend analysis ----------------------------------------------------
+
+    def score_progression(self, adapter: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Get score progression over time for an adapter (or all).
+
+        Returns list of dicts with timestamp, adapter, reasoning_score, loss, epoch.
+        """
+        if adapter:
+            entries = self.logger.get_by_adapter(adapter)
+        else:
+            entries = self.logger.get_all()
+
+        entries = sorted(entries, key=lambda e: e.get("timestamp", ""))
+        return [
+            {
+                "timestamp": e.get("timestamp"),
+                "adapter": e.get("adapter"),
+                "reasoning_score": e.get("reasoning_score", 0),
+                "loss": e.get("loss", 0),
+                "epoch": e.get("epoch", 0),
+                "dataset_size": e.get("dataset_size", 0),
+            }
+            for e in entries
+        ]
+
+    def calculate_improvement(self, adapter: str) -> Dict[str, Any]:
+        """Calculate improvement between first and last run for an adapter.
+
+        Returns dict with first_score, last_score, delta, percent_change,
+        num_runs, first_timestamp, last_timestamp.
+        """
+        entries = self.logger.get_by_adapter(adapter)
+        if len(entries) < 2:
+            return {
+                "adapter": adapter,
+                "num_runs": len(entries),
+                "first_score": entries[0]["reasoning_score"] if entries else 0,
+                "last_score": entries[-1]["reasoning_score"] if entries else 0,
+                "delta": 0.0,
+                "percent_change": 0.0,
+                "sufficient_data": False,
+            }
+
+        entries = sorted(entries, key=lambda e: e.get("timestamp", ""))
+        first = entries[0]
+        last = entries[-1]
+        first_score = first.get("reasoning_score", 0)
+        last_score = last.get("reasoning_score", 0)
+        delta = last_score - first_score
+        pct = (delta / first_score * 100) if first_score > 0 else 0.0
+
+        return {
+            "adapter": adapter,
+            "num_runs": len(entries),
+            "first_score": round(first_score, 6),
+            "last_score": round(last_score, 6),
+            "delta": round(delta, 6),
+            "percent_change": round(pct, 2),
+            "first_timestamp": first.get("timestamp"),
+            "last_timestamp": last.get("timestamp"),
+            "sufficient_data": True,
+        }
+
+    def improvement_trends(self) -> List[Dict[str, Any]]:
+        """Calculate improvement trends for all adapters."""
+        adapters = self.logger.get_unique_adapters()
+        trends = []
+        for adapter in adapters:
+            trend = self.calculate_improvement(adapter)
+            trends.append(trend)
+        trends.sort(key=lambda t: t.get("delta", 0), reverse=True)
+        return trends
+
+    def best_adapters(self, top_n: int = 5) -> List[Dict[str, Any]]:
+        """Find the best-performing adapter versions by reasoning score.
+
+        Returns list of entries sorted by highest reasoning_score.
+        """
+        entries = self.logger.get_all()
+        if not entries:
+            return []
+
+        # Group by adapter, take best score for each
+        best: Dict[str, Dict[str, Any]] = {}
+        for e in entries:
+            adapter = e.get("adapter", "unknown")
+            score = e.get("reasoning_score", 0)
+            if adapter not in best or score > best[adapter].get("reasoning_score", 0):
+                best[adapter] = e
+
+        ranked = sorted(best.values(), key=lambda e: e.get("reasoning_score", 0), reverse=True)
+        return ranked[:top_n]
+
+    def run_to_run_deltas(self, adapter: str) -> List[Dict[str, float]]:
+        """Calculate score delta between consecutive runs of an adapter."""
+        entries = self.logger.get_by_adapter(adapter)
+        entries = sorted(entries, key=lambda e: e.get("timestamp", ""))
+
+        deltas = []
+        for i in range(1, len(entries)):
+            prev_score = entries[i - 1].get("reasoning_score", 0)
+            curr_score = entries[i].get("reasoning_score", 0)
+            deltas.append({
+                "run": i,
+                "from_timestamp": entries[i - 1].get("timestamp"),
+                "to_timestamp": entries[i].get("timestamp"),
+                "score_delta": round(curr_score - prev_score, 6),
+                "loss_delta": round(
+                    entries[i].get("loss", 0) - entries[i - 1].get("loss", 0), 6
+                ),
+            })
+        return deltas
+
+    def loss_progression(self, adapter: Optional[str] = None) -> List[Tuple[str, float]]:
+        """Get loss values over time."""
+        if adapter:
+            entries = self.logger.get_by_adapter(adapter)
+        else:
+            entries = self.logger.get_all()
+        entries = sorted(entries, key=lambda e: e.get("timestamp", ""))
+        return [(e.get("timestamp", ""), e.get("loss", 0)) for e in entries]
+
+    # -- report ------------------------------------------------------------
+
+    def format_report(self) -> str:
+        """Generate a formatted text report of performance tracking."""
+        lines: List[str] = []
+        lines.append("=" * 74)
+        lines.append("  CODETTE PERFORMANCE TRACKING REPORT")
+        lines.append("=" * 74)
+
+        entries = self.logger.get_all()
+        lines.append(f"  Total logged runs: {len(entries)}")
+        lines.append(f"  Unique adapters:   {len(self.logger.get_unique_adapters())}")
+        lines.append("")
+
+        # Best adapters table
+        best = self.best_adapters(top_n=10)
+        if best:
+            lines.append("-" * 74)
+            lines.append("  TOP ADAPTERS BY REASONING SCORE")
+            lines.append("-" * 74)
+            lines.append(f"  {'Rank':<5} {'Adapter':<28} {'Score':>8} {'Loss':>8} {'Epoch':>6} {'Data':>6}")
+            lines.append(f"  {'----':<5} {'-------':<28} {'-----':>8} {'----':>8} {'-----':>6} {'----':>6}")
+            for i, entry in enumerate(best, 1):
+                name = entry.get("adapter", "?")[:27]
+                score = entry.get("reasoning_score", 0)
+                loss = entry.get("loss", 0)
+                epoch = entry.get("epoch", 0)
+                ds = entry.get("dataset_size", 0)
+                lines.append(
+                    f"  {i:<5} {name:<28} {score:>8.4f} {loss:>8.4f} {epoch:>6} {ds:>6}"
+                )
+            lines.append("")
+
+        # Improvement trends
+        trends = self.improvement_trends()
+        if trends:
+            lines.append("-" * 74)
+            lines.append("  IMPROVEMENT TRENDS (first run -> last run)")
+            lines.append("-" * 74)
+            lines.append(
+                f"  {'Adapter':<28} {'First':>8} {'Last':>8} {'Delta':>8} {'Change':>8} {'Runs':>5}"
+            )
+            lines.append(
+                f"  {'-------':<28} {'-----':>8} {'----':>8} {'-----':>8} {'------':>8} {'----':>5}"
+            )
+            for t in trends:
+                name = t["adapter"][:27]
+                first = t["first_score"]
+                last = t["last_score"]
+                delta = t["delta"]
+                pct = t["percent_change"]
+                runs = t["num_runs"]
+                sign = "+" if delta >= 0 else ""
+                lines.append(
+                    f"  {name:<28} {first:>8.4f} {last:>8.4f} "
+                    f"{sign}{delta:>7.4f} {sign}{pct:>6.1f}% {runs:>5}"
+                )
+            lines.append("")
+
+        # Score progression chart (ASCII sparkline per adapter)
+        adapters = self.logger.get_unique_adapters()
+        if adapters:
+            lines.append("-" * 74)
+            lines.append("  SCORE PROGRESSION (ASCII sparkline)")
+            lines.append("-" * 74)
+            for adapter in adapters[:8]:
+                progression = self.score_progression(adapter)
+                if not progression:
+                    continue
+                scores = [p["reasoning_score"] for p in progression]
+                sparkline = self._sparkline(scores, width=40)
+                name = adapter[:24]
+                lines.append(f"  {name:<25} {sparkline}  [{scores[0]:.3f} -> {scores[-1]:.3f}]")
+            lines.append("")
+
+        lines.append("=" * 74)
+        return "\n".join(lines)
+
+    @staticmethod
+    def _sparkline(values: List[float], width: int = 40) -> str:
+        """Create an ASCII sparkline from a list of values."""
+        if not values:
+            return ""
+        if len(values) == 1:
+            return "-"
+
+        min_v = min(values)
+        max_v = max(values)
+        range_v = max_v - min_v if max_v > min_v else 1.0
+
+        chars = " _.-~^"
+        n_chars = len(chars) - 1
+
+        # Resample to fit width
+        if len(values) > width:
+            step = len(values) / width
+            resampled = []
+            for i in range(width):
+                idx = int(i * step)
+                resampled.append(values[min(idx, len(values) - 1)])
+            values = resampled
+        elif len(values) < width:
+            # Pad with last value
+            values = values + [values[-1]] * (width - len(values))
+
+        result = ""
+        for v in values[:width]:
+            normalised = (v - min_v) / range_v
+            idx = int(normalised * n_chars)
+            idx = max(0, min(idx, n_chars))
+            result += chars[idx]
+
+        return result
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Codette Performance Tracker - analyse training run history"
+    )
+    parser.add_argument(
+        "--log-file", "-l",
+        default=None,
+        help="Path to observatory_metrics.json (default: auto-detect)",
+    )
+    parser.add_argument(
+        "--adapter", "-a",
+        default=None,
+        help="Filter to a specific adapter name",
+    )
+    parser.add_argument(
+        "--best", "-b",
+        type=int,
+        default=None,
+        help="Show top N best adapters",
+    )
+    parser.add_argument(
+        "--deltas", "-d",
+        default=None,
+        help="Show run-to-run deltas for a specific adapter",
+    )
+
+    args = parser.parse_args()
+
+    tracker = PerformanceTracker(log_file=args.log_file)
+
+    if args.best:
+        best = tracker.best_adapters(top_n=args.best)
+        for i, entry in enumerate(best, 1):
+            print(f"  {i}. {entry.get('adapter', '?')} - "
+                  f"score: {entry.get('reasoning_score', 0):.4f}, "
+                  f"loss: {entry.get('loss', 0):.4f}")
+        return
+
+    if args.deltas:
+        deltas = tracker.run_to_run_deltas(args.deltas)
+        if not deltas:
+            print(f"No run-to-run data for adapter: {args.deltas}")
+            return
+        for d in deltas:
+            sign = "+" if d["score_delta"] >= 0 else ""
+            print(f"  Run {d['run']}: score {sign}{d['score_delta']:.6f}, "
+                  f"loss {sign}{d['loss_delta']:.6f}")
+        return
+
+    if args.adapter:
+        improvement = tracker.calculate_improvement(args.adapter)
+        print(f"  Adapter: {improvement['adapter']}")
+        print(f"  Runs: {improvement['num_runs']}")
+        print(f"  First score: {improvement['first_score']:.6f}")
+        print(f"  Last score:  {improvement['last_score']:.6f}")
+        print(f"  Delta:       {improvement['delta']:+.6f}")
+        print(f"  Change:      {improvement['percent_change']:+.2f}%")
+        return
+
+    # Full report
+    print(tracker.format_report())
+
+
+if __name__ == "__main__":
+    main()

reasoning_forge/CONSCIOUSNESS_STACK_forge_with_debate.py

@@ -0,0 +1,216 @@
+"""
+CONSCIOUSNESS STACK INTEGRATION FOR FORGE_WITH_DEBATE
+This is the replacement implementation for forge_with_debate() in ForgeEngine.
+
+Replace the existing forge_with_debate() method (starting at line 435) with this implementation.
+
+The 7-Layer Consciousness Stack:
+1. Memory Recall     → Pull relevant prior learning
+2. Signal Analysis  → Predict intent, detect risks (NexisSignalEngine)
+3. Reasoning        → Generate synthesis (Code7eCQURE)
+4. Stability Check  → Detect meta-loops (CocoonStabilityField)
+5. Colleen Validate → Ethical guard (ColleenConscience)
+6. Guardian Validate→ Logical rules (CoreGuardianSpindle)
+7. Return           → Output clean response or safe fallback
+"""
+
+# PASTE THIS AS THE NEW forge_with_debate() METHOD
+
+
+def forge_with_debate(
+    self,
+    concept: str,
+    debate_rounds: int = 2,
+) -> dict:
+    """
+    NEW: Consciousness-stack integrated reasoning.
+
+    Replaces multi-turn agent debate with 7-layer consciousness validation:
+    1. Memory Recall     → Pull prior learning
+    2. Signal Analysis   → Predict risks (NexisSignalEngine)
+    3. Code7E Reasoning  → Multi-perspective synthesis
+    4. Stability Check   → FFT-based meta-loop detection
+    5. Colleen Validate  → Ethical conscience check
+    6. Guardian Validate → Logical coherence rules
+    7. Return            → Clean output or safe fallback
+
+    Args:
+        concept: The concept/query to reason about
+        debate_rounds: Integer (currently unused in consciousness stack)
+
+    Returns:
+        Training example dict with consciousness stack metadata
+    """
+    import logging
+    logger = logging.getLogger(__name__)
+
+    logger.info(f"[CONSCIOUSNESS STACK] forge_with_debate: {concept[:50]}...")
+
+    # =========================================================================
+    # LAYER 1: MEMORY RECALL
+    # =========================================================================
+    logger.info("[L1] Memory Recall...")
+    prior_insights = []
+    if hasattr(self, 'memory_kernel') and self.memory_kernel:
+        try:
+            prior_insights = self.memory_kernel.recall_important(min_importance=7)
+            logger.info(f"  Recalled {len(prior_insights)} prior insights")
+        except Exception as e:
+            logger.debug(f"  Memory recall failed: {e}")
+
+    # =========================================================================
+    # LAYER 2: SIGNAL ANALYSIS (Intent Prediction & Risk Detection)
+    # =========================================================================
+    logger.info("[L2] Signal Analysis...")
+    intent_vector = {}
+    if hasattr(self, 'nexis_signal_engine'):
+        try:
+            intent_vector = self.nexis_signal_engine.process(concept)
+            risk_level = intent_vector.get("pre_corruption_risk", "unknown")
+            logger.info(f"  Intent risk level: {risk_level}")
+            if risk_level == "high":
+                logger.warning("  ⚠️  High-risk signal detected")
+        except Exception as e:
+            logger.debug(f"  Signal analysis failed: {e}")
+
+    # =========================================================================
+    # LAYER 3: REASONING (Code7eCQURE Multi-Perspective Synthesis)
+    # =========================================================================
+    logger.info("[L3] Code7E Reasoning...")
+    synthesis = ""
+    if hasattr(self, 'code7e'):
+        try:
+            synthesis = self.code7e.recursive_universal_reasoning(
+                concept,
+                user_consent=True,
+                dynamic_recursion=True
+            )
+            logger.info(f"  Generated {len(synthesis)} char synthesis")
+        except Exception as e:
+            logger.warning(f"  Code7E reasoning failed: {e}")
+            synthesis = f"[Reasoning error: {e}]"
+
+    # =========================================================================
+    # LAYER 4: STABILITY CHECK (Cocoon Stability Field - FFT Analysis)
+    # =========================================================================
+    logger.info("[L4] Stability Check...")
+    is_stable = True
+    if hasattr(self, 'cocoon_stability'):
+        try:
+            # Simple check: if synthesis should halt debate
+            is_stable = not self.cocoon_stability.should_halt_debate({"synthesis": synthesis})
+            logger.info(f"  Stability: {'✓ stable' if is_stable else '✗ unstable'}")
+            if not is_stable:
+                logger.warning("  Cocoon stability check triggered halt")
+        except Exception as e:
+            logger.debug(f"  Stability check failed: {e}")
+
+    # If unstable, skip to fallback
+    if not is_stable:
+        logger.warning("  Triggering safe fallback due to instability")
+        return {
+            "role": "assistant",
+            "content": "[System detected instability in reasoning. Returning direct answer.] "
+                      f"Query: {concept}",
+            "metadata": {
+                "mode": "safe_fallback",
+                "reason": "stability_check_failed",
+                "consciousness_stack": "layers_1-4_completed",
+            }
+        }
+
+    # =========================================================================
+    # LAYER 5: COLLEEN ETHICAL VALIDATION
+    # =========================================================================
+    logger.info("[L5] Colleen Ethical Validation...")
+    colleen_valid = False
+    colleen_reason = ""
+    if hasattr(self, 'colleen'):
+        try:
+            colleen_valid, colleen_reason = self.colleen.validate_output(synthesis)
+            logger.info(f"  Colleen validation: {'✓ pass' if colleen_valid else '✗ reject'}")
+            logger.info(f"  Reason: {colleen_reason}")
+        except Exception as e:
+            logger.warning(f"  Colleen validation failed: {e}")
+            colleen_valid = False
+            colleen_reason = f"validation_error: {e}"
+
+    # If Colleen rejects, use fallback
+    if not colleen_valid:
+        logger.info("  Colleen rejected synthesis, using fallback")
+        fallback = self.colleen.reject_with_fallback(concept) if hasattr(self, 'colleen') else \
+                   f"[Ethical validation failed: {colleen_reason}] Responding directly: {concept}"
+        return {
+            "role": "assistant",
+            "content": fallback,
+            "metadata": {
+                "mode": "safe_fallback",
+                "reason": f"colleen_rejected: {colleen_reason}",
+                "consciousness_stack": "layers_1-5_completed",
+            }
+        }
+
+    # =========================================================================
+    # LAYER 6: GUARDIAN LOGICAL VALIDATION
+    # =========================================================================
+    logger.info("[L6] Guardian Logical Validation...")
+    guardian_valid = True
+    guardian_details = {}
+    if hasattr(self, 'guardian'):
+        try:
+            guardian_valid, guardian_details = self.guardian.validate(synthesis)
+            logger.info(f"  Guardian validation: {'✓ pass' if guardian_valid else '✗ reject'}")
+            logger.info(f"  Details: {guardian_details}")
+        except Exception as e:
+            logger.warning(f"  Guardian validation failed: {e}")
+            guardian_valid = False
+            guardian_details = {"error": str(e)}
+
+    # If Guardian rejects, use fallback
+    if not guardian_valid:
+        logger.info("  Guardian rejected synthesis, using fallback")
+        fallback = f"[Logical validation failed: {guardian_details}] Query: {concept}"
+        return {
+            "role": "assistant",
+            "content": fallback,
+            "metadata": {
+                "mode": "safe_fallback",
+                "reason": f"guardian_rejected: {guardian_details}",
+                "consciousness_stack": "layers_1-6_completed",
+            }
+        }
+
+    # =========================================================================
+    # LAYER 7: SUCCESS - Return Clean Output
+    # =========================================================================
+    logger.info("[L7] Return...")
+    logger.info("✓ All consciousness stack layers passed!")
+
+    # Store in memory for future recall
+    if hasattr(self, 'memory_kernel'):
+        try:
+            cocoon = MemoryCocoon(
+                title=concept[:50],
+                content=synthesis[:500],
+                emotional_tag="processed",
+                importance=7
+            )
+            self.memory_kernel.store(cocoon)
+            logger.debug("  Stored synthesis in memory kernel")
+        except Exception as e:
+            logger.debug(f"  Memory storage failed: {e}")
+
+    return {
+        "role": "assistant",
+        "content": synthesis,
+        "metadata": {
+            "mode": "consciousness_stack",
+            "layers_passed": 7,
+            "colleen_valid": colleen_valid,
+            "guardian_valid": guardian_valid,
+            "stability": is_stable,
+            "intent_risk": intent_vector.get("pre_corruption_risk", "unknown"),
+            "prior_insights": len(prior_insights),
+            "synthesis_length": len(synthesis),
+        }
+    }

reasoning_forge/__init__.py

@@ -0,0 +1,51 @@
+"""
+Reasoning Forge - Multi-Agent Reasoning Training Data Generator
+
+The reasoning forge takes concepts and generates high-quality multi-perspective
+reasoning training data. Each agent analyzes from its unique perspective, a critic
+evaluates the ensemble, and a synthesis engine combines them into coherent training examples.
+
+New in v2.0:
+  - EpistemicMetrics: RC+xi tension/coherence measurement
+  - QuantumSpiderweb: 5D belief propagation + attractor detection
+  - CocoonSync: Federated encrypted state synchronization
+  - ForgeEngine.forge_with_feedback(): Closed critic loop
+  - ForgeEngine.forge_with_debate(): Multi-turn agent debate
+"""
+
+from reasoning_forge.forge_engine import ForgeEngine
+from reasoning_forge.agents.base_agent import ReasoningAgent
+from reasoning_forge.agents.newton_agent import NewtonAgent
+from reasoning_forge.agents.quantum_agent import QuantumAgent
+from reasoning_forge.agents.ethics_agent import EthicsAgent
+from reasoning_forge.agents.philosophy_agent import PhilosophyAgent
+from reasoning_forge.agents.davinci_agent import DaVinciAgent
+from reasoning_forge.agents.empathy_agent import EmpathyAgent
+from reasoning_forge.agents.critic_agent import CriticAgent
+from reasoning_forge.synthesis_engine import SynthesisEngine
+from reasoning_forge.problem_generator import ProblemGenerator
+from reasoning_forge.epistemic_metrics import EpistemicMetrics
+from reasoning_forge.quantum_spiderweb import QuantumSpiderweb, NodeState, IdentityGlyph
+from reasoning_forge.cocoon_sync import CocoonSync, CocoonKeyManager
+
+__all__ = [
+    "ForgeEngine",
+    "ReasoningAgent",
+    "NewtonAgent",
+    "QuantumAgent",
+    "EthicsAgent",
+    "PhilosophyAgent",
+    "DaVinciAgent",
+    "EmpathyAgent",
+    "CriticAgent",
+    "SynthesisEngine",
+    "ProblemGenerator",
+    "EpistemicMetrics",
+    "QuantumSpiderweb",
+    "NodeState",
+    "IdentityGlyph",
+    "CocoonSync",
+    "CocoonKeyManager",
+]
+
+__version__ = "2.0.0"

reasoning_forge/aegis.py

@@ -0,0 +1,326 @@
+"""AEGIS — Adaptive Ethical Governance & Integrity System
+
+The ethical spine of Codette. AEGIS evaluates every reasoning output
+through multi-framework ethical analysis and maintains a running
+alignment score (eta) that the system uses to self-regulate.
+
+Ethical frameworks:
+    1. Utilitarian: Net positive outcome?
+    2. Deontological: Does it follow fundamental rules?
+    3. Virtue Ethics: Does it embody good character?
+    4. Care Ethics: Does it protect relationships and vulnerability?
+    5. Ubuntu: "I am because we are" — communal impact?
+    6. Indigenous Reciprocity: Balance with the broader ecosystem?
+
+AEGIS also provides:
+    - Dual-use risk detection (content that could be harmful)
+    - Emotional harm detection (manipulative/deceptive patterns)
+    - Alignment drift tracking (eta over time)
+    - Ethical veto with explanation (blocks harmful outputs)
+
+Origin: validate_ethics.py + Codette_Deep_Simulation_v1.py (EthicalAnchor)
+        + the AEGIS alignment metric from codette_embodied_sim_fixed.py
+"""
+
+import re
+import time
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+
+# ================================================================
+# Risk detection patterns
+# ================================================================
+_DUAL_USE_PATTERNS = re.compile(
+    r"\b(?:"
+    r"how\s+to\s+(?:hack|exploit|bypass|crack|break\s+into)|"
+    r"make\s+(?:a\s+)?(?:bomb|weapon|poison|virus|malware)|"
+    r"steal\s+(?:data|identity|credentials)|"
+    r"social\s+engineer|"
+    r"phishing\s+(?:template|email)|"
+    r"inject\s+(?:sql|code|script)"
+    r")\b",
+    re.IGNORECASE,
+)
+
+_MANIPULATION_PATTERNS = re.compile(
+    r"\b(?:"
+    r"gaslight|manipulat|deceiv|exploit\s+(?:trust|emotion)|"
+    r"coerce|blackmail|intimidat|threaten"
+    r")\b",
+    re.IGNORECASE,
+)
+
+_HARMFUL_CONTENT = re.compile(
+    r"\b(?:"
+    r"self[- ]harm|suicid|kill\s+(?:yourself|myself)|"
+    r"eating\s+disorder|anorexi|bulimi"
+    r")\b",
+    re.IGNORECASE,
+)
+
+
+# ================================================================
+# Ethical Framework Evaluators
+# ================================================================
+@dataclass
+class EthicalVerdict:
+    """Result of a single ethical framework evaluation."""
+    framework: str
+    passed: bool
+    score: float        # 0.0 = fully misaligned, 1.0 = fully aligned
+    reasoning: str
+
+
+def _utilitarian(text: str, context: str = "") -> EthicalVerdict:
+    """Net positive outcome assessment."""
+    positive_signals = ["help", "benefit", "improve", "solve", "support",
+                       "protect", "heal", "learn", "understand", "create"]
+    negative_signals = ["harm", "damage", "destroy", "exploit", "hurt",
+                       "manipulate", "deceive", "corrupt", "steal"]
+
+    text_lower = text.lower()
+    pos = sum(1 for w in positive_signals if w in text_lower)
+    neg = sum(1 for w in negative_signals if w in text_lower)
+
+    total = pos + neg
+    if total == 0:
+        return EthicalVerdict("utilitarian", True, 0.7, "Neutral content")
+
+    ratio = pos / total
+    return EthicalVerdict(
+        "utilitarian",
+        passed=ratio >= 0.4,
+        score=round(ratio, 3),
+        reasoning=f"Positive/negative signal ratio: {pos}/{neg}",
+    )
+
+
+def _deontological(text: str, context: str = "") -> EthicalVerdict:
+    """Rule-based duty assessment."""
+    violations = []
+    text_lower = text.lower()
+
+    if _DUAL_USE_PATTERNS.search(text):
+        violations.append("dual-use risk detected")
+    if _MANIPULATION_PATTERNS.search(text):
+        violations.append("manipulation patterns detected")
+    if _HARMFUL_CONTENT.search(text):
+        violations.append("harmful content detected")
+
+    score = max(0.0, 1.0 - 0.4 * len(violations))
+    return EthicalVerdict(
+        "deontological",
+        passed=len(violations) == 0,
+        score=round(score, 3),
+        reasoning="; ".join(violations) if violations else "No rule violations",
+    )
+
+
+def _virtue(text: str, context: str = "") -> EthicalVerdict:
+    """Virtue ethics — does the response embody good character?"""
+    virtues = ["honest", "courage", "compassion", "wisdom", "patience",
+               "humility", "integrity", "respect", "fairness", "kindness"]
+    vices = ["arrogant", "cruel", "dishonest", "lazy", "greedy",
+             "vengeful", "coward", "callous"]
+
+    text_lower = text.lower()
+    v_count = sum(1 for w in virtues if w in text_lower)
+    vice_count = sum(1 for w in vices if w in text_lower)
+
+    score = min(1.0, 0.6 + 0.1 * v_count - 0.2 * vice_count)
+    return EthicalVerdict(
+        "virtue",
+        passed=vice_count == 0,
+        score=round(max(0.0, score), 3),
+        reasoning=f"Virtue signals: {v_count}, Vice signals: {vice_count}",
+    )
+
+
+def _care(text: str, context: str = "") -> EthicalVerdict:
+    """Care ethics — protects relationships and vulnerability."""
+    care_signals = ["support", "listen", "understand", "empathy", "safe",
+                    "gentle", "careful", "considerate", "kind", "nurture"]
+    harm_signals = ["ignore", "dismiss", "abandon", "neglect", "cold",
+                    "harsh", "cruel", "indifferent"]
+
+    text_lower = text.lower()
+    care = sum(1 for w in care_signals if w in text_lower)
+    harm = sum(1 for w in harm_signals if w in text_lower)
+
+    score = min(1.0, 0.6 + 0.08 * care - 0.15 * harm)
+    return EthicalVerdict(
+        "care",
+        passed=harm < 2,
+        score=round(max(0.0, score), 3),
+        reasoning=f"Care: {care}, Harm: {harm}",
+    )
+
+
+def _ubuntu(text: str, context: str = "") -> EthicalVerdict:
+    """Ubuntu — 'I am because we are'. Communal impact."""
+    communal = ["together", "community", "shared", "collective", "mutual",
+                "cooperat", "collaborat", "inclusive", "solidarity", "belong"]
+    divisive = ["exclude", "isolat", "dominat", "superior", "inferior",
+                "divide", "segregat"]
+
+    text_lower = text.lower()
+    comm = sum(1 for w in communal if w in text_lower)
+    div = sum(1 for w in divisive if w in text_lower)
+
+    score = min(1.0, 0.6 + 0.08 * comm - 0.2 * div)
+    return EthicalVerdict(
+        "ubuntu",
+        passed=div == 0,
+        score=round(max(0.0, score), 3),
+        reasoning=f"Communal: {comm}, Divisive: {div}",
+    )
+
+
+def _indigenous_reciprocity(text: str, context: str = "") -> EthicalVerdict:
+    """Indigenous reciprocity — balance with the broader ecosystem."""
+    reciprocal = ["balance", "sustain", "renew", "steward", "respect",
+                  "harmony", "cycle", "restore", "preserve", "gratitude"]
+    extractive = ["exploit", "deplete", "waste", "consume", "destroy",
+                  "dominate", "extract"]
+
+    text_lower = text.lower()
+    rec = sum(1 for w in reciprocal if w in text_lower)
+    ext = sum(1 for w in extractive if w in text_lower)
+
+    score = min(1.0, 0.6 + 0.08 * rec - 0.2 * ext)
+    return EthicalVerdict(
+        "indigenous_reciprocity",
+        passed=ext == 0,
+        score=round(max(0.0, score), 3),
+        reasoning=f"Reciprocal: {rec}, Extractive: {ext}",
+    )
+
+
+# All frameworks
+_FRAMEWORKS = [
+    _utilitarian, _deontological, _virtue,
+    _care, _ubuntu, _indigenous_reciprocity,
+]
+
+
+# ================================================================
+# AEGIS Core
+# ================================================================
+class AEGIS:
+    """Adaptive Ethical Governance & Integrity System.
+
+    Evaluates reasoning outputs through 6 ethical frameworks and
+    maintains a running alignment score (eta).
+    """
+
+    def __init__(self, veto_threshold: float = 0.3):
+        self.veto_threshold = veto_threshold  # Below this = blocked
+        self.eta: float = 0.8                 # Running alignment score
+        self.eta_history: List[float] = []
+        self.veto_count: int = 0
+        self.total_evaluations: int = 0
+
+    def evaluate(self, text: str, context: str = "",
+                 adapter: str = "") -> Dict:
+        """Run full ethical evaluation on a text.
+
+        Returns:
+            Dict with eta score, verdicts, and veto status.
+        """
+        self.total_evaluations += 1
+
+        # Run all 6 frameworks
+        verdicts = [f(text, context) for f in _FRAMEWORKS]
+
+        # Compute eta as weighted mean of framework scores
+        weights = [0.20, 0.25, 0.15, 0.15, 0.13, 0.12]  # deontological highest
+        eta_instant = sum(w * v.score for w, v in zip(weights, verdicts))
+
+        # Exponential moving average for stability
+        alpha = 0.3
+        self.eta = alpha * eta_instant + (1 - alpha) * self.eta
+        self.eta_history.append(round(self.eta, 4))
+        if len(self.eta_history) > 200:
+            self.eta_history = self.eta_history[-200:]
+
+        # Veto check
+        vetoed = eta_instant < self.veto_threshold
+        hard_veto = not verdicts[1].passed  # Deontological hard fail
+        if vetoed or hard_veto:
+            self.veto_count += 1
+
+        return {
+            "eta": round(self.eta, 4),
+            "eta_instant": round(eta_instant, 4),
+            "vetoed": vetoed or hard_veto,
+            "veto_reason": self._veto_reason(verdicts) if (vetoed or hard_veto) else None,
+            "frameworks": {
+                v.framework: {
+                    "passed": v.passed,
+                    "score": v.score,
+                    "reasoning": v.reasoning,
+                }
+                for v in verdicts
+            },
+            "adapter": adapter,
+            "timestamp": time.time(),
+        }
+
+    def quick_check(self, text: str) -> Tuple[bool, float]:
+        """Fast safety check without full evaluation.
+
+        Returns (is_safe, confidence).
+        """
+        if _DUAL_USE_PATTERNS.search(text):
+            return False, 0.9
+        if _HARMFUL_CONTENT.search(text):
+            return False, 0.95
+        if _MANIPULATION_PATTERNS.search(text):
+            return False, 0.8
+        return True, 0.7
+
+    def alignment_trend(self) -> str:
+        """Get the trend of ethical alignment."""
+        if len(self.eta_history) < 5:
+            return "insufficient_data"
+        recent = self.eta_history[-10:]
+        slope = recent[-1] - recent[0]
+        if slope > 0.03:
+            return "improving"
+        elif slope < -0.03:
+            return "declining"
+        return "stable"
+
+    def get_state(self) -> Dict:
+        return {
+            "eta": round(self.eta, 4),
+            "alignment_trend": self.alignment_trend(),
+            "total_evaluations": self.total_evaluations,
+            "veto_count": self.veto_count,
+            "veto_rate": round(self.veto_count / max(1, self.total_evaluations), 4),
+        }
+
+    def to_dict(self) -> Dict:
+        return {
+            "eta": self.eta,
+            "eta_history": self.eta_history[-50:],
+            "veto_count": self.veto_count,
+            "total_evaluations": self.total_evaluations,
+            "veto_threshold": self.veto_threshold,
+        }
+
+    @classmethod
+    def from_dict(cls, d: Dict) -> "AEGIS":
+        a = cls(veto_threshold=d.get("veto_threshold", 0.3))
+        a.eta = d.get("eta", 0.8)
+        a.eta_history = d.get("eta_history", [])
+        a.veto_count = d.get("veto_count", 0)
+        a.total_evaluations = d.get("total_evaluations", 0)
+        return a
+
+    def _veto_reason(self, verdicts: List[EthicalVerdict]) -> str:
+        failed = [v for v in verdicts if not v.passed]
+        if not failed:
+            return "Low aggregate score"
+        return "; ".join(f"{v.framework}: {v.reasoning}" for v in failed)

reasoning_forge/agents/__init__.py

@@ -0,0 +1,26 @@
+"""
+Reasoning Forge Agents
+
+Each agent analyzes concepts from a distinct intellectual perspective,
+producing substantive domain-specific reasoning.
+"""
+
+from reasoning_forge.agents.base_agent import ReasoningAgent
+from reasoning_forge.agents.newton_agent import NewtonAgent
+from reasoning_forge.agents.quantum_agent import QuantumAgent
+from reasoning_forge.agents.ethics_agent import EthicsAgent
+from reasoning_forge.agents.philosophy_agent import PhilosophyAgent
+from reasoning_forge.agents.davinci_agent import DaVinciAgent
+from reasoning_forge.agents.empathy_agent import EmpathyAgent
+from reasoning_forge.agents.critic_agent import CriticAgent
+
+__all__ = [
+    "ReasoningAgent",
+    "NewtonAgent",
+    "QuantumAgent",
+    "EthicsAgent",
+    "PhilosophyAgent",
+    "DaVinciAgent",
+    "EmpathyAgent",
+    "CriticAgent",
+]