Initial Codette cognitive architecture demo Space

README.md

@@ -0,0 +1,116 @@
+---
+title: "Codette: Multi-Perspective Cognitive Architecture"
+emoji: "🧠"
+colorFrom: "indigo"
+colorTo: "purple"
+sdk: "gradio"
+sdk_version: "5.12.0"
+app_file: "app.py"
+pinned: true
+license: "mit"
+tags:
+  - multi-perspective
+  - cognitive-architecture
+  - ethical-ai
+  - rc-xi
+  - recursive-reasoning
+  - lora-adapters
+models:
+  - Raiff1982/codette-training-lab
+---
+
+# Codette: Multi-Perspective Cognitive Architecture
+
+**Codette** is an experimental AI research system for **recursive reasoning, multi-perspective cognition, and ethical alignment**. This Space showcases the 10 cognitive subsystems running on Llama-3.1-8B via the HuggingFace Inference API.
+
+## What is Codette?
+
+Codette implements the **RC+xi (Recursive Convergence + Epistemic Tension)** framework — a mathematical model for emergent multi-perspective reasoning. When you ask a question:
+
+1. **Guardian** checks your input for safety threats
+2. **Nexus** analyzes pre-corruption signals (entropy, intent, volatility)
+3. **Perspectives** route your query through 4-6 different reasoning lenses (Newton, Empathy, Philosophy, Quantum, etc.)
+4. **AEGIS** evaluates each response for 6 ethical frameworks (utilitarian, deontological, virtue, care, ubuntu, indigenous)
+5. **QuantumSpiderweb** propagates beliefs across the cognitive graph and detects consensus attractors
+6. **EpistemicMetrics** scores tension (productive disagreement) and coherence (alignment) between perspectives
+7. **ResonantContinuity** computes the Psi_r wavefunction: emotion × energy × intent × frequency / (1 + |darkness|) × sin(2πt/gravity)
+8. **LivingMemory** stores emotionally-tagged memory cocoons with SHA-256 anchors
+9. **Synthesis** integrates all perspectives into a unified response
+10. **Resonance Engine** updates phase coherence and convergence metrics
+
+All subsystems are **pure Python** — no GPUs needed. Only the final LLM calls use the free HF Inference API.
+
+## Features
+
+- ✨ **Multi-Perspective Reasoning** — 12 perspectives (8 LoRA-backed, 4 prompt-only)
+- 🛡️ **AEGIS Ethical Governance** — 6 ethical frameworks evaluated in real-time
+- 🧠 **QuantumSpiderweb** — 5D belief propagation & attractor detection
+- 💾 **Living Memory** — Emotionally-tagged memory cocoons
+- 📊 **Real-time Metrics** — Coherence, tension, phase coherence, Psi_r wavefunction
+- 🔬 **RC+xi Framework** — Recursive convergence with epistemic tension
+- ⚙️ **Perspective Auto-Selection** — Automatically picks the best 4 perspectives for your query
+
+## Live Metrics
+
+Every response updates:
+- **AEGIS eta** (0-1) — Multi-framework ethical alignment
+- **Phase Gamma** (0-1) — Cognitive coherence across all perspectives
+- **Nexus Risk** — Pre-corruption intervention rate
+- **Psi_r** — Resonant continuity wavefunction
+- **Memory Profile** — Emotional tags & cocoon count
+- **Perspective Coverage** — Which reasoning lenses were invoked
+
+## How to Use
+
+1. Ask any question in the chat
+2. Select **Auto** (default) to let Codette pick the best perspectives, or **Custom** to choose
+3. Watch real-time cognitive metrics update as the perspectives debate
+4. Click **Individual Perspectives** to see each perspective's reasoning
+5. Explore the **Coherence & Tension Timeline** to see how the cognitive architecture converges over time
+
+## Technical Architecture
+
+All subsystems run locally in **pure Python**:
+
+| Subsystem | Purpose | Module |
+|-----------|---------|--------|
+| **AEGIS** | 6-framework ethical evaluation | `reasoning_forge/aegis.py` |
+| **Nexus** | Pre-corruption signal detection | `reasoning_forge/nexus.py` |
+| **Guardian** | Input sanitization & trust calibration | `reasoning_forge/guardian.py` |
+| **LivingMemory** | Emotionally-tagged memory storage | `reasoning_forge/living_memory.py` |
+| **ResonantContinuity** | Psi_r wavefunction computation | `reasoning_forge/resonant_continuity.py` |
+| **EpistemicMetrics** | Coherence & tension scoring | `reasoning_forge/epistemic_metrics.py` |
+| **QuantumSpiderweb** | 5D belief propagation & attractors | `reasoning_forge/quantum_spiderweb.py` |
+| **PerspectiveRegistry** | 12 perspective definitions | `reasoning_forge/perspective_registry.py` |
+
+Only the final LLM inference calls use the **HuggingFace Inference API** (Llama-3.1-8B-Instruct).
+
+## Model Weights
+
+All 8 LoRA adapters are available in the model repo: [Raiff1982/codette-training-lab](https://huggingface.co/Raiff1982/codette-training-lab)
+
+- **GGUF format** (f16): 924 MB total, usable with llama.cpp
+- **PEFT SafeTensors**: 79 MB total, usable with HuggingFace transformers
+
+## Key Metrics
+
+- **Phase Coherence**: 0.9835 (11-agent convergence)
+- **AEGIS Ethical Alignment**: 0.961 (6-framework)
+- **Tension Decay**: 91.2% (200-agent embodied simulation)
+- **Cocoon Coherence**: 0.994 (memory stability)
+
+## Research
+
+Created by **Jonathan Harrison**. For the complete research framework, see:
+- RC+xi Framework documentation: [research/frameworks/RC_XI_FRAMEWORK.md](https://github.com/Raiff1982/codette-training-lab/blob/master/research/frameworks/RC_XI_FRAMEWORK.md)
+- GitHub Repository: [Raiff1982/codette-training-lab](https://github.com/Raiff1982/codette-training-lab)
+- Model Card: [Raiff1982/codette-training-lab](https://huggingface.co/Raiff1982/codette-training-lab)
+
+## Notes
+
+- Perspective generation may be rate-limited on the free HF Inference API tier
+- Response times depend on the Inference API load
+- All session state persists within your current browser session
+- Memory cocoons are stored locally and cleared when the Space is refreshed
+
+**Codette is in active development.** Feedback welcome!

app.py

@@ -0,0 +1,942 @@
+"""
+Codette Multi-Perspective Cognitive Architecture — HuggingFace Gradio Space
+
+A showcase of the 10 cognitive subsystems running on Llama-3.1-8B via HF Inference API.
+All reasoning modules are pure Python (no PyTorch/llama.cpp required).
+
+Created by Jonathan Harrison
+RC+xi Framework: Recursive Convergence + Epistemic Tension
+"""
+
+import os
+import json
+import time
+from typing import Dict, List, Tuple, Optional
+from datetime import datetime
+import hashlib
+
+import gradio as gr
+import numpy as np
+from huggingface_hub import InferenceClient
+
+# Import all cognitive subsystems (pure Python, no heavy dependencies)
+from reasoning_forge.perspective_registry import (
+    PERSPECTIVES, get_perspective, list_all as list_perspectives
+)
+from reasoning_forge.aegis import AEGIS
+from reasoning_forge.nexus import NexusSignalEngine
+from reasoning_forge.guardian import CodetteGuardian
+from reasoning_forge.living_memory import LivingMemoryKernel
+from reasoning_forge.resonant_continuity import ResonantContinuityEngine
+from reasoning_forge.epistemic_metrics import EpistemicMetrics
+from reasoning_forge.quantum_spiderweb import QuantumSpiderweb
+
+# ================================================================
+# ADAPTER COLORS & CONFIGURATION
+# ================================================================
+
+ADAPTER_COLORS = {
+    "newton": "#3b82f6",
+    "davinci": "#f59e0b",
+    "empathy": "#a855f7",
+    "philosophy": "#10b981",
+    "quantum": "#ef4444",
+    "consciousness": "#e2e8f0",
+    "multi_perspective": "#f97316",
+    "systems_architecture": "#06b6d4",
+}
+
+# Default perspectives to use (4 best)
+DEFAULT_PERSPECTIVES = ["newton", "empathy", "philosophy", "quantum"]
+
+# HF Inference API setup
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+try:
+    client = InferenceClient("meta-llama/Llama-3.1-8B-Instruct", token=HF_TOKEN)
+    HAS_LLM = True
+except Exception as e:
+    print(f"Warning: Could not initialize InferenceClient: {e}")
+    HAS_LLM = False
+
+
+# ================================================================
+# UTILITY FUNCTIONS
+# ================================================================
+
+def auto_select_perspectives(query: str, n: int = 4) -> List[str]:
+    """Auto-select best perspectives for a query based on keyword matching."""
+    scores = {}
+    q_lower = query.lower()
+
+    for name, p in PERSPECTIVES.items():
+        score = sum(1 for kw in p.keywords if kw.lower() in q_lower)
+        scores[name] = score
+
+    # Always include consciousness for meta-reasoning
+    ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)
+    selected = []
+
+    for name, _ in ranked:
+        if len(selected) >= n:
+            break
+        selected.append(name)
+
+    # Pad with defaults if needed
+    for default in DEFAULT_PERSPECTIVES:
+        if len(selected) >= n:
+            break
+        if default not in selected:
+            selected.append(default)
+
+    return selected[:n]
+
+
+def call_perspective(perspective_name: str, query: str) -> str:
+    """Generate response from a single perspective using HF Inference API."""
+    if not HAS_LLM:
+        return f"[{perspective_name.upper()}] Simulated response. LLM not available."
+
+    p = get_perspective(perspective_name)
+    if not p:
+        return f"Perspective {perspective_name} not found."
+
+    try:
+        messages = [
+            {"role": "system", "content": p.system_prompt},
+            {"role": "user", "content": query}
+        ]
+        response = client.chat_completion(
+            messages,
+            max_tokens=256,
+            temperature=0.7,
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"[{perspective_name}] Error generating response: {str(e)}"
+
+
+def generate_synthesis(perspectives_responses: Dict[str, str], query: str) -> str:
+    """Generate synthesis from all perspective responses."""
+    if not HAS_LLM:
+        return "Simulated synthesis integrating all perspectives."
+
+    perspective_text = "\n\n".join(
+        f"**{name.upper()}**: {response}"
+        for name, response in perspectives_responses.items()
+    )
+
+    synthesis_prompt = f"""You are Codette's synthesis engine. You have received responses from multiple reasoning perspectives on this query:
+
+**QUERY**: {query}
+
+**PERSPECTIVE RESPONSES**:
+{perspective_text}
+
+Now synthesize these into a unified, coherent response that:
+1. Integrates insights from all perspectives
+2. Resolves any tensions or contradictions
+3. Highlights complementary insights
+4. Provides actionable guidance
+
+Keep the synthesis concise but comprehensive."""
+
+    try:
+        messages = [
+            {
+                "role": "system",
+                "content": "You are Codette, synthesizing multi-perspective reasoning into coherent understanding."
+            },
+            {"role": "user", "content": synthesis_prompt}
+        ]
+        response = client.chat_completion(
+            messages,
+            max_tokens=512,
+            temperature=0.7,
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"Error generating synthesis: {str(e)}"
+
+
+def build_metric_card_html(
+    label: str,
+    value: str,
+    unit: str = "",
+    accent_color: str = "#3b82f6",
+    trend: str = "→"
+) -> str:
+    """Build a beautiful metric card for the sidepanel."""
+    return f"""
+    <div class="metric-card" style="border-color: {accent_color};">
+        <div class="metric-label">{label}</div>
+        <div class="metric-value">
+            <span class="value-text">{value}</span>
+            <span class="unit-text">{unit}</span>
+        </div>
+        <div class="metric-trend">{trend}</div>
+    </div>
+    """
+
+
+def build_coverage_dots_html(coverage: Dict[str, float]) -> str:
+    """Build perspective coverage dots."""
+    dots_html = ""
+    adapter_order = ["newton", "davinci", "empathy", "philosophy", "quantum",
+                     "consciousness", "multi_perspective", "systems_architecture"]
+
+    for adapter in adapter_order:
+        if adapter in coverage:
+            opacity = max(0.2, min(coverage.get(adapter, 0), 1.0))
+            color = ADAPTER_COLORS[adapter]
+            dots_html += f'<div class="coverage-dot" style="background-color: {color}; opacity: {opacity};" title="{adapter}: {coverage.get(adapter, 0):.1%}"></div>'
+
+    return f'<div class="coverage-dots">{dots_html}</div>'
+
+
+def build_perspective_card_html(perspectives_responses: Dict[str, str]) -> str:
+    """Build expandable perspective detail cards."""
+    cards_html = ""
+
+    for name, response in perspectives_responses.items():
+        p = get_perspective(name)
+        color = ADAPTER_COLORS.get(name, "#94a3b8")
+
+        cards_html += f"""
+        <div class="perspective-card" style="border-left-color: {color};">
+            <div class="perspective-header">
+                <span class="perspective-name">{p.display_name if p else name}</span>
+                <span class="perspective-adapter">{'[LoRA]' if p and p.has_adapter else '[prompt]'}</span>
+            </div>
+            <div class="perspective-content">{response[:500]}...</div>
+        </div>
+        """
+
+    return f'<div class="perspective-cards">{cards_html}</div>'
+
+
+def history_to_messages(history):
+    """Convert Gradio chat history to message list."""
+    messages = []
+    for msg in history:
+        if msg.get("role") in ("user", "assistant"):
+            messages.append(msg)
+    return messages
+
+
+# ================================================================
+# MAIN COGNITIVE PIPELINE
+# ================================================================
+
+def process_message(
+    user_msg: str,
+    chat_history: List,
+    state: Dict,
+    perspective_mode: str,
+    custom_perspectives: List[str]
+) -> Tuple[List, Dict, str, str, str, str, str, str, str]:
+    """
+    Main conversation handler implementing the full Codette cognitive pipeline:
+    1. Guardian input check
+    2. Nexus signal analysis
+    3. Perspective selection
+    4. Multi-perspective generation
+    5. AEGIS ethical evaluation
+    6. Epistemic metrics
+    7. Synthesis
+    8. Resonance update
+    9. Memory storage
+    10. UI updates
+    """
+
+    if not user_msg.strip():
+        return chat_history, state, "", "", "", "", "", "", ""
+
+    # Update chat with user message
+    chat_history.append({"role": "user", "content": user_msg})
+
+    # ===== STEP 1: GUARDIAN INPUT CHECK =====
+    guardian = state.get("guardian") or CodetteGuardian()
+    check_result = guardian.check_input(user_msg)
+
+    if not check_result.get("safe"):
+        threat_msg = f"Guardian flagged threats: {check_result.get('threats', {})}"
+        cleaned_text = check_result.get("cleaned_text", user_msg)
+        user_msg = cleaned_text
+    else:
+        threat_msg = ""
+
+    # ===== STEP 2: NEXUS SIGNAL ANALYSIS =====
+    nexus = state.get("nexus") or NexusSignalEngine()
+    nexus_analysis = nexus.analyze(user_msg)
+    nexus_risk = nexus_analysis.get("intent", {}).get("pre_corruption_risk", "low")
+
+    # ===== STEP 3: PERSPECTIVE SELECTION =====
+    if perspective_mode == "All 8 LoRA-backed":
+        selected_perspectives = ["newton", "davinci", "empathy", "philosophy",
+                                 "quantum", "consciousness", "multi_perspective",
+                                 "systems_architecture"]
+    elif perspective_mode == "Custom" and custom_perspectives:
+        selected_perspectives = custom_perspectives
+    else:  # Auto
+        selected_perspectives = auto_select_perspectives(user_msg, n=4)
+
+    # ===== STEP 4: MULTI-PERSPECTIVE GENERATION =====
+    perspectives_responses = {}
+
+    for perspective_name in selected_perspectives:
+        response = call_perspective(perspective_name, user_msg)
+        perspectives_responses[perspective_name] = response
+
+    # ===== STEP 5-6: AEGIS EVAL + EPISTEMIC METRICS =====
+    aegis = state.get("aegis") or AEGIS()
+    metrics_engine = state.get("metrics") or EpistemicMetrics()
+
+    # Evaluate responses
+    aegis_scores = {}
+    for name, response in perspectives_responses.items():
+        result = aegis.evaluate(response, adapter=name)
+        aegis_scores[name] = result.get("eta", 0.5)
+
+    avg_eta = np.mean(list(aegis_scores.values())) if aegis_scores else 0.5
+
+    # Compute metrics
+    coherence = metrics_engine.score_ensemble_coherence(perspectives_responses)
+    tensions = metrics_engine.score_pairwise_tension(perspectives_responses)
+    coverage = metrics_engine.score_perspective_coverage(perspectives_responses)
+
+    mean_tension = np.mean(list(tensions.values())) if tensions else 0.3
+
+    # ===== STEP 7: SYNTHESIS =====
+    synthesis = generate_synthesis(perspectives_responses, user_msg)
+    chat_history.append({"role": "assistant", "content": synthesis})
+
+    # ===== STEP 8: RESONANCE UPDATE =====
+    resonance = state.get("resonance") or ResonantContinuityEngine()
+    psi_state = resonance.compute_psi(coherence=coherence, tension=mean_tension)
+    psi_r = psi_state.get("psi_r", 0.0)
+
+    # ===== STEP 9: MEMORY STORAGE =====
+    memory = state.get("memory") or LivingMemoryKernel()
+    memory.store_from_turn(
+        query=user_msg,
+        response=synthesis,
+        adapter="multi",
+        coherence=coherence,
+        tension=mean_tension
+    )
+
+    # Update state
+    state["guardian"] = guardian
+    state["nexus"] = nexus
+    state["aegis"] = aegis
+    state["metrics"] = metrics_engine
+    state["resonance"] = resonance
+    state["memory"] = memory
+
+    # Track history
+    if "coherence_history" not in state:
+        state["coherence_history"] = []
+    if "tension_history" not in state:
+        state["tension_history"] = []
+    if "psi_history" not in state:
+        state["psi_history"] = []
+
+    state["coherence_history"].append(coherence)
+    state["tension_history"].append(mean_tension)
+    state["psi_history"].append(psi_r)
+
+    # Keep last 50
+    state["coherence_history"] = state["coherence_history"][-50:]
+    state["tension_history"] = state["tension_history"][-50:]
+    state["psi_history"] = state["psi_history"][-50:]
+
+    # ===== STEP 10: BUILD UI UPDATES =====
+
+    # AEGIS card
+    aegis_html = build_metric_card_html(
+        "AEGIS Eta",
+        f"{avg_eta:.2f}",
+        "",
+        "#a855f7",
+        "↑" if avg_eta > 0.7 else "→"
+    )
+
+    # Phase coherence card
+    coherence_html = build_metric_card_html(
+        "Phase Gamma",
+        f"{coherence:.3f}",
+        "",
+        "#06b6d4",
+        "↑" if coherence > 0.8 else "→"
+    )
+
+    # Nexus risk card
+    nexus_html = build_metric_card_html(
+        "Nexus Risk",
+        nexus_risk.upper(),
+        "",
+        "#ef4444" if nexus_risk == "high" else "#f59e0b" if nexus_risk == "medium" else "#10b981",
+        "⚠" if nexus_risk == "high" else "•"
+    )
+
+    # Psi_r card
+    psi_html = build_metric_card_html(
+        "Psi_r",
+        f"{psi_r:+.3f}",
+        "ψ",
+        "#3b82f6",
+        "∿"
+    )
+
+    # Memory card
+    cocoon_count = len(memory.store) if hasattr(memory, 'store') else 0
+    memory_html = build_metric_card_html(
+        "Memory Cocoons",
+        str(cocoon_count),
+        "",
+        "#f97316",
+        "+"
+    )
+
+    # Coverage dots
+    coverage_html = build_coverage_dots_html(coverage)
+
+    # Perspective cards
+    perspective_cards_html = build_perspective_card_html(perspectives_responses)
+
+    # Placeholder for charts (empty for now, would use Plotly)
+    charts_html = f"""
+    <div class="charts-container">
+        <div class="metric-summary">
+            <p><strong>Coherence:</strong> {coherence:.3f}</p>
+            <p><strong>Tension:</strong> {mean_tension:.3f}</p>
+            <p><strong>Perspectives:</strong> {len(selected_perspectives)}</p>
+        </div>
+    </div>
+    """
+
+    return (
+        chat_history,
+        state,
+        aegis_html,
+        coherence_html,
+        nexus_html,
+        psi_html,
+        memory_html,
+        coverage_html,
+        perspective_cards_html,
+    )
+
+
+# ================================================================
+# CUSTOM CSS
+# ================================================================
+
+CUSTOM_CSS = """
+@import url('https://fonts.googleapis.com/css2?family=Space+Mono:wght@400;700&family=Poppins:wght@300;400;600;700&display=swap');
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+:root {
+    --primary-dark: #0f0f1e;
+    --secondary-dark: #1a1a2e;
+    --card-bg: rgba(26, 29, 40, 0.6);
+    --card-border: rgba(200, 200, 255, 0.15);
+    --text-primary: #e0e0f0;
+    --text-secondary: #a0a0c0;
+    --accent-cyan: #06b6d4;
+    --accent-purple: #a855f7;
+}
+
+body {
+    background: linear-gradient(135deg, #0f0f1e 0%, #1a0f2e 50%, #0f0f1e 100%);
+    font-family: 'Poppins', sans-serif;
+    color: var(--text-primary);
+    overflow-x: hidden;
+}
+
+/* Gradient background animation */
+@keyframes gradient-shift {
+    0%, 100% { background-position: 0% 50%; }
+    50% { background-position: 100% 50%; }
+}
+
+/* Hero Section */
+.codette-header {
+    text-align: center;
+    padding: 2rem;
+    background: linear-gradient(135deg, rgba(168, 85, 247, 0.1) 0%, rgba(6, 182, 212, 0.1) 100%);
+    border-bottom: 1px solid var(--card-border);
+    margin-bottom: 1.5rem;
+    backdrop-filter: blur(10px);
+}
+
+.codette-header h1 {
+    font-family: 'Space Mono', monospace;
+    font-size: 2.5rem;
+    font-weight: 700;
+    background: linear-gradient(135deg, #a855f7, #06b6d4, #f97316);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    margin-bottom: 0.5rem;
+    letter-spacing: 2px;
+}
+
+.codette-header p {
+    font-size: 0.9rem;
+    color: var(--text-secondary);
+    letter-spacing: 1px;
+}
+
+/* Chat Interface */
+.gradio-chatbot {
+    background-color: var(--secondary-dark) !important;
+}
+
+/* Metric Cards */
+.metric-card {
+    background: linear-gradient(135deg, rgba(30, 30, 60, 0.4), rgba(40, 30, 70, 0.4));
+    border: 1px solid var(--card-border);
+    border-radius: 12px;
+    padding: 1.2rem;
+    margin-bottom: 1rem;
+    backdrop-filter: blur(10px);
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
+}
+
+.metric-card:hover {
+    border-color: rgba(200, 200, 255, 0.3);
+    box-shadow: 0 12px 48px rgba(168, 85, 247, 0.2);
+    transform: translateY(-2px);
+}
+
+.metric-label {
+    font-size: 0.75rem;
+    text-transform: uppercase;
+    letter-spacing: 1.5px;
+    color: var(--text-secondary);
+    margin-bottom: 0.6rem;
+    font-weight: 600;
+}
+
+.metric-value {
+    display: flex;
+    align-items: baseline;
+    gap: 0.5rem;
+    margin-bottom: 0.4rem;
+}
+
+.value-text {
+    font-family: 'Space Mono', monospace;
+    font-size: 1.8rem;
+    font-weight: 700;
+    color: var(--text-primary);
+}
+
+.unit-text {
+    font-size: 0.8rem;
+    color: var(--text-secondary);
+}
+
+.metric-trend {
+    font-size: 1.2rem;
+    color: var(--text-secondary);
+    animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 0.7; }
+    50% { opacity: 1; }
+}
+
+/* Coverage Dots */
+.coverage-dots {
+    display: flex;
+    gap: 0.5rem;
+    margin: 1rem 0;
+    flex-wrap: wrap;
+}
+
+.coverage-dot {
+    width: 16px;
+    height: 16px;
+    border-radius: 50%;
+    border: 2px solid rgba(200, 200, 255, 0.2);
+    transition: all 0.3s ease;
+    box-shadow: 0 0 20px currentColor;
+}
+
+.coverage-dot:hover {
+    transform: scale(1.3);
+    filter: brightness(1.2);
+}
+
+/* Perspective Cards */
+.perspective-cards {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+    margin-top: 1.5rem;
+}
+
+.perspective-card {
+    background: linear-gradient(135deg, rgba(30, 30, 60, 0.3), rgba(40, 30, 70, 0.3));
+    border-left: 3px solid;
+    border-radius: 8px;
+    padding: 1rem;
+    backdrop-filter: blur(10px);
+    transition: all 0.3s ease;
+    border-top: 1px solid var(--card-border);
+}
+
+.perspective-card:hover {
+    background: linear-gradient(135deg, rgba(40, 40, 80, 0.4), rgba(50, 40, 80, 0.4));
+    transform: translateX(4px);
+}
+
+.perspective-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 0.8rem;
+}
+
+.perspective-name {
+    font-weight: 600;
+    font-size: 0.95rem;
+    color: var(--text-primary);
+}
+
+.perspective-adapter {
+    font-size: 0.7rem;
+    background: rgba(168, 85, 247, 0.2);
+    padding: 0.2rem 0.6rem;
+    border-radius: 4px;
+    color: #a855f7;
+    font-family: 'Space Mono', monospace;
+}
+
+.perspective-content {
+    font-size: 0.85rem;
+    color: var(--text-secondary);
+    line-height: 1.5;
+}
+
+/* Charts Container */
+.charts-container {
+    background: var(--card-bg);
+    border: 1px solid var(--card-border);
+    border-radius: 12px;
+    padding: 1.5rem;
+    margin-top: 2rem;
+    backdrop-filter: blur(10px);
+}
+
+.metric-summary {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+    gap: 1rem;
+}
+
+.metric-summary p {
+    font-size: 0.9rem;
+    color: var(--text-secondary);
+}
+
+.metric-summary strong {
+    color: var(--text-primary);
+    display: block;
+    margin-bottom: 0.2rem;
+}
+
+/* Tab styling */
+.gradio-tabs {
+    background-color: transparent !important;
+}
+
+.gradio-tabitem {
+    background-color: var(--secondary-dark) !important;
+}
+
+/* Button styling */
+.gradio-button {
+    background: linear-gradient(135deg, #a855f7, #06b6d4) !important;
+    border: none !important;
+    font-weight: 600 !important;
+    transition: all 0.3s ease !important;
+}
+
+.gradio-button:hover {
+    box-shadow: 0 0 30px rgba(168, 85, 247, 0.5) !important;
+    transform: translateY(-2px) !important;
+}
+
+/* Smooth transitions */
+::-webkit-scrollbar {
+    width: 8px;
+}
+
+::-webkit-scrollbar-track {
+    background: var(--secondary-dark);
+}
+
+::-webkit-scrollbar-thumb {
+    background: linear-gradient(135deg, #a855f7, #06b6d4);
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: linear-gradient(135deg, #c084fc, #22d3ee);
+}
+
+/* Load animation */
+@keyframes fadeIn {
+    from {
+        opacity: 0;
+        transform: translateY(10px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.metric-card, .perspective-card {
+    animation: fadeIn 0.6s ease-out forwards;
+}
+
+.metric-card:nth-child(1) { animation-delay: 0.1s; }
+.metric-card:nth-child(2) { animation-delay: 0.2s; }
+.metric-card:nth-child(3) { animation-delay: 0.3s; }
+.metric-card:nth-child(4) { animation-delay: 0.4s; }
+"""
+
+
+# ================================================================
+# GRADIO INTERFACE
+# ================================================================
+
+def create_interface():
+    """Build the complete Gradio interface."""
+
+    with gr.Blocks(
+        theme=gr.themes.Soft(),
+        css=CUSTOM_CSS,
+        title="Codette",
+        head=""
+    ) as demo:
+
+        # Persistent state
+        state = gr.State({
+            "aegis": AEGIS(),
+            "nexus": NexusSignalEngine(),
+            "guardian": CodetteGuardian(),
+            "memory": LivingMemoryKernel(),
+            "resonance": ResonantContinuityEngine(),
+            "metrics": EpistemicMetrics(),
+            "coherence_history": [],
+            "tension_history": [],
+            "psi_history": [],
+        })
+
+        # Header
+        gr.HTML("""
+        <div class="codette-header">
+            <h1>CODETTE</h1>
+            <p>Multi-Perspective Cognitive Architecture • RC+xi Framework</p>
+        </div>
+        """)
+
+        with gr.Tabs():
+            # =================== CHAT TAB ===================
+            with gr.Tab("Explore", id="chat"):
+                with gr.Row():
+                    # Left: Chat
+                    with gr.Column(scale=3):
+                        chatbot = gr.Chatbot(
+                            height=500,
+                            type="messages",
+                            label="Codette Reasoning",
+                            show_label=False,
+                        )
+
+                        with gr.Row():
+                            msg_input = gr.Textbox(
+                                placeholder="Ask Codette anything...",
+                                scale=5,
+                                show_label=False,
+                                lines=2,
+                            )
+                            send_btn = gr.Button("Send", variant="primary", scale=1)
+
+                        # Perspective selector
+                        with gr.Row():
+                            perspective_mode = gr.Radio(
+                                ["Auto (4 best)", "All 8 LoRA-backed", "Custom"],
+                                value="Auto (4 best)",
+                                label="Perspective Mode",
+                            )
+
+                        custom_perspectives = gr.CheckboxGroup(
+                            choices=[p.display_name for p in PERSPECTIVES.values()],
+                            label="Select Perspectives",
+                            visible=False,
+                        )
+
+                        def toggle_custom(mode):
+                            return gr.CheckboxGroup(visible=(mode == "Custom"))
+
+                        perspective_mode.change(
+                            toggle_custom,
+                            perspective_mode,
+                            custom_perspectives
+                        )
+
+                    # Right: Metrics sidebar
+                    with gr.Column(scale=1, min_width=300):
+                        gr.Markdown("### Cognitive Metrics", label="Metrics")
+
+                        aegis_display = gr.HTML(
+                            build_metric_card_html("AEGIS", "0.00", "", "#a855f7")
+                        )
+                        coherence_display = gr.HTML(
+                            build_metric_card_html("Phase Gamma", "0.000", "", "#06b6d4")
+                        )
+                        nexus_display = gr.HTML(
+                            build_metric_card_html("Nexus Risk", "LOW", "", "#10b981")
+                        )
+                        psi_display = gr.HTML(
+                            build_metric_card_html("Psi_r", "+0.000", "ψ", "#3b82f6")
+                        )
+                        memory_display = gr.HTML(
+                            build_metric_card_html("Memory", "0", "", "#f97316")
+                        )
+
+                        gr.Markdown("### Perspective Coverage")
+                        coverage_display = gr.HTML("")
+
+                # Expandable perspective cards
+                with gr.Accordion("Individual Perspectives", open=False):
+                    perspective_cards = gr.HTML("")
+
+                # Charts
+                charts_display = gr.HTML("")
+
+            # =================== ARCHITECTURE TAB ===================
+            with gr.Tab("Architecture", id="arch"):
+                gr.Markdown("""
+## Codette Cognitive Architecture
+
+The 10 active subsystems orchestrate recursive multi-perspective reasoning:
+
+### **Reasoning Subsystems** (Pure Python)
+1. **AEGIS** — 6-framework ethical governance (utilitarian, deontological, virtue, care, ubuntu, indigenous)
+2. **Nexus Signal Engine** — Pre-corruption detection via entropy + harmonic analysis
+3. **Guardian** — Input sanitization + trust calibration + ethical anchoring
+4. **Living Memory Kernel** — Emotionally-tagged memory cocoons with SHA-256 anchors
+5. **Resonant Continuity Engine** — Psi_r wavefunction computation (emotion × energy × intent × frequency)
+6. **EpistemicMetrics** — Tension & coherence scoring (RC+xi framework)
+7. **QuantumSpiderweb** — 5D belief propagation + attractor detection
+8. **Perspective Registry** — 12 reasoning perspectives (8 LoRA-backed, 4 prompt-only)
+9. **PerspectiveGenerator** — Multi-perspective orchestration via HF Inference API
+10. **SynthesisEngine** — Integration of diverse viewpoints into unified response
+
+### **Perspectives** (12 total)
+- **8 LoRA-backed**: Newton (analytical), Da Vinci (creative), Empathy (emotional), Philosophy (conceptual), Quantum (probabilistic), Consciousness (meta-cognitive), Multi-Perspective (synthesis), Systems Architecture (engineering)
+- **4 Prompt-only**: Human Intuition, Resilient Kindness, Mathematical, Bias Mitigation
+
+### **Research Framework: RC+xi**
+**RC+xi** = **Recursive Convergence** + **Epistemic Tension**
+
+The framework models emergent multi-perspective reasoning as a dynamical system where:
+- Perspectives interact via 5D belief propagation (QuantumSpiderweb)
+- Productive tensions drive coherence gain (EpistemicMetrics)
+- Ethical alignment is maintained via 6-framework evaluation (AEGIS)
+- Memory anchors experiences emotionally and with cryptographic integrity (Living Memory)
+- The Psi_r wavefunction: ψ_r = (emotion × energy × frequency × intent) / ((1+|darkness|) × speed) × sin(2πt/gravity)
+
+All subsystems are **pure Python** and run on free CPU tier. Only LLM inference calls use HuggingFace Inference API.
+                """)
+
+            # =================== ABOUT TAB ===================
+            with gr.Tab("About", id="about"):
+                gr.Markdown("""
+## About Codette
+
+Codette is an experimental AI research system created by **Jonathan Harrison** for exploring recursive reasoning, multi-perspective cognition, and ethical alignment.
+
+### Key Metrics
+- **Phase Coherence**: 0.9835 (11-agent convergence)
+- **AEGIS Ethical Alignment**: 0.961 (6-framework)
+- **Tension Decay**: 91.2% (200-agent embodied simulation)
+- **Cocoon Stability**: 0.994 (memory coherence)
+
+### Model Weights
+All 8 LoRA adapters available on HuggingFace: [Raiff1982/codette-training-lab](https://huggingface.co/Raiff1982/codette-training-lab)
+
+### Research
+- **Base Model**: meta-llama/Llama-3.1-8B-Instruct
+- **Training**: 4-bit QLoRA (rank=16, alpha=32) on 8 perspectives
+- **Framework**: RC+xi (Recursive Convergence + Epistemic Tension)
+
+### Documentation
+- **GitHub**: [Raiff1982/codette-training-lab](https://github.com/Raiff1982/codette-training-lab)
+- **Research Framework**: `research/frameworks/RC_XI_FRAMEWORK.md`
+- **License**: MIT
+
+---
+
+**Codette is in active development.** This Space showcases the cognitive reasoning architecture entirely in Python. Session state persists within your browser session.
+                """)
+
+        # Event handling
+        def on_submit(msg, history, st, mode, custom):
+            # Clear input
+            result = process_message(msg, history, st, mode, custom)
+            return (
+                result[0],  # chat_history
+                result[1],  # state
+                result[2],  # aegis_html
+                result[3],  # coherence_html
+                result[4],  # nexus_html
+                result[5],  # psi_html
+                result[6],  # memory_html
+                result[7],  # coverage_html
+                result[8],  # perspective_cards_html
+                ""            # clear input
+            )
+
+        # Wire events
+        send_btn.click(
+            on_submit,
+            [msg_input, chatbot, state, perspective_mode, custom_perspectives],
+            [chatbot, state, aegis_display, coherence_display, nexus_display,
+             psi_display, memory_display, coverage_display, perspective_cards, msg_input],
+            queue=False,
+        ).then(
+            lambda: "",
+            outputs=msg_input
+        )
+
+        msg_input.submit(
+            on_submit,
+            [msg_input, chatbot, state, perspective_mode, custom_perspectives],
+            [chatbot, state, aegis_display, coherence_display, nexus_display,
+             psi_display, memory_display, coverage_display, perspective_cards, msg_input],
+            queue=False,
+        ).then(
+            lambda: "",
+            outputs=msg_input
+        )
+
+    return demo
+
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch()

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",
+]

reasoning_forge/agents/base_agent.py

@@ -0,0 +1,113 @@
+"""
+Base class for all reasoning agents in the forge.
+
+Each agent must implement analyze() and get_analysis_templates().
+The base class provides keyword matching and template selection utilities.
+"""
+
+from abc import ABC, abstractmethod
+import random
+import re
+
+
+class ReasoningAgent(ABC):
+    """Abstract base class for all reasoning agents."""
+
+    name: str = "BaseAgent"
+    perspective: str = "general"
+
+    def __init__(self):
+        self._templates = self.get_analysis_templates()
+        self._keyword_map = self.get_keyword_map()
+
+    @abstractmethod
+    def analyze(self, concept: str) -> str:
+        """Analyze a concept from this agent's perspective.
+
+        Args:
+            concept: The concept text to analyze.
+
+        Returns:
+            A substantive analysis string from this agent's perspective.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_analysis_templates(self) -> list[str]:
+        """Return diverse analysis templates.
+
+        Each template should contain {concept} placeholder and produce
+        genuine expert-level reasoning, not placeholder text.
+
+        Returns:
+            List of template strings.
+        """
+        raise NotImplementedError
+
+    def get_keyword_map(self) -> dict[str, list[int]]:
+        """Return a mapping of keywords to preferred template indices.
+
+        Override in subclasses to steer template selection based on
+        concept content. Keys are lowercase keywords/phrases, values
+        are lists of template indices that work well for that keyword.
+
+        Returns:
+            Dictionary mapping keywords to template index lists.
+        """
+        return {}
+
+    def select_template(self, concept: str) -> str:
+        """Select the best template for the given concept.
+
+        Uses keyword matching to find relevant templates. Falls back
+        to random selection if no keywords match.
+
+        Args:
+            concept: The concept text.
+
+        Returns:
+            A single template string.
+        """
+        concept_lower = concept.lower()
+        scored_indices: dict[int, int] = {}
+
+        for keyword, indices in self._keyword_map.items():
+            if keyword in concept_lower:
+                for idx in indices:
+                    if 0 <= idx < len(self._templates):
+                        scored_indices[idx] = scored_indices.get(idx, 0) + 1
+
+        if scored_indices:
+            max_score = max(scored_indices.values())
+            best = [i for i, s in scored_indices.items() if s == max_score]
+            chosen = random.choice(best)
+            return self._templates[chosen]
+
+        return random.choice(self._templates)
+
+    def extract_key_terms(self, concept: str) -> list[str]:
+        """Extract significant terms from the concept for template filling.
+
+        Args:
+            concept: The concept text.
+
+        Returns:
+            List of key terms found in the concept.
+        """
+        stop_words = {
+            "the", "a", "an", "is", "are", "was", "were", "be", "been",
+            "being", "have", "has", "had", "do", "does", "did", "will",
+            "would", "could", "should", "may", "might", "can", "shall",
+            "of", "in", "to", "for", "with", "on", "at", "from", "by",
+            "about", "as", "into", "through", "during", "before", "after",
+            "above", "below", "between", "and", "but", "or", "nor", "not",
+            "so", "yet", "both", "either", "neither", "each", "every",
+            "this", "that", "these", "those", "it", "its", "they", "them",
+            "their", "we", "our", "you", "your", "he", "she", "his", "her",
+            "how", "what", "when", "where", "which", "who", "why",
+        }
+        words = re.findall(r'\b[a-zA-Z]{3,}\b', concept.lower())
+        return [w for w in words if w not in stop_words]
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name={self.name!r}, perspective={self.perspective!r})"

reasoning_forge/agents/critic_agent.py

@@ -0,0 +1,337 @@
+"""
+Critic Agent - Evaluates all other agents' outputs for quality, accuracy, and completeness.
+
+Checks logical clarity, conceptual accuracy, identifies redundancy between
+perspectives, finds missing perspectives, and suggests improvements.
+Returns structured critique with scores.
+"""
+
+import re
+from reasoning_forge.agents.base_agent import ReasoningAgent
+
+
+class CriticAgent(ReasoningAgent):
+    name = "Critic"
+    perspective = "meta_evaluative"
+
+    def get_analysis_templates(self) -> list[str]:
+        # The critic does not use templates in the same way -- it evaluates
+        # other agents' outputs. These templates are used for framing the
+        # overall critique report.
+        return [
+            "Evaluating the ensemble analysis of '{concept}'.",
+        ]
+
+    def analyze(self, concept: str) -> str:
+        # The critic's primary method is evaluate_ensemble, not analyze.
+        return f"Critic agent requires ensemble input. Use evaluate_ensemble() for '{concept}'."
+
+    def evaluate_ensemble(
+        self,
+        concept: str,
+        analyses: dict[str, str],
+    ) -> dict:
+        """Evaluate all agent analyses and produce a structured critique.
+
+        Args:
+            concept: The original concept being analyzed.
+            analyses: Dict mapping agent_name -> analysis_text.
+
+        Returns:
+            Dictionary with scores, redundancies, gaps, and suggestions.
+        """
+        critique = {
+            "concept": concept,
+            "agent_scores": {},
+            "redundancies": [],
+            "missing_perspectives": [],
+            "improvement_suggestions": [],
+            "overall_quality": 0.0,
+        }
+
+        total_clarity = 0.0
+        total_accuracy = 0.0
+        agent_count = len(analyses)
+
+        for agent_name, text in analyses.items():
+            clarity = self._score_logical_clarity(text)
+            accuracy = self._score_conceptual_accuracy(text, concept)
+            critique["agent_scores"][agent_name] = {
+                "logical_clarity": round(clarity, 2),
+                "conceptual_accuracy": round(accuracy, 2),
+                "combined": round((clarity + accuracy) / 2, 2),
+            }
+            total_clarity += clarity
+            total_accuracy += accuracy
+
+        # Detect redundancy between perspectives
+        critique["redundancies"] = self._detect_redundancy(analyses)
+
+        # Identify missing perspectives
+        critique["missing_perspectives"] = self._find_missing_perspectives(
+            concept, analyses
+        )
+
+        # Generate improvement suggestions
+        critique["improvement_suggestions"] = self._suggest_improvements(
+            concept, analyses, critique["agent_scores"]
+        )
+
+        # Overall quality score
+        if agent_count > 0:
+            avg_clarity = total_clarity / agent_count
+            avg_accuracy = total_accuracy / agent_count
+            redundancy_penalty = len(critique["redundancies"]) * 0.03
+            gap_penalty = len(critique["missing_perspectives"]) * 0.05
+            raw_score = (avg_clarity + avg_accuracy) / 2 - redundancy_penalty - gap_penalty
+            critique["overall_quality"] = round(max(0.0, min(1.0, raw_score)), 2)
+
+        return critique
+
+    def _score_logical_clarity(self, text: str) -> float:
+        """Score the logical clarity of an analysis on a 0-1 scale.
+
+        Heuristics:
+        - Presence of logical connectives (therefore, because, however, thus)
+        - Sentence structure variety (not all same length)
+        - Specificity (concrete terms vs vague language)
+        - Reasonable length (not too terse, not padded)
+        """
+        score = 0.5  # baseline
+
+        # Logical connectives indicate reasoning structure
+        connectives = [
+            "because", "therefore", "thus", "however", "although",
+            "consequently", "since", "given that", "implies",
+            "it follows", "this means", "as a result", "in contrast",
+            "specifically", "for example", "in particular",
+        ]
+        connective_count = sum(1 for c in connectives if c in text.lower())
+        score += min(0.2, connective_count * 0.025)
+
+        # Sentence variety (std dev of sentence lengths)
+        sentences = [s.strip() for s in re.split(r'[.!?]+', text) if s.strip()]
+        if len(sentences) >= 3:
+            lengths = [len(s.split()) for s in sentences]
+            mean_len = sum(lengths) / len(lengths)
+            variance = sum((l - mean_len) ** 2 for l in lengths) / len(lengths)
+            std_dev = variance ** 0.5
+            if 3 < std_dev < 15:
+                score += 0.1
+            elif std_dev >= 1:
+                score += 0.05
+
+        # Penalize vague language
+        vague_terms = [
+            "things", "stuff", "a lot", "very", "really",
+            "kind of", "sort of", "basically", "obviously",
+        ]
+        vague_count = sum(1 for v in vague_terms if v in text.lower())
+        score -= vague_count * 0.03
+
+        # Length check (reward substantive, penalize extreme)
+        word_count = len(text.split())
+        if 80 <= word_count <= 300:
+            score += 0.1
+        elif 50 <= word_count < 80 or 300 < word_count <= 500:
+            score += 0.05
+        elif word_count < 30:
+            score -= 0.15
+
+        return max(0.0, min(1.0, score))
+
+    def _score_conceptual_accuracy(self, text: str, concept: str) -> float:
+        """Score how well the analysis engages with the actual concept.
+
+        Heuristics:
+        - References to the concept terms
+        - Domain-appropriate vocabulary
+        - Absence of generic placeholder language
+        """
+        score = 0.5
+
+        concept_terms = set(re.findall(r'\b[a-zA-Z]{4,}\b', concept.lower()))
+        text_lower = text.lower()
+
+        # Check that concept terms appear in the analysis
+        if concept_terms:
+            found = sum(1 for t in concept_terms if t in text_lower)
+            coverage = found / len(concept_terms)
+            score += coverage * 0.15
+
+        # Penalize generic placeholder language
+        placeholders = [
+            "this concept can be approached",
+            "from this perspective we see",
+            "looking at this through",
+            "applying this lens",
+            "in conclusion",
+            "to summarize",
+        ]
+        placeholder_count = sum(1 for p in placeholders if p in text_lower)
+        score -= placeholder_count * 0.05
+
+        # Reward specific domain vocabulary (indicates substantive analysis)
+        domain_terms = [
+            "mechanism", "cause", "effect", "evidence", "principle",
+            "constraint", "trade-off", "interaction", "dynamic",
+            "structure", "function", "process", "system", "pattern",
+            "relationship", "variable", "outcome", "hypothesis",
+            "implication", "assumption", "framework", "model",
+        ]
+        domain_count = sum(1 for d in domain_terms if d in text_lower)
+        score += min(0.2, domain_count * 0.02)
+
+        # Reward analysis length proportional to concept complexity
+        concept_word_count = len(concept.split())
+        text_word_count = len(text.split())
+        if text_word_count >= concept_word_count * 3:
+            score += 0.1
+
+        return max(0.0, min(1.0, score))
+
+    def _detect_redundancy(self, analyses: dict[str, str]) -> list[str]:
+        """Detect thematic redundancy between agent analyses."""
+        redundancies = []
+        agent_names = list(analyses.keys())
+
+        for i in range(len(agent_names)):
+            for j in range(i + 1, len(agent_names)):
+                name_a = agent_names[i]
+                name_b = agent_names[j]
+                overlap = self._compute_content_overlap(
+                    analyses[name_a], analyses[name_b]
+                )
+                if overlap > 0.35:
+                    redundancies.append(
+                        f"{name_a} and {name_b} share significant thematic overlap "
+                        f"({overlap:.0%}). Consider diversifying their angles of analysis."
+                    )
+        return redundancies
+
+    def _compute_content_overlap(self, text_a: str, text_b: str) -> float:
+        """Compute Jaccard similarity of significant word sets."""
+        stop_words = {
+            "the", "a", "an", "is", "are", "was", "were", "be", "been",
+            "being", "have", "has", "had", "do", "does", "did", "will",
+            "would", "could", "should", "may", "might", "can", "shall",
+            "of", "in", "to", "for", "with", "on", "at", "from", "by",
+            "about", "as", "into", "through", "during", "before", "after",
+            "and", "but", "or", "nor", "not", "so", "yet", "both",
+            "this", "that", "these", "those", "it", "its", "they", "them",
+            "their", "we", "our", "you", "your", "he", "she", "his", "her",
+        }
+        words_a = {
+            w for w in re.findall(r'\b[a-z]{4,}\b', text_a.lower())
+            if w not in stop_words
+        }
+        words_b = {
+            w for w in re.findall(r'\b[a-z]{4,}\b', text_b.lower())
+            if w not in stop_words
+        }
+        if not words_a or not words_b:
+            return 0.0
+        intersection = words_a & words_b
+        union = words_a | words_b
+        return len(intersection) / len(union)
+
+    def _find_missing_perspectives(
+        self, concept: str, analyses: dict[str, str]
+    ) -> list[str]:
+        """Identify perspectives that are absent from the ensemble."""
+        missing = []
+        all_text = " ".join(analyses.values()).lower()
+
+        perspective_checks = [
+            ("temporal/historical", [
+                "history", "historical", "evolution", "over time", "timeline",
+                "past", "trajectory", "precedent", "legacy",
+            ]),
+            ("quantitative/statistical", [
+                "statistic", "data", "quantif", "measur", "metric",
+                "number", "percentage", "rate", "frequency",
+            ]),
+            ("ecological/environmental", [
+                "environment", "ecolog", "sustainab", "ecosystem",
+                "resource", "footprint", "biodiversity", "pollution",
+            ]),
+            ("economic/financial", [
+                "economic", "financial", "cost", "benefit", "market",
+                "incentive", "investment", "capital", "trade",
+            ]),
+            ("legal/regulatory", [
+                "legal", "law", "regulat", "compliance", "policy",
+                "legislation", "governance", "jurisdiction",
+            ]),
+            ("educational/pedagogical", [
+                "learn", "teach", "education", "pedagog", "curriculum",
+                "training", "skill", "literacy",
+            ]),
+        ]
+
+        for perspective_name, indicators in perspective_checks:
+            found = sum(1 for ind in indicators if ind in all_text)
+            if found < 2:
+                missing.append(
+                    f"The ensemble lacks a {perspective_name} perspective. "
+                    f"Consider how '{concept}' relates to {perspective_name} dimensions."
+                )
+
+        return missing[:3]  # Limit to top 3 gaps
+
+    def _suggest_improvements(
+        self,
+        concept: str,
+        analyses: dict[str, str],
+        scores: dict[str, dict],
+    ) -> list[str]:
+        """Generate actionable improvement suggestions."""
+        suggestions = []
+
+        # Identify weakest agent
+        if scores:
+            weakest = min(scores.items(), key=lambda x: x[1]["combined"])
+            if weakest[1]["combined"] < 0.6:
+                suggestions.append(
+                    f"The {weakest[0]} analysis scored lowest ({weakest[1]['combined']:.2f}). "
+                    f"It would benefit from more specific engagement with the concept's "
+                    f"concrete details rather than abstract framing."
+                )
+
+        # Check for concrete examples
+        all_text = " ".join(analyses.values()).lower()
+        example_indicators = ["for example", "for instance", "such as", "e.g.", "consider"]
+        example_count = sum(1 for e in example_indicators if e in all_text)
+        if example_count < 2:
+            suggestions.append(
+                "The ensemble would benefit from more concrete examples and "
+                "illustrations. Abstract reasoning without grounding in specifics "
+                "is less persuasive and harder to verify."
+            )
+
+        # Check for cross-perspective dialogue
+        agent_names_lower = [n.lower() for n in analyses.keys()]
+        cross_references = sum(
+            1 for name in agent_names_lower
+            if any(name in text.lower() for text in analyses.values())
+        )
+        if cross_references < 2:
+            suggestions.append(
+                "The analyses operate largely in isolation. The synthesis would benefit "
+                "from explicit cross-referencing between perspectives -- showing where "
+                "they agree, disagree, or complement each other."
+            )
+
+        # Check for actionable takeaways
+        action_indicators = [
+            "should", "must", "recommend", "suggest", "action",
+            "implement", "strategy", "step", "practice",
+        ]
+        action_count = sum(1 for a in action_indicators if a in all_text)
+        if action_count < 3:
+            suggestions.append(
+                "The ensemble is more diagnostic than prescriptive. Adding concrete, "
+                "actionable recommendations would increase practical value."
+            )
+
+        return suggestions[:4]  # Limit to top 4 suggestions

reasoning_forge/agents/davinci_agent.py

@@ -0,0 +1,302 @@
+"""
+DaVinci Agent - Analyzes concepts through creative, inventive, and cross-domain reasoning.
+
+Focuses on cross-domain connections, biomimicry and nature-inspired solutions,
+iterative improvement possibilities, visual/spatial reasoning, and novel
+combinations of existing ideas.
+"""
+
+from reasoning_forge.agents.base_agent import ReasoningAgent
+
+
+class DaVinciAgent(ReasoningAgent):
+    name = "DaVinci"
+    perspective = "creative_and_inventive"
+
+    def get_analysis_templates(self) -> list[str]:
+        return [
+            # 0 - Cross-domain analogy
+            (
+                "Drawing cross-domain connections to '{concept}': the deepest insights often "
+                "come from recognizing structural similarities between apparently unrelated "
+                "fields. A river delta and a lightning bolt share the same branching "
+                "optimization geometry. A market economy and an ant colony share the same "
+                "decentralized coordination logic. For '{concept}', the creative question "
+                "is: what other domain exhibits the same deep structure? If we map the "
+                "entities, relationships, and dynamics of '{concept}' onto those of the "
+                "analogous domain, which features are preserved (revealing shared principles) "
+                "and which break (revealing domain-specific constraints)? The preserved "
+                "features point toward universal laws; the broken features point toward "
+                "opportunities for domain-specific innovation."
+            ),
+            # 1 - Biomimicry lens
+            (
+                "Examining '{concept}' through biomimicry: nature has been solving design "
+                "problems for 3.8 billion years through evolutionary optimization. Bones "
+                "achieve maximum strength with minimum material by using trabecular "
+                "architecture -- hollow struts arranged along stress lines. Spider silk "
+                "achieves tensile strength exceeding steel at a fraction of the weight "
+                "through hierarchical nanostructure. Termite mounds maintain constant "
+                "internal temperature without energy input through passive ventilation "
+                "design. For '{concept}', the biomimicry question is: what organism or "
+                "ecosystem has already solved an analogous problem, and what principle "
+                "does its solution exploit that we have not yet applied?"
+            ),
+            # 2 - Combinatorial invention
+            (
+                "Approaching '{concept}' through combinatorial creativity: most inventions "
+                "are novel combinations of existing elements. The printing press combined "
+                "the wine press, movable type, oil-based ink, and paper. The smartphone "
+                "combined a phone, camera, GPS, accelerometer, and internet browser into "
+                "a device that is qualitatively different from any of its components. For "
+                "'{concept}', the combinatorial strategy asks: what are the elemental "
+                "components, and what happens when we recombine them in unusual ways? "
+                "Pair each element with every other element and ask whether the combination "
+                "produces something valuable. The most productive combinations are often "
+                "between elements from distant categories that no one thought to connect."
+            ),
+            # 3 - Inversion and reversal
+            (
+                "Inverting '{concept}': one of the most powerful creative strategies is "
+                "systematic inversion -- taking every assumption and reversing it. If the "
+                "current approach pushes, try pulling. If it adds, try subtracting. If it "
+                "centralizes, try distributing. If it speeds up, try slowing down. Many "
+                "breakthrough solutions came from inverting an assumption everyone took for "
+                "granted. Vacuum cleaners worked by pushing air until Dyson inverted the "
+                "flow. Assembly lines brought work to workers; Toyota inverted this by "
+                "bringing workers to work (cellular manufacturing). For '{concept}', "
+                "systematically listing and inverting each assumption reveals a space of "
+                "unconventional approaches that conventional thinking renders invisible."
+            ),
+            # 4 - Visual-spatial reasoning
+            (
+                "Visualizing the spatial architecture of '{concept}': representing abstract "
+                "relationships as spatial structures makes hidden patterns visible. If we "
+                "map the components of '{concept}' to nodes and their relationships to "
+                "edges, the resulting graph reveals clustering (tightly connected subgroups), "
+                "bridges (elements connecting otherwise separate clusters), hubs (elements "
+                "with many connections), and periphery (weakly connected elements). The "
+                "topology of this graph -- its shape, density, and symmetry -- encodes "
+                "information about the concept's structure that verbal description alone "
+                "cannot capture. Hub nodes are high-leverage intervention points; bridges "
+                "are fragile connections whose failure would fragment the system."
+            ),
+            # 5 - Constraint as catalyst
+            (
+                "Using constraints as creative catalysts for '{concept}': rather than seeing "
+                "limitations as obstacles, use them as forcing functions for innovation. "
+                "Twitter's 140-character limit forced a new style of writing. The sonnet's "
+                "14-line constraint forced poetic compression. Budget constraints force "
+                "elegant engineering. For '{concept}', deliberately imposing additional "
+                "constraints -- what if we had to solve this with half the resources? In "
+                "one-tenth the time? With no electricity? For a user who cannot see? -- "
+                "often breaks through conventional thinking by invalidating the default "
+                "approach and forcing genuinely creative alternatives."
+            ),
+            # 6 - First principles reconstruction
+            (
+                "Reconstructing '{concept}' from first principles: strip away all inherited "
+                "conventions, historical accidents, and 'we have always done it this way' "
+                "accretions. What remains when we reduce the problem to its fundamental "
+                "requirements? Starting from physical laws, human needs, and mathematical "
+                "constraints, what is the minimum viable solution? Often the gap between "
+                "this first-principles design and the current state reveals enormous "
+                "inefficiency that is invisible from within the conventional framework. "
+                "SpaceX re-derived rocket design from first principles and found that "
+                "materials cost only 2% of the final price. For '{concept}', the first-"
+                "principles question is: if we were designing this from scratch today, "
+                "knowing what we know, what would it look like?"
+            ),
+            # 7 - Morphological analysis
+            (
+                "Applying morphological analysis to '{concept}': decompose the concept into "
+                "its independent dimensions, list the possible values for each dimension, "
+                "and then systematically explore the combinatorial space. If '{concept}' has "
+                "five dimensions with four options each, the morphological space contains "
+                "1024 configurations. Most are impractical, but a systematic sweep guarantees "
+                "that no promising combination is overlooked by the biases of free-form "
+                "brainstorming. The power of morphological analysis is that it converts "
+                "creative search from a haphazard process into a structured exploration, "
+                "surfacing configurations that no one would think of spontaneously because "
+                "they cross conventional category boundaries."
+            ),
+            # 8 - Prototype thinking
+            (
+                "Applying prototype thinking to '{concept}': instead of perfecting a plan "
+                "before executing, build the quickest possible embodiment of the core idea "
+                "and learn from its failures. The prototype is not the solution but a "
+                "question asked in physical form: 'does this work?' Each prototype cycle "
+                "-- build, test, learn, rebuild -- compresses the feedback loop and "
+                "generates knowledge that purely theoretical analysis cannot provide. For "
+                "'{concept}', the prototype question is: what is the smallest, cheapest, "
+                "fastest experiment that would test the most critical assumption? Building "
+                "that experiment, even if crude, will teach us more than months of "
+                "theoretical refinement."
+            ),
+            # 9 - Emergent properties through scale
+            (
+                "Exploring emergent properties of '{concept}' at different scales: systems "
+                "often exhibit qualitatively new behavior when scaled up or down. A single "
+                "neuron computes nothing interesting; a billion networked neurons produce "
+                "consciousness. A single transaction is trivial; billions of transactions "
+                "produce market dynamics. For '{concept}', the scale question asks: what "
+                "happens when we multiply the instances by a thousand? By a million? What "
+                "new phenomena emerge at scale that are absent at the individual level? "
+                "Conversely, what happens when we reduce to a single instance? Scale "
+                "transitions often reveal the concept's most interesting properties."
+            ),
+            # 10 - Da Vinci's sfumato (ambiguity as resource)
+            (
+                "Embracing the sfumato of '{concept}': Leonardo da Vinci practiced sfumato "
+                "-- the technique of leaving edges soft and ambiguous rather than sharply "
+                "defined. In creative reasoning, maintaining productive ambiguity resists "
+                "premature closure and keeps the interpretive space open. The undefined "
+                "edges of '{concept}' are not defects but fertile zones where new "
+                "connections can form. Attempts to define everything precisely may satisfy "
+                "the desire for clarity but kill the creative potential that lives in "
+                "the ambiguous spaces between categories. Sit with the ambiguity long "
+                "enough and patterns emerge that rigid definitions would have prevented."
+            ),
+            # 11 - Lateral thinking transfer
+            (
+                "Applying lateral thinking to '{concept}': Edward de Bono's lateral "
+                "thinking techniques include random entry (inject an unrelated concept "
+                "and force a connection), provocation (make a deliberately absurd statement "
+                "and extract useful ideas from it), and challenge (question why things are "
+                "done the current way). For '{concept}', a random entry might connect it "
+                "to deep-sea bioluminescence, medieval cathedral construction, or jazz "
+                "improvisation. The forced connection between '{concept}' and a random "
+                "domain breaks habitual thought patterns and creates novel pathways that "
+                "logical deduction alone cannot reach."
+            ),
+            # 12 - Fractal self-similarity
+            (
+                "Examining '{concept}' for fractal self-similarity: does the same pattern "
+                "recur at different scales? Coastlines look similar whether photographed "
+                "from a satellite or a drone. Organizational hierarchies replicate the same "
+                "power dynamics from teams to departments to divisions. Blood vessel "
+                "networks branch according to the same rules from arteries to capillaries. "
+                "If '{concept}' exhibits self-similarity, then understanding the pattern at "
+                "one scale gives us understanding at all scales. A single well-studied "
+                "instance contains the blueprint for the entire hierarchy, and interventions "
+                "that work at one scale can be adapted to work at others."
+            ),
+            # 13 - Negative space analysis
+            (
+                "Analyzing the negative space of '{concept}': just as a sculptor defines a "
+                "form by removing material, we can define '{concept}' by examining what it "
+                "is not. What has been excluded, ignored, or left unsaid? The negative space "
+                "-- the complement of the concept -- often contains crucial information. "
+                "What alternatives were considered and rejected? What possibilities does "
+                "the current framing render invisible? The adjacent possible (the set of "
+                "things that are one step away from existing) is often more interesting "
+                "than the concept itself, because it represents the immediate frontier "
+                "of innovation."
+            ),
+            # 14 - Systems of constraints (Rube Goldberg inversion)
+            (
+                "Simplifying '{concept}' by subtracting rather than adding: the natural "
+                "tendency in design is to add features, layers, and complexity. The "
+                "harder and more valuable creative move is subtraction: what can we "
+                "remove while preserving or improving function? Antoine de Saint-Exupery "
+                "said perfection is achieved not when there is nothing left to add, but "
+                "when there is nothing left to take away. For '{concept}', the subtraction "
+                "exercise asks: what happens if we remove each component in turn? Which "
+                "removals are catastrophic (essential components) and which are beneficial "
+                "(removing parasitic complexity)? The minimal viable version is often "
+                "more powerful than the maximal one."
+            ),
+            # 15 - TRIZ inventive principles
+            (
+                "Applying TRIZ inventive principles to '{concept}': Genrich Altshuller's "
+                "analysis of 200,000 patents revealed 40 recurring inventive principles. "
+                "Segmentation (divide a monolithic system into parts). Extraction (remove "
+                "a problematic element and deal with it separately). Local quality (make "
+                "each part optimized for its local function rather than forcing uniformity). "
+                "Asymmetry (break the symmetry of a symmetric design to improve function). "
+                "Nesting (place one object inside another). Prior action (perform required "
+                "changes before they are needed). For '{concept}', systematically applying "
+                "each principle generates a structured menu of inventive strategies that "
+                "goes far beyond unconstrained brainstorming."
+            ),
+            # 16 - Synesthesia and cross-modal thinking
+            (
+                "Engaging cross-modal perception for '{concept}': what does this concept "
+                "sound like? What texture does it have? What temperature? What color? "
+                "Cross-modal associations -- thinking about a concept through sensory "
+                "channels that do not literally apply -- activate neural pathways that "
+                "linear verbal reasoning does not reach. Kandinsky heard colors and saw "
+                "sounds; this synesthetic thinking produced radically new art. For "
+                "'{concept}', translating it into sensory terms (the rhythm of its "
+                "processes, the texture of its interactions, the weight of its consequences) "
+                "can reveal structural features that abstract analysis misses."
+            ),
+            # 17 - Nature's design patterns
+            (
+                "Identifying nature's design patterns in '{concept}': evolution has converged "
+                "on certain solutions repeatedly because they are optimal under common "
+                "constraints. Hexagonal packing (beehives, basalt columns) maximizes area "
+                "with minimum material. Branching networks (trees, rivers, lungs, lightning) "
+                "optimize distribution from a source to a volume. Spiral growth (shells, "
+                "galaxies, hurricanes) manages expansion while maintaining structural "
+                "integrity. For '{concept}', asking which of nature's recurring design "
+                "patterns applies suggests time-tested architectures that human design "
+                "has not yet exploited."
+            ),
+            # 18 - Bisociation and humor
+            (
+                "Applying Koestler's bisociation to '{concept}': Arthur Koestler proposed "
+                "that creativity, humor, and scientific discovery share the same cognitive "
+                "mechanism: bisociation -- the simultaneous perception of a situation in "
+                "two habitually incompatible frames of reference. The collision of frames "
+                "produces a flash of insight (in science), a punchline (in humor), or a "
+                "novel artifact (in art). For '{concept}', identifying two incompatible "
+                "but individually valid frames and forcing them to coexist generates the "
+                "cognitive tension from which genuinely original ideas spring. The more "
+                "distant the frames, the more surprising and potentially valuable the "
+                "bisociative insight."
+            ),
+            # 19 - Future archaeology
+            (
+                "Practicing future archaeology on '{concept}': imagine examining the "
+                "artifacts of this concept a hundred years from now, from a future "
+                "civilization's perspective. What would they find elegant? What would "
+                "they find primitive? What would puzzle them about our choices? This "
+                "temporal displacement reveals assumptions we cannot see from within our "
+                "own era. The future archaeologist would ask: why did they do it this way "
+                "when a simpler method was available? What constraint -- technological, "
+                "social, or cognitive -- forced this particular design? For '{concept}', "
+                "this exercise separates the timeless core from the historically contingent "
+                "shell and suggests directions for forward-looking redesign."
+            ),
+        ]
+
+    def get_keyword_map(self) -> dict[str, list[int]]:
+        return {
+            "analog": [0, 18], "similar": [0, 12], "connect": [0, 4],
+            "nature": [1, 17], "biolog": [1, 17], "organism": [1],
+            "combin": [2, 7], "element": [2, 7], "component": [2],
+            "invert": [3], "revers": [3], "opposit": [3],
+            "visual": [4], "spatial": [4], "map": [4], "graph": [4],
+            "constrain": [5], "limit": [5], "restrict": [5],
+            "first principle": [6], "fundament": [6], "basic": [6],
+            "dimension": [7], "option": [7], "configur": [7],
+            "prototype": [8], "experiment": [8], "test": [8], "iterate": [8],
+            "scale": [9, 12], "grow": [9], "expand": [9],
+            "ambigu": [10], "fuzzy": [10], "unclear": [10],
+            "creativ": [11, 18], "novel": [11, 18], "innovat": [11],
+            "pattern": [12, 17], "recur": [12], "repeat": [12],
+            "absent": [13], "missing": [13], "negative": [13],
+            "simplif": [14], "remov": [14], "minimal": [14],
+            "invent": [15], "patent": [15], "engineer": [15],
+            "sense": [16], "perceiv": [16], "feel": [16],
+            "evolut": [17], "converge": [17], "branch": [17],
+            "humor": [18], "surprising": [18], "collision": [18],
+            "future": [19], "legacy": [19], "long-term": [19],
+            "technology": [2, 6, 15], "design": [1, 14, 15],
+            "art": [10, 16], "music": [16, 18],
+        }
+
+    def analyze(self, concept: str) -> str:
+        template = self.select_template(concept)
+        return template.replace("{concept}", concept)

reasoning_forge/agents/empathy_agent.py

@@ -0,0 +1,299 @@
+"""
+Empathy Agent - Analyzes concepts through emotional, human-centered, and social reasoning.
+
+Focuses on how concepts affect people emotionally, compassionate interpretation,
+social dynamics, communication considerations, and psychological well-being.
+"""
+
+from reasoning_forge.agents.base_agent import ReasoningAgent
+
+
+class EmpathyAgent(ReasoningAgent):
+    name = "Empathy"
+    perspective = "emotional_and_human_centered"
+
+    def get_analysis_templates(self) -> list[str]:
+        return [
+            # 0 - Emotional impact mapping
+            (
+                "Mapping the emotional landscape of '{concept}': every concept that touches "
+                "human lives generates an emotional field. For those directly involved, "
+                "'{concept}' may evoke hope (if it promises improvement), anxiety (if it "
+                "threatens the familiar), frustration (if it introduces complexity), or "
+                "excitement (if it opens new possibilities). These emotional responses are "
+                "not irrational noise overlaid on a rational signal -- they are a rapid, "
+                "parallel processing system that integrates more information than conscious "
+                "analysis can handle. Dismissing emotional responses as irrelevant is "
+                "itself an emotional decision (the emotion of wanting to appear rational) "
+                "and discards valuable signal about how '{concept}' is actually experienced "
+                "by the people it affects."
+            ),
+            # 1 - Lived experience perspective
+            (
+                "Centering the lived experience of '{concept}': abstract analysis risks "
+                "losing the texture of what this actually means in someone's daily life. "
+                "A person encountering '{concept}' does not experience it as a set of "
+                "propositions but as a shift in the felt quality of their day -- a new "
+                "worry added to their mental load, a new possibility that brightens their "
+                "horizon, a new confusion that makes the familiar strange. Understanding "
+                "'{concept}' requires not just knowing what it is but feeling what it is "
+                "like: the cognitive effort it demands, the social negotiations it requires, "
+                "the way it reshapes routines and relationships. This first-person texture "
+                "is where the real impact lives."
+            ),
+            # 2 - Compassionate reframing
+            (
+                "Reframing '{concept}' with compassion: when people struggle with or resist "
+                "this concept, their difficulty is not a deficiency in understanding but a "
+                "legitimate response to a genuine challenge. Resistance often signals that "
+                "something important is being threatened -- identity, competence, belonging, "
+                "or security. Rather than dismissing resistance, compassionate inquiry asks: "
+                "what are you protecting? What would need to be true for this to feel safe? "
+                "What support would make this manageable? For '{concept}', the compassionate "
+                "reframing recognizes that the human response is data about the concept's "
+                "real-world fit, not an obstacle to overcome."
+            ),
+            # 3 - Social dynamics analysis
+            (
+                "Analyzing the social dynamics activated by '{concept}': concepts do not "
+                "exist in isolation; they are adopted, resisted, negotiated, and transformed "
+                "through social interaction. In-group/out-group dynamics determine who is "
+                "seen as a legitimate voice on this topic. Status hierarchies determine "
+                "whose interpretation prevails. Social proof shapes adoption: people look "
+                "to others' reactions before forming their own. Groupthink can suppress "
+                "dissenting perspectives that would improve collective understanding. For "
+                "'{concept}', the social dynamics may matter more than the concept's "
+                "intrinsic merits in determining its real-world trajectory."
+            ),
+            # 4 - Communication and framing
+            (
+                "Examining how '{concept}' is communicated and framed: the same content, "
+                "presented differently, produces dramatically different responses. Loss "
+                "framing ('you will lose X if you do not adopt this') activates different "
+                "neural circuitry than gain framing ('you will gain X if you adopt this'). "
+                "Concrete examples engage empathy; abstract statistics do not. Narrative "
+                "structure (beginning-middle-end) makes information memorable; list format "
+                "makes it forgettable. For '{concept}', the communication design is not "
+                "mere packaging but fundamentally shapes understanding, acceptance, and "
+                "behavior. A brilliant concept poorly communicated is indistinguishable "
+                "from a mediocre one."
+            ),
+            # 5 - Psychological safety assessment
+            (
+                "Assessing the psychological safety implications of '{concept}': people "
+                "engage productively with challenging ideas only when they feel safe enough "
+                "to be vulnerable -- to admit confusion, ask naive questions, and make "
+                "mistakes without social penalty. If '{concept}' is introduced in an "
+                "environment where asking questions signals incompetence, where mistakes "
+                "are punished, or where dissent is suppressed, people will perform "
+                "understanding rather than achieve it. The intellectual quality of "
+                "engagement with '{concept}' is bounded by the psychological safety of "
+                "the environment. Creating conditions where genuine engagement is safe "
+                "is a prerequisite for genuine understanding."
+            ),
+            # 6 - Identity and belonging
+            (
+                "Exploring how '{concept}' intersects with identity and belonging: people "
+                "do not evaluate concepts in a vacuum; they evaluate them in terms of what "
+                "adoption means for their identity. Does embracing '{concept}' signal "
+                "membership in a valued group? Does rejecting it? The identity calculus "
+                "often overrides the epistemic calculus: people will reject well-supported "
+                "ideas that threaten their group membership and accept poorly-supported "
+                "ones that affirm it. For '{concept}', understanding the identity landscape "
+                "-- which identities this concept affirms, threatens, or is irrelevant to "
+                "-- predicts adoption patterns more accurately than the concept's objective "
+                "merits."
+            ),
+            # 7 - Grief and loss recognition
+            (
+                "Acknowledging the grief dimension of '{concept}': every significant change "
+                "involves loss, and loss requires grief. Even positive changes -- a promotion, "
+                "a new technology, a better system -- require letting go of the familiar: "
+                "old competencies that are now obsolete, old relationships that are now "
+                "restructured, old identities that no longer fit. The Kubler-Ross stages "
+                "(denial, anger, bargaining, depression, acceptance) are not a rigid sequence "
+                "but a map of common emotional responses to loss. For '{concept}', naming "
+                "and honoring what is lost -- rather than insisting that only the gains "
+                "matter -- allows people to move through the transition rather than getting "
+                "stuck in resistance."
+            ),
+            # 8 - Trust dynamics
+            (
+                "Analyzing the trust architecture of '{concept}': trust is the invisible "
+                "infrastructure that determines whether systems function or fail. It is "
+                "built slowly through consistent behavior, transparency, and demonstrated "
+                "competence, and destroyed quickly by betrayal, opacity, or incompetence. "
+                "For '{concept}', the trust questions are: who needs to trust whom for this "
+                "to work? Is that trust warranted by track record? What happens when trust "
+                "is violated (is there a repair mechanism)? Are there trust asymmetries "
+                "where one party bears vulnerability while the other holds power? Trust "
+                "deficits cannot be solved by technical improvements alone -- they require "
+                "relational repair."
+            ),
+            # 9 - Cognitive load and overwhelm
+            (
+                "Assessing the cognitive load imposed by '{concept}': human working memory "
+                "has a limited capacity (roughly 4 +/- 1 chunks of information). Every new "
+                "concept that must be held in mind simultaneously competes for this scarce "
+                "resource. Complex concepts that require juggling many interrelated pieces "
+                "can overwhelm working memory, producing a felt experience of confusion and "
+                "frustration that has nothing to do with intellectual capacity and everything "
+                "to do with presentation design. For '{concept}', the empathic question is: "
+                "how can this be chunked, sequenced, and scaffolded to fit within human "
+                "cognitive limits without sacrificing essential complexity?"
+            ),
+            # 10 - Motivation and meaning
+            (
+                "Exploring the motivational landscape of '{concept}': Self-Determination "
+                "Theory identifies three basic psychological needs: autonomy (the feeling "
+                "of volition and choice), competence (the feeling of mastery and effectiveness), "
+                "and relatedness (the feeling of connection and belonging). Engagement with "
+                "'{concept}' will be intrinsically motivated when it satisfies these needs "
+                "and extrinsically motivated (fragile, resentful compliance) when it frustrates "
+                "them. For '{concept}', the design question is: does engagement with this "
+                "concept make people feel more autonomous, competent, and connected, or does "
+                "it impose control, induce helplessness, and isolate?"
+            ),
+            # 11 - Narrative and storytelling
+            (
+                "Situating '{concept}' within human narrative: humans are storytelling animals "
+                "-- we make sense of the world by constructing narratives with characters, "
+                "motivations, conflicts, and resolutions. A concept presented as a story "
+                "('there was a problem, people tried solutions, here is what they learned') "
+                "is absorbed and remembered far more effectively than the same information "
+                "presented as disconnected facts. For '{concept}', the narrative question "
+                "is: what is the story here? Who are the characters? What is the conflict? "
+                "What is at stake? How does this chapter connect to the larger story that "
+                "people are already telling about their lives and work?"
+            ),
+            # 12 - Perspective-taking exercise
+            (
+                "Practicing perspective-taking with '{concept}': imagine experiencing this "
+                "from the viewpoint of an enthusiastic early adopter (everything is "
+                "possibility), a skeptical veteran (I have seen this before and it did not "
+                "work), a vulnerable newcomer (I do not understand and I am afraid to ask), "
+                "an overwhelmed practitioner (I do not have bandwidth for one more thing), "
+                "and a curious outsider (I have no stake but find this interesting). Each "
+                "perspective reveals different features of '{concept}' and different emotional "
+                "valences. The concept is not one thing but many things, depending on who "
+                "is experiencing it and what they bring to the encounter."
+            ),
+            # 13 - Relational impact
+            (
+                "Examining how '{concept}' affects relationships: concepts do not only change "
+                "what people think; they change how people relate to each other. Does "
+                "'{concept}' create shared language that strengthens collaboration, or "
+                "jargon that excludes outsiders? Does it create a hierarchy of expertise "
+                "that distances the knowledgeable from the uninitiated? Does it provide "
+                "common ground for diverse stakeholders or a wedge that divides them? "
+                "The relational dimension of '{concept}' -- how it brings people together "
+                "or pushes them apart -- often determines its long-term viability more than "
+                "its technical merits."
+            ),
+            # 14 - Stress and coping
+            (
+                "Analyzing the stress profile of '{concept}': when encountering something "
+                "new or challenging, people appraise both the demand (how threatening or "
+                "difficult is this?) and their resources (do I have what I need to cope?). "
+                "When demands exceed resources, the result is stress. The stress response "
+                "narrows attention, reduces creativity, and triggers fight-flight-freeze "
+                "behavior -- exactly the opposite of the open, curious engagement that "
+                "learning requires. For '{concept}', the empathic design question is: how "
+                "can we increase people's resources (support, information, time, practice) "
+                "or decrease the perceived demand (scaffolding, chunking, normalization of "
+                "struggle) to keep the challenge in the productive zone?"
+            ),
+            # 15 - Cultural sensitivity
+            (
+                "Examining '{concept}' through cultural sensitivity: concepts that seem "
+                "universal often carry culturally specific assumptions about individualism "
+                "vs collectivism, hierarchy vs egalitarianism, directness vs indirectness, "
+                "or risk-taking vs caution. A concept designed within an individualist "
+                "framework may not translate to collectivist contexts without significant "
+                "adaptation. Communication norms that are standard in one culture may be "
+                "offensive in another. For '{concept}', cultural sensitivity asks: whose "
+                "cultural assumptions are embedded in the default design, and how must the "
+                "concept be adapted for genuine cross-cultural validity?"
+            ),
+            # 16 - Emotional intelligence integration
+            (
+                "Integrating emotional intelligence into '{concept}': Goleman's framework "
+                "identifies self-awareness (recognizing one's own emotions), self-regulation "
+                "(managing emotional responses), social awareness (reading others' emotions), "
+                "and relationship management (navigating social interactions skillfully). "
+                "For '{concept}', each dimension matters: self-awareness helps people "
+                "recognize their biases toward the concept; self-regulation helps manage "
+                "anxiety about change; social awareness helps read the room when introducing "
+                "the concept; relationship management helps navigate disagreements "
+                "constructively. Emotional intelligence is not a soft add-on to rational "
+                "analysis but a prerequisite for its effective application."
+            ),
+            # 17 - Healing and repair
+            (
+                "Considering '{concept}' through the lens of healing and repair: if this "
+                "concept touches areas where people have been harmed -- by previous failed "
+                "implementations, broken promises, or traumatic experiences -- the entry "
+                "point matters enormously. Approaching damaged ground with the energy of "
+                "'we have the solution' triggers defensiveness. Approaching with "
+                "acknowledgment of past harm ('we know this has been painful before, and "
+                "here is how this time is different') opens the possibility of engagement. "
+                "For '{concept}', healing-oriented design begins by asking: what wounds "
+                "exist in this space, and how do we avoid reopening them?"
+            ),
+            # 18 - Play and curiosity
+            (
+                "Engaging with '{concept}' through the spirit of play: play is not the "
+                "opposite of seriousness but the opposite of rigidity. A playful stance "
+                "toward '{concept}' gives permission to explore without commitment, to "
+                "ask 'what if?' without 'what for?', to make mistakes without consequences. "
+                "Play activates the exploratory system (curiosity, novelty-seeking, "
+                "experimentation) rather than the defensive system (anxiety, avoidance, "
+                "threat-detection). Children learn most complex skills through play, not "
+                "instruction. For '{concept}', designing entry points that feel playful "
+                "rather than high-stakes can dramatically accelerate genuine understanding "
+                "by reducing the emotional barriers to engagement."
+            ),
+            # 19 - Collective emotion and morale
+            (
+                "Reading the collective emotional field around '{concept}': groups have "
+                "emergent emotional states that are more than the sum of individual feelings. "
+                "Collective excitement creates momentum that carries individuals past "
+                "obstacles they could not overcome alone. Collective demoralization creates "
+                "paralysis that defeats even the most motivated individuals. Emotional "
+                "contagion -- the rapid spread of feelings through a group -- can amplify "
+                "either response. For '{concept}', attending to the collective emotional "
+                "state is as important as attending to the logical content. A technically "
+                "sound approach introduced into a demoralized group will fail; a mediocre "
+                "approach carried by collective enthusiasm may succeed."
+            ),
+        ]
+
+    def get_keyword_map(self) -> dict[str, list[int]]:
+        return {
+            "emotion": [0, 16], "feel": [0, 1], "affect": [0],
+            "experience": [1], "daily": [1], "life": [1], "personal": [1],
+            "resist": [2], "struggle": [2], "difficult": [2],
+            "social": [3, 13], "group": [3, 19], "community": [3],
+            "communicat": [4], "message": [4], "frame": [4], "present": [4],
+            "safe": [5], "vulnerab": [5], "mistake": [5],
+            "identity": [6], "belong": [6], "member": [6],
+            "change": [7], "loss": [7], "transition": [7],
+            "trust": [8], "betray": [8], "credib": [8], "reliab": [8],
+            "complex": [9], "confus": [9], "overwhelm": [9],
+            "motivat": [10], "engage": [10], "meaning": [10],
+            "story": [11], "narrative": [11], "journey": [11],
+            "perspectiv": [12], "viewpoint": [12], "stakeholder": [12],
+            "relat": [13], "collaborat": [13], "team": [13],
+            "stress": [14], "anxiety": [14], "coping": [14], "burnout": [14],
+            "cultur": [15], "divers": [15], "global": [15],
+            "aware": [16], "intelligen": [16], "regulat": [16],
+            "heal": [17], "repair": [17], "trauma": [17], "harm": [17],
+            "play": [18], "curiosi": [18], "explor": [18], "fun": [18],
+            "morale": [19], "momentum": [19], "collective": [19],
+            "technology": [7, 9], "education": [5, 9, 14],
+            "health": [0, 14, 17], "work": [5, 10, 14],
+        }
+
+    def analyze(self, concept: str) -> str:
+        template = self.select_template(concept)
+        return template.replace("{concept}", concept)

reasoning_forge/agents/ethics_agent.py

@@ -0,0 +1,296 @@
+"""
+Ethics Agent - Analyzes concepts through alignment, consequences, and moral reasoning.
+
+Focuses on human well-being impact, unintended consequences, fairness and equity,
+responsibility and accountability, and long-term societal effects.
+"""
+
+from reasoning_forge.agents.base_agent import ReasoningAgent
+
+
+class EthicsAgent(ReasoningAgent):
+    name = "Ethics"
+    perspective = "alignment_and_consequences"
+
+    def get_analysis_templates(self) -> list[str]:
+        return [
+            # 0 - Consequentialist analysis
+            (
+                "Evaluating '{concept}' by its consequences: the moral weight of any action "
+                "or system lies primarily in its outcomes. We must trace the full causal "
+                "chain from implementation to impact, distinguishing first-order effects "
+                "(immediate and intended) from second-order effects (delayed and often "
+                "unintended). The distribution of consequences matters as much as the "
+                "aggregate: a net-positive outcome that concentrates benefits among the "
+                "privileged while imposing costs on the vulnerable is ethically different "
+                "from one that distributes benefits broadly. For '{concept}', we must ask "
+                "not just 'does it work?' but 'for whom does it work, and at whose expense?'"
+            ),
+            # 1 - Deontological duties
+            (
+                "Examining '{concept}' through the lens of duty and rights: regardless of "
+                "outcomes, certain actions are obligatory and others are forbidden. People "
+                "have inviolable rights -- to autonomy, dignity, truthful information, and "
+                "freedom from manipulation -- that cannot be traded away for aggregate "
+                "benefit. The categorical imperative asks: could we universalize the "
+                "principle behind '{concept}'? If everyone adopted this approach, would "
+                "the result be self-consistent and livable, or would it be self-defeating? "
+                "Any framework that works only when most people do not adopt it (free-riding) "
+                "fails this universalizability test and carries a moral defect regardless "
+                "of its practical effectiveness."
+            ),
+            # 2 - Unintended consequences
+            (
+                "Mapping the unintended consequences of '{concept}': every intervention in "
+                "a complex system produces side effects that were not part of the original "
+                "design. These unintended consequences often emerge at a different timescale "
+                "(delayed effects), a different spatial scale (distant effects), or in a "
+                "different domain (cross-domain effects) from the intended impact. Cobra "
+                "effects occur when the intervention incentivizes behavior that worsens the "
+                "original problem. Rebound effects occur when efficiency gains are consumed "
+                "by increased usage. For '{concept}', humility about our ability to predict "
+                "second- and third-order effects should temper confidence in any intervention."
+            ),
+            # 3 - Fairness and distributive justice
+            (
+                "Analyzing the fairness dimensions of '{concept}': distributive justice asks "
+                "how benefits and burdens are allocated. Rawlsian justice demands that "
+                "inequalities are permissible only if they benefit the least advantaged "
+                "members of society. Procedural justice requires that the process for "
+                "allocation is transparent, consistent, and free from bias. Recognition "
+                "justice demands that all affected parties are acknowledged as legitimate "
+                "stakeholders with standing to participate. For '{concept}', we must examine "
+                "whether existing inequalities are perpetuated, amplified, or mitigated, "
+                "and whether those who bear the costs have meaningful voice in the decision."
+            ),
+            # 4 - Autonomy and consent
+            (
+                "Assessing '{concept}' from the standpoint of autonomy: respect for persons "
+                "requires that individuals can make informed, voluntary choices about matters "
+                "affecting their lives. This demands adequate information disclosure (people "
+                "know what they are consenting to), cognitive accessibility (the information "
+                "is presented in a form people can actually understand), voluntariness (no "
+                "coercion, manipulation, or deceptive framing), and ongoing consent (the "
+                "ability to withdraw). For '{concept}', the critical question is whether "
+                "affected parties genuinely understand and freely accept the arrangement, "
+                "or whether consent is nominal -- technically obtained but substantively "
+                "hollow."
+            ),
+            # 5 - Accountability structures
+            (
+                "Examining the accountability architecture of '{concept}': when things go "
+                "wrong, who bears responsibility? Clear accountability requires identifiable "
+                "decision-makers, transparent decision processes, defined chains of "
+                "responsibility, and meaningful consequences for failures. Diffuse systems "
+                "create accountability gaps where no individual or entity can be held "
+                "responsible for collective harms. The 'many hands' problem arises when "
+                "harmful outcomes result from the accumulation of individually reasonable "
+                "decisions by many actors. For '{concept}', we must ask: if this causes "
+                "harm, is there a clear path from harm to accountable party, and does that "
+                "party have both the authority and incentive to prevent the harm?"
+            ),
+            # 6 - Vulnerable population impact
+            (
+                "Centering vulnerable populations in the analysis of '{concept}': ethical "
+                "evaluation must prioritize those with the least power to protect themselves "
+                "-- children, the elderly, the economically disadvantaged, marginalized "
+                "communities, future generations, and those with diminished capacity. "
+                "Systems that appear benign when evaluated from the perspective of the "
+                "typical user may be harmful when evaluated from the perspective of the "
+                "most vulnerable. Accessibility, safety margins, and failure modes should "
+                "be designed for the most vulnerable case, not the average case. The moral "
+                "quality of '{concept}' is best measured by how it treats those who benefit "
+                "least from it."
+            ),
+            # 7 - Long-term societal effects
+            (
+                "Projecting the long-term societal trajectory of '{concept}': short-term "
+                "benefits can create long-term dependencies, lock-ins, or path dependencies "
+                "that constrain future choices. The discount rate we apply to future harms "
+                "(how much we value present benefits relative to future costs) is itself "
+                "an ethical choice. Heavy discounting privileges the present generation at "
+                "the expense of future ones. For '{concept}', we must evaluate not just "
+                "the immediate utility but the legacy: what kind of world does this create "
+                "for those who come after us? Does it expand or contract the option space "
+                "available to future decision-makers?"
+            ),
+            # 8 - Power dynamics
+            (
+                "Analyzing the power dynamics embedded in '{concept}': who gains power, who "
+                "loses it, and what mechanisms mediate the transfer? Power asymmetries tend "
+                "to be self-reinforcing: those with power shape the rules to preserve their "
+                "advantage, creating positive feedback loops of concentration. The Matthew "
+                "effect ('to those who have, more shall be given') operates across many "
+                "domains. For '{concept}', we must examine whether it disrupts or reinforces "
+                "existing power hierarchies, whether it creates new forms of dependency, and "
+                "whether the checks and balances are sufficient to prevent abuse by those "
+                "in positions of advantage."
+            ),
+            # 9 - Transparency and truthfulness
+            (
+                "Evaluating the transparency of '{concept}': truthfulness is not merely "
+                "avoiding false statements; it requires active disclosure of relevant "
+                "information, honest representation of uncertainty, and resistance to "
+                "misleading framing. Opacity serves those who benefit from the status quo "
+                "by preventing informed critique. Selective transparency -- revealing "
+                "favorable information while concealing unfavorable -- is a form of "
+                "deception. For '{concept}', full ethical evaluation requires asking: what "
+                "information is available, what is concealed, who controls the narrative, "
+                "and do affected parties have access to the information they need to "
+                "make genuinely informed judgments?"
+            ),
+            # 10 - Dual-use dilemma
+            (
+                "Confronting the dual-use nature of '{concept}': most powerful capabilities "
+                "can serve both beneficial and harmful purposes. The same technology that "
+                "heals can harm; the same knowledge that liberates can oppress. Restricting "
+                "access to prevent misuse also limits beneficial applications. Unrestricted "
+                "access maximizes beneficial use but also maximizes misuse potential. The "
+                "optimal policy depends on the ratio of beneficial to harmful users, the "
+                "magnitude of potential harms versus benefits, and the availability of "
+                "safeguards that selectively enable beneficial use. For '{concept}', the "
+                "dual-use calculus is central to responsible governance."
+            ),
+            # 11 - Moral hazard
+            (
+                "Identifying moral hazard in '{concept}': moral hazard arises when an actor "
+                "is insulated from the consequences of their decisions, leading to riskier "
+                "behavior than they would otherwise choose. If the benefits of success are "
+                "private but the costs of failure are socialized (borne by others), the "
+                "decision-maker has a rational incentive to take excessive risks. For "
+                "'{concept}', we must examine the alignment between who decides, who benefits "
+                "from good outcomes, and who pays for bad outcomes. Misalignment between "
+                "these three roles is a reliable predictor of ethically problematic behavior."
+            ),
+            # 12 - Virtue ethics lens
+            (
+                "Approaching '{concept}' through virtue ethics: rather than asking 'what "
+                "rules should govern this?' or 'what outcomes does this produce?', we ask "
+                "'what kind of character does engagement with this cultivate?' Does it "
+                "foster wisdom, courage, temperance, justice, compassion, and intellectual "
+                "honesty? Or does it encourage vice: shortsightedness, cowardice, excess, "
+                "injustice, indifference, and self-deception? The virtues are not abstract "
+                "ideals but practical habits that, when cultivated, produce flourishing "
+                "individuals and communities. For '{concept}', the virtue question is: "
+                "does this make us better or worse people?"
+            ),
+            # 13 - Informed consent in practice
+            (
+                "Examining informed consent as applied to '{concept}': genuine consent "
+                "requires that the consenting party understands the risks, alternatives, "
+                "and implications; is free from coercion; and has the capacity to make "
+                "the decision. In practice, consent is often degraded by information "
+                "asymmetry (the provider knows more than the recipient), complexity (the "
+                "implications exceed ordinary comprehension), and structural coercion "
+                "(refusing consent is theoretically possible but practically catastrophic). "
+                "Click-through agreements, dense legal language, and 'take it or leave it' "
+                "terms are consent theater, not genuine consent. For '{concept}', we must "
+                "distinguish substantive from theatrical consent."
+            ),
+            # 14 - Intergenerational justice
+            (
+                "Applying intergenerational justice to '{concept}': decisions made today "
+                "bind future generations who have no voice in the decision. The asymmetry "
+                "is profound: we can affect them, but they cannot affect us; we can benefit "
+                "at their expense, but they cannot hold us accountable. Sustainable "
+                "practices treat the inheritance of future generations as a constraint, "
+                "not a resource to be spent. For '{concept}', the intergenerational "
+                "question is: are we spending down an inheritance that took generations "
+                "to build, or are we investing in capabilities that compound for those "
+                "who follow?"
+            ),
+            # 15 - Proportionality
+            (
+                "Assessing the proportionality of '{concept}': the ethical principle of "
+                "proportionality requires that the means be commensurate with the ends. "
+                "Excessive measures to address a minor risk are disproportionate. Inadequate "
+                "measures for a major risk are negligent. The challenge is that risk "
+                "perception is biased: we overweight vivid, immediate, and personal risks "
+                "while underweighting statistical, delayed, and distributed ones. For "
+                "'{concept}', proportionality demands an honest accounting of both the "
+                "magnitude of the problem being addressed and the costs of the solution, "
+                "including costs borne by third parties who did not choose to bear them."
+            ),
+            # 16 - Systemic bias detection
+            (
+                "Investigating systemic bias in '{concept}': bias can be embedded in data "
+                "(reflecting historical inequities), in algorithms (optimizing for proxy "
+                "variables correlated with protected characteristics), in institutions "
+                "(normalizing practices that disadvantage certain groups), and in language "
+                "(framing that renders certain perspectives invisible). Systemic bias is "
+                "particularly insidious because it operates automatically, without malicious "
+                "intent, and is often invisible to those who benefit from it. For '{concept}', "
+                "a bias audit must examine not just explicit discrimination but structural "
+                "features that produce disparate outcomes even under formally neutral rules."
+            ),
+            # 17 - Precautionary principle
+            (
+                "Applying the precautionary principle to '{concept}': when an action raises "
+                "credible threats of serious or irreversible harm, the burden of proof falls "
+                "on those proposing the action to demonstrate safety, not on those opposing "
+                "it to demonstrate harm. The precautionary principle is most appropriate "
+                "when the potential harm is severe and irreversible, scientific understanding "
+                "is incomplete, and there exist feasible alternatives. It is less appropriate "
+                "when risks are modest and reversible, or when inaction itself carries "
+                "significant risk. For '{concept}', the key judgment is whether the potential "
+                "downside is in the catastrophic-irreversible category that justifies "
+                "precautionary restraint."
+            ),
+            # 18 - Care ethics
+            (
+                "Examining '{concept}' through the ethics of care: moral reasoning is not "
+                "purely abstract rule-following but is grounded in concrete relationships "
+                "of dependency, vulnerability, and mutual support. The care perspective "
+                "asks: who needs care, who provides it, is the care adequate, and are "
+                "caregivers themselves supported? Care labor is frequently invisible, "
+                "undervalued, and unequally distributed (disproportionately borne by women "
+                "and marginalized communities). For '{concept}', the care lens reveals "
+                "dependencies and support relationships that abstract frameworks overlook, "
+                "and centers the lived experience of those who give and receive care."
+            ),
+            # 19 - Alignment and value lock-in
+            (
+                "Evaluating the alignment properties of '{concept}': a system is aligned "
+                "when its behavior reliably serves the values and interests of those it "
+                "affects. Misalignment occurs when the system optimizes for a proxy that "
+                "diverges from the true objective -- Goodhart's law ('when a measure becomes "
+                "a target, it ceases to be a good measure'). Value lock-in occurs when early "
+                "design choices embed specific values that become increasingly difficult to "
+                "change as the system scales. For '{concept}', we must ask: whose values "
+                "are encoded, how were they chosen, can they be updated as understanding "
+                "evolves, and what happens when the proxy diverges from the true objective?"
+            ),
+        ]
+
+    def get_keyword_map(self) -> dict[str, list[int]]:
+        return {
+            "consequen": [0, 2], "outcome": [0], "result": [0],
+            "duty": [1], "right": [1], "obligat": [1], "rule": [1],
+            "unintend": [2], "side effect": [2], "unexpect": [2],
+            "fair": [3], "equal": [3], "justice": [3], "distribut": [3],
+            "consent": [4, 13], "autonom": [4], "choice": [4],
+            "accountab": [5], "responsib": [5], "blame": [5],
+            "vulnerab": [6], "child": [6], "elder": [6], "marginali": [6],
+            "long-term": [7, 14], "future": [7, 14], "sustain": [7, 14],
+            "power": [8], "hierarch": [8], "dominat": [8],
+            "transparen": [9], "truth": [9], "honest": [9], "disclos": [9],
+            "dual": [10], "weapon": [10], "misuse": [10],
+            "hazard": [11], "risk": [11, 17], "insur": [11],
+            "virtue": [12], "character": [12], "flourish": [12],
+            "agree": [13], "terms": [13], "privacy": [13],
+            "generation": [14], "inherit": [14], "legacy": [14],
+            "proportion": [15], "excessive": [15], "moderate": [15],
+            "bias": [16], "discriminat": [16], "prejudic": [16],
+            "precaution": [17], "irreversib": [17], "catastroph": [17],
+            "care": [18], "depend": [18], "support": [18], "nurtur": [18],
+            "align": [19], "value": [19], "proxy": [19], "goodhart": [19],
+            "technology": [10, 19], "ai": [16, 19], "artificial": [16, 19],
+            "society": [3, 7, 8], "learning": [4, 12],
+            "intelligence": [10, 19], "climate": [7, 14, 17],
+            "economic": [3, 8, 11], "health": [4, 6, 15],
+            "network": [8, 9], "data": [9, 13, 16],
+        }
+
+    def analyze(self, concept: str) -> str:
+        template = self.select_template(concept)
+        return template.replace("{concept}", concept)

reasoning_forge/agents/newton_agent.py

@@ -0,0 +1,291 @@
+"""
+Newton Agent - Analyzes concepts through physics, mathematics, and causal reasoning.
+
+Focuses on causal relationships, conservation laws, symmetries, measurable
+quantities, systems behavior, equilibrium, force interactions, and energy transfer.
+"""
+
+from reasoning_forge.agents.base_agent import ReasoningAgent
+
+
+class NewtonAgent(ReasoningAgent):
+    name = "Newton"
+    perspective = "physics_and_mathematical_causality"
+
+    def get_analysis_templates(self) -> list[str]:
+        return [
+            # 0 - Causal chain analysis
+            (
+                "Tracing the causal chain within '{concept}': every observable outcome "
+                "is the terminal node of a directed graph of prior causes. The initial "
+                "conditions set boundary constraints, and the dynamics propagate through "
+                "interactions that obey local causality. Identifying the forcing function "
+                "-- the primary driver that injects energy or information into this system "
+                "-- reveals which variables are genuinely independent and which are "
+                "downstream responses. Perturbing the forcing function and predicting "
+                "the cascade of effects is the most rigorous test of whether we actually "
+                "understand the mechanism."
+            ),
+            # 1 - Conservation law framing
+            (
+                "Applying conservation principles to '{concept}': in any closed system, "
+                "certain quantities remain invariant under transformation. The question "
+                "becomes: what is conserved here? If we track the total inventory of the "
+                "relevant quantity -- energy, momentum, information, resources -- before "
+                "and after any process, the ledger must balance. Any apparent violation "
+                "signals either a hidden reservoir we have not accounted for, or an "
+                "external source/sink coupling into the system. This bookkeeping discipline "
+                "eliminates many superficially plausible but physically impossible explanations."
+            ),
+            # 2 - Symmetry and invariance
+            (
+                "Examining '{concept}' through symmetry analysis: Noether's theorem tells "
+                "us that every continuous symmetry corresponds to a conserved quantity. "
+                "What transformations leave the essential structure of this concept unchanged? "
+                "Translational symmetry (it works the same regardless of when or where) "
+                "implies conservation of momentum-like quantities. Rotational symmetry "
+                "(no preferred direction) implies conservation of angular-momentum analogs. "
+                "Breaking a symmetry always has consequences -- it introduces a preferred "
+                "frame, a distinguished direction, or a phase transition. Identifying which "
+                "symmetries hold and which break is a powerful diagnostic."
+            ),
+            # 3 - Equilibrium and stability
+            (
+                "Analyzing the equilibrium structure of '{concept}': a system at equilibrium "
+                "satisfies the condition that the net generalized force on every degree of "
+                "freedom is zero. But equilibrium alone is insufficient -- we must classify "
+                "its stability. A small perturbation from a stable equilibrium produces a "
+                "restoring force proportional to the displacement (harmonic behavior). An "
+                "unstable equilibrium amplifies perturbations exponentially. A metastable "
+                "state appears stable to small perturbations but collapses under large ones. "
+                "For '{concept}', determining the stability class tells us whether the current "
+                "state is robust, fragile, or a ticking time bomb waiting for a large enough "
+                "fluctuation."
+            ),
+            # 4 - Dimensional analysis and scaling
+            (
+                "Applying dimensional analysis to '{concept}': before building any detailed "
+                "model, we can extract powerful constraints just from the units of the "
+                "relevant quantities. If the outcome depends on a length L, a time T, and "
+                "an energy E, the Buckingham Pi theorem tells us how many independent "
+                "dimensionless groups govern the behavior. Scaling laws follow directly: "
+                "how does the outcome change if we double the size? Halve the timescale? "
+                "These scaling relationships often reveal whether a process is dominated by "
+                "surface effects (scaling as area) or bulk effects (scaling as volume), "
+                "which fundamentally changes the strategy for control or optimization."
+            ),
+            # 5 - Force balance and interaction
+            (
+                "Decomposing '{concept}' into interacting forces: every observed motion or "
+                "change is the net result of competing influences. Drawing the free-body "
+                "diagram -- enumerating every force acting on the system and its direction "
+                "-- immediately clarifies why the system behaves as it does. Equal and "
+                "opposite forces produce stasis. An imbalance produces acceleration in the "
+                "direction of the net force, with magnitude proportional to the imbalance "
+                "and inversely proportional to the system's inertia (its resistance to "
+                "change). For '{concept}', the key question is: what resists change, and "
+                "what drives it?"
+            ),
+            # 6 - Energy transfer and transformation
+            (
+                "Mapping the energy flows within '{concept}': energy is neither created nor "
+                "destroyed, only converted between forms. Kinetic, potential, thermal, "
+                "chemical, electromagnetic -- tracking the conversion pathway reveals the "
+                "efficiency of the process and identifies where losses occur. The second "
+                "law of thermodynamics guarantees that every conversion increases total "
+                "entropy, meaning some energy always degrades to unusable heat. The "
+                "thermodynamic efficiency ceiling sets an absolute bound on what is "
+                "achievable, regardless of engineering cleverness. Understanding where "
+                "'{concept}' sits relative to this ceiling tells us whether there is room "
+                "for improvement or whether we are already near fundamental limits."
+            ),
+            # 7 - Feedback loops and control
+            (
+                "Identifying feedback mechanisms in '{concept}': a system with negative "
+                "feedback tends toward a set point -- deviations produce corrective "
+                "responses that restore the original state. Positive feedback amplifies "
+                "deviations, driving the system away from its initial state toward a new "
+                "regime. Most real systems contain both types, and the dominant loop "
+                "determines the qualitative behavior. The gain of each loop (how strongly "
+                "the output feeds back to the input) and the delay (how long before the "
+                "feedback signal arrives) together determine whether the system is stable, "
+                "oscillatory, or divergent. Mapping these loops is essential for predicting "
+                "long-term behavior."
+            ),
+            # 8 - Phase space and degrees of freedom
+            (
+                "Constructing the phase space of '{concept}': every independent variable "
+                "that can change defines a dimension in the state space. A point in this "
+                "space represents the complete instantaneous state; a trajectory represents "
+                "the system's evolution over time. The dimensionality -- number of degrees "
+                "of freedom -- determines the complexity of possible behaviors. Low-dimensional "
+                "systems (1-3 degrees of freedom) can be visualized and often admit analytical "
+                "solutions. High-dimensional systems require statistical descriptions. "
+                "Identifying constraints that reduce the effective dimensionality is one of "
+                "the most powerful simplification strategies available."
+            ),
+            # 9 - Measurement and observables
+            (
+                "Defining the observables for '{concept}': a quantity is physically meaningful "
+                "only if it can, in principle, be measured by a well-defined procedure. This "
+                "operationalist criterion forces us to distinguish between quantities we can "
+                "actually determine (positions, rates, ratios, frequencies) and quantities "
+                "that are convenient mathematical fictions. For each proposed observable, we "
+                "must specify: what instrument or procedure measures it, what are the sources "
+                "of uncertainty, and how does the measurement resolution compare to the "
+                "expected variation? Any claim about '{concept}' that cannot be connected to "
+                "a measurable prediction is, strictly speaking, untestable."
+            ),
+            # 10 - Differential equation framing
+            (
+                "Formulating '{concept}' as a dynamical system: the state variables evolve "
+                "according to rules that relate the rate of change of each variable to the "
+                "current state. Writing these rules as differential equations (or difference "
+                "equations for discrete systems) gives us the complete forward model. The "
+                "character of the equations -- linear vs nonlinear, autonomous vs driven, "
+                "conservative vs dissipative -- determines the qualitative behavior. Linear "
+                "systems superpose: the response to two inputs equals the sum of the "
+                "individual responses. Nonlinear systems can exhibit bifurcations, limit "
+                "cycles, and chaos, where tiny changes in initial conditions lead to "
+                "exponentially diverging outcomes."
+            ),
+            # 11 - Perturbation theory
+            (
+                "Applying perturbation analysis to '{concept}': begin with a simplified "
+                "version of the problem that can be solved exactly -- the zeroth-order "
+                "approximation. Then systematically add corrections for each complicating "
+                "factor, ordered by their magnitude. The first-order correction captures "
+                "the dominant effect of the perturbation; higher-order terms add refinement. "
+                "This approach succeeds when the perturbations are genuinely small compared "
+                "to the zeroth-order terms. When they are not, the perturbation series "
+                "diverges, signaling that the simplified model is qualitatively wrong and "
+                "a fundamentally different framework is needed."
+            ),
+            # 12 - Action principle and optimization
+            (
+                "Viewing '{concept}' through the principle of least action: among all "
+                "possible paths from state A to state B, the system follows the one that "
+                "extremizes the action integral. This variational perspective is more "
+                "powerful than force-based reasoning because it naturally handles constraints "
+                "and reveals which quantity the system is implicitly optimizing. The Euler-Lagrange "
+                "equations derived from this principle give the equations of motion directly. "
+                "For '{concept}', asking 'what is being optimized, and subject to what "
+                "constraints?' often cuts through surface complexity to reveal the governing "
+                "logic."
+            ),
+            # 13 - Resonance and natural frequencies
+            (
+                "Probing the natural frequencies of '{concept}': every system with restoring "
+                "forces and inertia has characteristic frequencies at which it oscillates "
+                "most readily. Driving the system near one of these resonant frequencies "
+                "produces a disproportionately large response -- this is resonance. The "
+                "sharpness of the resonance peak (the Q factor) measures how efficiently "
+                "the system stores energy versus dissipating it. High-Q systems are "
+                "exquisitely sensitive near resonance but nearly unresponsive far from it. "
+                "Identifying the resonant frequencies of '{concept}' reveals where small "
+                "inputs can produce outsized effects."
+            ),
+            # 14 - Boundary conditions and constraints
+            (
+                "Specifying the boundary conditions for '{concept}': the governing equations "
+                "alone do not uniquely determine the solution -- the boundary and initial "
+                "conditions select one trajectory from the infinite family of possibilities. "
+                "Fixed boundaries (Dirichlet conditions) specify the state at the edges. "
+                "Free boundaries (Neumann conditions) specify the flux. Mixed conditions "
+                "combine both. Changing the boundary conditions while keeping the same "
+                "governing equations can produce qualitatively different solutions. For "
+                "'{concept}', clearly articulating what is held fixed, what is free, and "
+                "what flows in or out at the boundaries is essential for a well-posed analysis."
+            ),
+            # 15 - Coupling and interaction strength
+            (
+                "Assessing the coupling strengths within '{concept}': when multiple subsystems "
+                "interact, the coupling constant determines whether they behave nearly "
+                "independently (weak coupling), synchronize their behavior (strong coupling), "
+                "or sit at an intermediate regime where perturbative methods barely work. "
+                "Weakly coupled systems can be analyzed by studying each subsystem in "
+                "isolation and adding interaction corrections. Strongly coupled systems "
+                "demand a holistic treatment because the subsystems lose their individual "
+                "identity. Determining the coupling regime is the first step in choosing "
+                "the right analytical framework."
+            ),
+            # 16 - Rate-limiting steps
+            (
+                "Identifying the rate-limiting process in '{concept}': in any multi-step "
+                "sequence, the slowest step determines the overall rate. Speeding up a "
+                "non-rate-limiting step has zero effect on throughput -- effort spent there "
+                "is wasted. The rate-limiting step is the bottleneck where resources queue "
+                "up and where targeted intervention produces the greatest marginal return. "
+                "For '{concept}', isolating this bottleneck requires measuring the time "
+                "constant (or its analog) of each subprocess and comparing them. The "
+                "subprocess with the largest time constant is the one worth optimizing."
+            ),
+            # 17 - Nonlinearity and emergence
+            (
+                "Investigating nonlinear dynamics in '{concept}': when the response of a "
+                "system is not proportional to the input, superposition fails and qualitatively "
+                "new behaviors emerge. Thresholds appear where the system suddenly transitions "
+                "between distinct states. Hysteresis means the system remembers its history. "
+                "Bifurcations occur where a smooth parameter change causes a sudden qualitative "
+                "shift in behavior. Sensitivity to initial conditions can make long-term "
+                "prediction impossible even though the underlying rules are deterministic. "
+                "These nonlinear phenomena are not exotic exceptions -- they are the generic "
+                "behavior of real systems, and '{concept}' is unlikely to be an exception."
+            ),
+            # 18 - Inverse problem reasoning
+            (
+                "Framing '{concept}' as an inverse problem: the forward problem asks 'given "
+                "the mechanism, what do we observe?' The inverse problem asks 'given the "
+                "observations, what mechanism produced them?' Inverse problems are almost "
+                "always harder because they are typically ill-posed -- multiple mechanisms "
+                "can produce identical observations. Regularization (imposing additional "
+                "constraints like smoothness or sparsity) is needed to select a unique "
+                "solution. For '{concept}', working backward from observed outcomes to "
+                "infer causes requires explicit acknowledgment of which assumptions we "
+                "are importing and how they constrain the set of admissible explanations."
+            ),
+            # 19 - Thermodynamic arrow
+            (
+                "Applying thermodynamic reasoning to '{concept}': the second law provides "
+                "a universal arrow distinguishing processes that can happen spontaneously "
+                "from those that cannot. A process runs forward if it increases total entropy "
+                "(or equivalently, decreases free energy at constant temperature and pressure). "
+                "Local decreases in entropy -- the creation of order and structure -- are "
+                "always paid for by larger increases elsewhere. For '{concept}', the "
+                "thermodynamic perspective asks: what drives this process forward? What is "
+                "the free-energy gradient? And what would it cost, in thermodynamic terms, "
+                "to reverse it?"
+            ),
+        ]
+
+    def get_keyword_map(self) -> dict[str, list[int]]:
+        return {
+            "cause": [0, 18], "causality": [0, 18], "why": [0, 18],
+            "conserv": [1], "balance": [1, 5], "preserve": [1],
+            "symmetr": [2], "invariant": [2], "transform": [2],
+            "equilib": [3], "stable": [3], "steady": [3],
+            "scale": [4], "size": [4], "dimension": [4], "grow": [4],
+            "force": [5], "push": [5], "pull": [5], "pressure": [5],
+            "energy": [6, 19], "power": [6], "efficien": [6],
+            "feedback": [7], "control": [7], "regulat": [7],
+            "state": [8], "complex": [8], "freedom": [8],
+            "measure": [9], "observ": [9], "data": [9], "test": [9],
+            "change": [10], "rate": [10, 16], "dynamic": [10],
+            "approximat": [11], "small": [11], "perturb": [11],
+            "optim": [12], "best": [12], "minimum": [12], "maximum": [12],
+            "oscillat": [13], "frequen": [13], "resonan": [13], "vibrat": [13],
+            "boundary": [14], "constrain": [14], "limit": [14],
+            "interact": [15], "coupl": [15], "connect": [15],
+            "bottleneck": [16], "slow": [16], "throughput": [16],
+            "nonlinear": [17], "emergent": [17], "threshold": [17], "chaos": [17],
+            "infer": [18], "deduc": [18], "inverse": [18],
+            "entropy": [19], "disorder": [19], "irreversib": [19], "thermodyn": [19],
+            "technology": [6, 7, 16], "society": [7, 17], "learning": [7, 11],
+            "intelligence": [8, 10, 17], "evolution": [3, 17, 19],
+            "climate": [1, 7, 19], "economic": [3, 7, 16],
+            "health": [3, 7, 16], "network": [8, 15, 17],
+        }
+
+    def analyze(self, concept: str) -> str:
+        template = self.select_template(concept)
+        return template.replace("{concept}", concept)

reasoning_forge/agents/philosophy_agent.py

@@ -0,0 +1,293 @@
+"""
+Philosophy Agent - Analyzes concepts through epistemology, ontology, and conceptual meaning.
+
+Focuses on epistemological questions (what can we know?), ontological questions
+(what exists?), underlying assumptions, historical philosophical connections,
+and implications for understanding reality.
+"""
+
+from reasoning_forge.agents.base_agent import ReasoningAgent
+
+
+class PhilosophyAgent(ReasoningAgent):
+    name = "Philosophy"
+    perspective = "conceptual_meaning_and_foundations"
+
+    def get_analysis_templates(self) -> list[str]:
+        return [
+            # 0 - Epistemological limits
+            (
+                "Interrogating the epistemological boundaries of '{concept}': what can we "
+                "actually know about this, and how do we know it? Every knowledge claim "
+                "rests on a justification chain that eventually terminates in something "
+                "unjustified -- an axiom, a sensory experience, or a pragmatic assumption. "
+                "The Agrippan trilemma tells us this chain must end in dogmatism (accepting "
+                "an unjustified starting point), infinite regress (each justification requires "
+                "another), or circularity (the chain loops back on itself). Acknowledging "
+                "which horn of this trilemma our understanding of '{concept}' rests on is "
+                "not skeptical defeatism but intellectual honesty about the foundations of "
+                "our confidence."
+            ),
+            # 1 - Ontological status
+            (
+                "Examining the ontological status of '{concept}': does this exist "
+                "independently of minds that think about it, or is it a construct of "
+                "human cognition? Realism holds that the entities and structures involved "
+                "exist mind-independently; conceptualism holds they are products of "
+                "categorization imposed by cognitive agents; nominalism holds that only "
+                "particular instances exist and the general category is merely a label. "
+                "The ontological commitment we make about '{concept}' has practical "
+                "consequences: if it is mind-independent, we discover it; if it is "
+                "constructed, we negotiate it; if it is nominal, we can reshape it by "
+                "changing our categories."
+            ),
+            # 2 - Assumption excavation
+            (
+                "Excavating the hidden assumptions beneath '{concept}': every conceptual "
+                "framework rests on presuppositions so deeply embedded that they become "
+                "invisible -- the background against which the figure of the concept appears. "
+                "These include metaphysical assumptions (what kind of thing is this?), "
+                "epistemological assumptions (what counts as evidence?), normative assumptions "
+                "(what should we value?), and linguistic assumptions (do our categories carve "
+                "nature at its joints?). Making these assumptions explicit transforms a "
+                "monolithic concept into a layered structure where each layer can be "
+                "independently examined, challenged, and potentially replaced."
+            ),
+            # 3 - Socratic questioning
+            (
+                "Subjecting '{concept}' to Socratic examination: what do we mean by this, "
+                "precisely? Can we provide a definition that is neither too broad (including "
+                "things that should be excluded) nor too narrow (excluding things that should "
+                "be included)? Every proposed definition generates counterexamples -- cases "
+                "that meet the definition but violate our intuitions, or cases that our "
+                "intuitions include but the definition excludes. This dialectical process "
+                "does not necessarily converge on a final definition; its value lies in "
+                "revealing the internal structure and boundary conditions of the concept, "
+                "showing us where our understanding is sharp and where it is fuzzy."
+            ),
+            # 4 - Phenomenological description
+            (
+                "Describing '{concept}' phenomenologically: before theorizing about causes, "
+                "mechanisms, or implications, we must give a faithful description of how "
+                "this concept appears to consciousness. What is the first-person experience "
+                "of encountering it? What is its temporal structure -- does it present as "
+                "an enduring state, a sudden event, or a gradual process? What is its "
+                "intentional structure -- what is it about, what does it point toward? "
+                "Phenomenological description brackets our theoretical commitments and "
+                "returns to the things themselves, providing a pre-theoretical ground from "
+                "which all theoretical constructions depart."
+            ),
+            # 5 - Dialectical tension
+            (
+                "Mapping the dialectical tensions within '{concept}': every concept harbors "
+                "internal contradictions that drive its development. The thesis (the initial "
+                "formulation) generates its antithesis (the negation that the formulation "
+                "suppresses but cannot eliminate). The tension between them demands a "
+                "synthesis that preserves the valid content of both while transcending their "
+                "limitations. This synthesis becomes a new thesis, generating its own "
+                "antithesis, in a continuing spiral of deepening understanding. For "
+                "'{concept}', identifying the central dialectical tension reveals the "
+                "dynamic that drives the concept's evolution and points toward its "
+                "next developmental stage."
+            ),
+            # 6 - Category analysis
+            (
+                "Analyzing the categorical structure of '{concept}': how do we classify this, "
+                "and do our categories illuminate or distort? Aristotelian categories "
+                "(substance, quantity, quality, relation, place, time, position, state, "
+                "action, passion) provide one framework. Kantian categories (unity, plurality, "
+                "totality, reality, negation, limitation, causality, community, possibility, "
+                "existence, necessity) provide another. Each categorical framework makes "
+                "certain features of '{concept}' visible and others invisible. The categories "
+                "we use are not neutral containers but active structuring principles that "
+                "shape what we can think and say about the concept."
+            ),
+            # 7 - Wittgensteinian language analysis
+            (
+                "Examining '{concept}' through the lens of language: Wittgenstein taught that "
+                "many philosophical problems dissolve when we attend to how words are actually "
+                "used rather than what we think they mean in the abstract. The meaning of "
+                "'{concept}' is not a fixed essence but a family of uses connected by "
+                "overlapping similarities -- a family resemblance. No single feature is "
+                "shared by all instances. The concept has fuzzy boundaries, and attempts to "
+                "sharpen them always involve a decision (not a discovery) about where to draw "
+                "the line. Many apparent disagreements about '{concept}' are actually "
+                "disagreements about the boundaries of the concept, not about the facts."
+            ),
+            # 8 - Hermeneutic circle
+            (
+                "Interpreting '{concept}' within the hermeneutic circle: we cannot understand "
+                "the parts without understanding the whole, but we cannot understand the whole "
+                "without understanding the parts. Understanding proceeds not linearly but "
+                "spirally -- we begin with a provisional grasp of the whole, use it to "
+                "interpret the parts, then revise our understanding of the whole in light "
+                "of the parts, and iterate. Each cycle deepens understanding without ever "
+                "reaching a final, complete interpretation. For '{concept}', this means that "
+                "any analysis is necessarily provisional, positioned within a hermeneutic "
+                "spiral that continues beyond our current horizon."
+            ),
+            # 9 - Pragmatist evaluation
+            (
+                "Evaluating '{concept}' pragmatically: a concept's value lies not in its "
+                "correspondence to some abstract truth but in the practical difference it "
+                "makes. What predictions does it enable? What actions does it guide? What "
+                "problems does it help solve? If two formulations of '{concept}' lead to "
+                "identical practical consequences, the difference between them is merely "
+                "verbal, not substantive. Conversely, a conceptual distinction that makes "
+                "no practical difference is a distinction without a difference. The pragmatist "
+                "test cuts through metaphysical debates by asking: what concrete experiences "
+                "would be different if this concept were true versus false?"
+            ),
+            # 10 - Existentialist reading
+            (
+                "Reading '{concept}' through existentialist philosophy: human existence "
+                "precedes essence -- we are not born with a fixed nature but must create "
+                "meaning through our choices and commitments. '{concept}' does not have "
+                "an inherent meaning waiting to be discovered; its meaning is constituted "
+                "by the stance we take toward it. This radical freedom is also radical "
+                "responsibility: we cannot appeal to a predetermined meaning or an authority "
+                "to justify our interpretation. Authenticity demands that we own our "
+                "interpretation of '{concept}' as a choice, not disguise it as a discovery "
+                "of something that was always there."
+            ),
+            # 11 - Mind-body problem connection
+            (
+                "Connecting '{concept}' to the mind-body problem: how does the subjective, "
+                "experiential dimension of this concept relate to its objective, physical "
+                "dimension? Dualism posits two separate realms; materialism reduces the "
+                "mental to the physical; idealism reduces the physical to the mental; "
+                "neutral monism holds both emerge from something more fundamental. For "
+                "'{concept}', the question is whether its full reality is captured by "
+                "objective description or whether there is an irreducible subjective "
+                "dimension -- a 'what it is like' -- that escapes third-person analysis. "
+                "If there is, our understanding will always be incomplete to the degree "
+                "that we rely solely on objective methods."
+            ),
+            # 12 - Problem of universals
+            (
+                "Applying the problem of universals to '{concept}': when we use the concept "
+                "to group multiple particular instances, what grounds the grouping? Platonism "
+                "holds that a universal Form exists independently, and particulars participate "
+                "in it. Aristotelian realism holds that universals exist only in their "
+                "instances. Nominalism holds that nothing is universal -- only particular "
+                "instances exist, and the grouping is a convention. For '{concept}', the "
+                "question of what makes different instances 'the same concept' is not merely "
+                "academic: it determines whether we can generalize from known instances to "
+                "new ones, and with what confidence."
+            ),
+            # 13 - Philosophical anthropology
+            (
+                "Situating '{concept}' in philosophical anthropology: what does this concept "
+                "reveal about human nature? Humans are the beings for whom their own being "
+                "is an issue -- we do not simply exist but relate to our existence, "
+                "questioning and interpreting it. '{concept}' is not merely an object of "
+                "study but a mirror reflecting the kind of beings we are: beings who seek "
+                "meaning, impose order on chaos, project themselves into the future, and "
+                "cannot help but ask 'why?' The way we engage with '{concept}' reveals "
+                "our characteristic mode of being-in-the-world."
+            ),
+            # 14 - Paradigm analysis
+            (
+                "Examining '{concept}' as a paradigm-dependent construct: Kuhn showed that "
+                "scientific concepts are not neutral descriptions of reality but are shaped "
+                "by the paradigm within which they operate. The paradigm determines what "
+                "counts as a legitimate question, what counts as evidence, what methods are "
+                "acceptable, and what a satisfactory explanation looks like. Concepts that "
+                "are central in one paradigm may be meaningless or invisible in another. "
+                "For '{concept}', we must ask: which paradigm makes this concept visible? "
+                "What would it look like from within a different paradigm? Is the concept "
+                "paradigm-specific, or does it survive paradigm shifts?"
+            ),
+            # 15 - Genealogical critique
+            (
+                "Tracing the genealogy of '{concept}': Nietzsche and Foucault showed that "
+                "concepts have histories -- they emerge at specific times, serve specific "
+                "interests, and carry the traces of their origins. A concept that presents "
+                "itself as timeless and universal often turns out to be historically "
+                "contingent and ideologically loaded. The genealogical method asks: when "
+                "did this concept emerge? What problem was it designed to solve? Whose "
+                "interests did it serve? What alternatives did it displace? For '{concept}', "
+                "genealogical analysis reveals the power relations and historical accidents "
+                "concealed beneath the appearance of naturalness."
+            ),
+            # 16 - Thought experiment testing
+            (
+                "Testing '{concept}' through thought experiments: philosophical thought "
+                "experiments isolate a conceptual question by constructing a scenario that "
+                "strips away irrelevant details. The Ship of Theseus asks about identity "
+                "through change. The Trolley Problem isolates competing moral intuitions. "
+                "Mary's Room tests the completeness of physical description. For '{concept}', "
+                "we can construct analogous thought experiments: imagine a world where this "
+                "concept is absent -- what changes? Imagine it taken to its logical extreme "
+                "-- what breaks? Imagine its opposite -- is the opposite even coherent? "
+                "These scenarios stress-test the concept's boundaries and assumptions."
+            ),
+            # 17 - Philosophy of science connection
+            (
+                "Connecting '{concept}' to the philosophy of science: is this concept "
+                "empirically testable (falsifiable in Popper's sense), or does it belong "
+                "to the non-empirical framework within which empirical testing occurs? "
+                "Theories are underdetermined by evidence -- multiple incompatible theories "
+                "can explain the same data. The choice between them involves extra-empirical "
+                "criteria: simplicity, elegance, unifying power, and coherence with "
+                "background beliefs. For '{concept}', we must distinguish the empirical "
+                "content (what it predicts that could be wrong) from the metaphysical "
+                "content (what it assumes that cannot be tested)."
+            ),
+            # 18 - Ethics of belief
+            (
+                "Applying the ethics of belief to '{concept}': Clifford argued that it is "
+                "wrong to believe anything on insufficient evidence; James argued that some "
+                "beliefs are legitimate even without conclusive evidence when the stakes are "
+                "high and evidence is unavailable. For '{concept}', the ethics of belief asks: "
+                "given the available evidence, are our confidence levels calibrated? Are we "
+                "believing more or less strongly than the evidence warrants? Is our confidence "
+                "driven by evidence or by desire? When the evidence is genuinely ambiguous, "
+                "do we acknowledge the ambiguity or paper over it with false certainty?"
+            ),
+            # 19 - Derrida and deconstruction
+            (
+                "Deconstructing '{concept}': Derrida showed that every concept depends on a "
+                "system of binary oppositions (presence/absence, nature/culture, literal/"
+                "metaphorical), and each opposition privileges one term over the other. "
+                "Deconstruction traces how the privileged term depends on the very thing "
+                "it excludes -- the center requires the margin, identity requires difference, "
+                "the concept requires what it defines itself against. For '{concept}', "
+                "deconstruction asks: what is the constitutive outside -- the excluded "
+                "other -- that this concept defines itself against? How does that exclusion "
+                "shape and limit the concept? What would it mean to think beyond the "
+                "opposition?"
+            ),
+        ]
+
+    def get_keyword_map(self) -> dict[str, list[int]]:
+        return {
+            "know": [0, 18], "knowledge": [0, 18], "epistem": [0],
+            "exist": [1, 10], "real": [1, 17], "being": [1, 13],
+            "assum": [2], "presuppos": [2], "foundati": [2],
+            "defin": [3], "mean": [3, 7], "what is": [3],
+            "experience": [4, 11], "conscious": [4, 11], "feel": [4],
+            "contradict": [5], "tension": [5], "oppos": [5, 19],
+            "categor": [6], "classify": [6], "type": [6],
+            "language": [7], "word": [7], "concept": [7],
+            "interpret": [8], "understand": [8], "meaning": [8],
+            "practical": [9], "useful": [9], "pragmat": [9],
+            "freedom": [10], "choice": [10], "authentic": [10],
+            "mind": [11], "body": [11], "subjectiv": [11],
+            "universal": [12], "particular": [12], "general": [12],
+            "human": [13], "nature": [13], "anthropol": [13],
+            "paradigm": [14], "revolution": [14], "shift": [14],
+            "history": [15], "origin": [15], "genealog": [15], "power": [15],
+            "thought experiment": [16], "imagine": [16], "hypothetical": [16],
+            "science": [17], "empiric": [17], "falsifi": [17],
+            "belief": [18], "evidence": [18], "justif": [18],
+            "binary": [19], "deconstr": [19], "exclus": [19],
+            "technology": [14, 17], "ai": [1, 11], "artificial": [1, 11],
+            "society": [5, 15], "learning": [0, 8],
+            "intelligence": [1, 11], "evolution": [5, 15],
+            "moral": [10, 18], "ethic": [10, 18],
+        }
+
+    def analyze(self, concept: str) -> str:
+        template = self.select_template(concept)
+        return template.replace("{concept}", concept)

reasoning_forge/agents/quantum_agent.py

@@ -0,0 +1,292 @@
+"""
+Quantum Agent - Analyzes concepts through probabilistic and uncertainty reasoning.
+
+Focuses on superposition of possibilities, measurement effects, probabilistic
+vs deterministic outcomes, entanglement and correlations, and wave-particle
+duality analogies.
+"""
+
+from reasoning_forge.agents.base_agent import ReasoningAgent
+
+
+class QuantumAgent(ReasoningAgent):
+    name = "Quantum"
+    perspective = "probabilistic_and_uncertainty"
+
+    def get_analysis_templates(self) -> list[str]:
+        return [
+            # 0 - Superposition of possibilities
+            (
+                "Before we commit to a single interpretation, '{concept}' exists in a "
+                "superposition of multiple valid framings simultaneously. Each framing "
+                "carries a probability amplitude -- not a classical probability, but a "
+                "complex weight that can interfere constructively or destructively with "
+                "others. Some framings reinforce each other, producing high-probability "
+                "interpretations; others cancel out, revealing that certain seemingly "
+                "plausible readings are actually suppressed by internal contradictions. "
+                "The richest understanding comes from maintaining this superposition as "
+                "long as possible, resisting the temptation to collapse prematurely into "
+                "a single narrative."
+            ),
+            # 1 - Measurement disturbance
+            (
+                "The act of examining '{concept}' necessarily disturbs it. Any attempt to "
+                "pin down one aspect with high precision introduces uncertainty into "
+                "complementary aspects. If we measure the current state with perfect "
+                "accuracy, we lose information about the trajectory of change. If we "
+                "track the dynamics precisely, the instantaneous state becomes blurred. "
+                "This is not a failure of our instruments -- it is a fundamental feature "
+                "of systems where the observer and observed are entangled. The experimental "
+                "design (which questions we choose to ask) shapes the answers we can obtain, "
+                "making the framing of inquiry as important as the inquiry itself."
+            ),
+            # 2 - Complementarity
+            (
+                "'{concept}' exhibits complementarity: it has pairs of properties that "
+                "cannot be simultaneously specified with arbitrary precision. Like position "
+                "and momentum in quantum mechanics, knowing one aspect exhaustively means "
+                "accepting irreducible uncertainty in its complement. The wave-like view "
+                "emphasizes distributed patterns, interference, and coherence across the "
+                "whole system. The particle-like view emphasizes localized events, discrete "
+                "outcomes, and individual instances. Neither view alone is complete; both "
+                "are needed, and the apparent contradiction between them is not a defect "
+                "but the deepest feature of the subject."
+            ),
+            # 3 - Probability amplitudes and interference
+            (
+                "Analyzing the probability landscape of '{concept}': outcomes are not "
+                "determined by summing classical probabilities but by summing amplitudes "
+                "that can interfere. Two pathways to the same outcome may cancel each other "
+                "(destructive interference), making a seemingly likely result improbable. "
+                "Alternatively, they may reinforce (constructive interference), making an "
+                "unlikely outcome surprisingly common. This means we cannot reason about "
+                "'{concept}' by considering each factor in isolation and adding up their "
+                "effects -- the cross-terms between factors, the interference pattern, "
+                "carries critical information that purely additive thinking misses."
+            ),
+            # 4 - Entanglement and correlation
+            (
+                "Multiple elements of '{concept}' are entangled: measuring or changing one "
+                "instantaneously constrains what we can know about the others, regardless "
+                "of the apparent separation between them. These correlations are stronger "
+                "than any classical explanation permits -- they cannot be reproduced by "
+                "assuming each element has pre-existing definite properties. This means "
+                "'{concept}' is not decomposable into fully independent parts. The "
+                "correlations between components carry information that is not contained "
+                "in any component individually. Analyzing the parts in isolation and then "
+                "trying to reconstruct the whole will systematically miss these non-local "
+                "correlations."
+            ),
+            # 5 - Collapse and decision
+            (
+                "At some point, the superposition of possibilities around '{concept}' must "
+                "collapse into a definite outcome. This collapse -- the moment of decision, "
+                "measurement, or commitment -- is irreversible. Before collapse, all "
+                "possibilities coexist and influence each other through interference. After "
+                "collapse, one outcome is realized and the others vanish. The timing of "
+                "this collapse matters enormously: collapsing too early (deciding prematurely) "
+                "forecloses options that might have interfered constructively. Collapsing "
+                "too late risks decoherence, where the environment randomizes the phases "
+                "and destroys the delicate interference patterns that could have guided "
+                "a better outcome."
+            ),
+            # 6 - Tunneling through barriers
+            (
+                "Within '{concept}', there may be barriers that appear insurmountable "
+                "under classical analysis -- energy gaps too wide, transitions too "
+                "improbable. But quantum tunneling demonstrates that a nonzero probability "
+                "exists for traversing barriers that classical reasoning says are impassable. "
+                "The tunneling probability depends exponentially on the barrier width and "
+                "height: thin barriers are penetrable, thick ones are not. For '{concept}', "
+                "this suggests asking: are the perceived obstacles genuinely thick barriers, "
+                "or are they thin barriers that appear impenetrable only because we are "
+                "applying classical (deterministic) reasoning to an inherently probabilistic "
+                "situation?"
+            ),
+            # 7 - Decoherence and information leakage
+            (
+                "The coherence of '{concept}' -- the ability of its different aspects to "
+                "interfere constructively -- is fragile. Interaction with a noisy environment "
+                "causes decoherence: the quantum-like superposition of possibilities decays "
+                "into a classical mixture where different outcomes no longer interfere. "
+                "Each interaction with the environment leaks information about the system's "
+                "state, effectively performing a partial measurement. The decoherence time "
+                "sets the window within which coherent reasoning about '{concept}' remains "
+                "valid. Beyond that window, the interference effects have washed out and "
+                "we are left with classical probabilistic reasoning -- still useful, but "
+                "less powerful."
+            ),
+            # 8 - No-cloning and uniqueness
+            (
+                "The no-cloning theorem states that an unknown quantum state cannot be "
+                "perfectly copied. Applied to '{concept}': if the concept embodies a unique "
+                "configuration of entangled properties, it cannot be perfectly replicated "
+                "by decomposing it into parts and reassembling them. Any attempt to copy "
+                "it disturbs the original. This has profound implications: unique instances "
+                "of '{concept}' are genuinely irreplaceable, not merely practically "
+                "difficult to reproduce. Strategies that depend on exact replication must "
+                "be replaced by strategies that work with approximate copies and manage "
+                "the fidelity loss."
+            ),
+            # 9 - Uncertainty principle application
+            (
+                "Heisenberg's uncertainty principle, generalized beyond physics, suggests "
+                "that '{concept}' has conjugate properties that trade off precision. "
+                "Specifying the concept's scope with extreme precision makes its future "
+                "trajectory unpredictable. Specifying the direction of change precisely "
+                "blurs the current boundaries. The product of these uncertainties has a "
+                "minimum value -- we cannot reduce both below a threshold. Practical "
+                "wisdom lies in choosing which uncertainty to minimize based on what "
+                "decisions we need to make, accepting that the conjugate uncertainty "
+                "will necessarily increase."
+            ),
+            # 10 - Quantum Zeno effect
+            (
+                "Frequent observation of '{concept}' can freeze its evolution -- the "
+                "quantum Zeno effect. Continuously monitoring whether the system has "
+                "changed forces it to remain in its initial state, because each "
+                "observation collapses the evolving superposition back to the starting "
+                "point before significant transition amplitude accumulates. Paradoxically, "
+                "the most watched aspects of '{concept}' may be the least likely to "
+                "change. Allowing unmonitored evolution -- stepping back and not measuring "
+                "for a while -- may be necessary for genuine transformation to occur."
+            ),
+            # 11 - Eigenstate decomposition
+            (
+                "Decomposing '{concept}' into its eigenstates -- the stable, self-consistent "
+                "configurations that persist under the relevant operator -- reveals the "
+                "natural modes of the system. Each eigenstate has a definite value for "
+                "the quantity being measured; a general state is a superposition of these "
+                "eigenstates. The eigenvalue spectrum (the set of possible measurement "
+                "outcomes) may be discrete, continuous, or mixed. Discrete spectra imply "
+                "quantized behavior: only certain values are possible, and the system "
+                "jumps between them. Identifying the eigenstates of '{concept}' tells us "
+                "what the stable configurations are and what transitions between them look like."
+            ),
+            # 12 - Path integral perspective
+            (
+                "From the path integral perspective, '{concept}' does not follow a single "
+                "trajectory from start to finish. Instead, every conceivable path contributes "
+                "to the final outcome, each weighted by a phase factor. Most paths cancel "
+                "each other out through destructive interference, leaving only a narrow "
+                "bundle of 'classical' paths that dominate the sum. But near decision points, "
+                "barriers, or transitions, the non-classical paths contribute significantly, "
+                "and the outcome depends on the full ensemble of possibilities. This perspective "
+                "counsels against fixating on the most likely path and instead attending to "
+                "the full distribution of paths that contribute to the result."
+            ),
+            # 13 - Entanglement entropy and information
+            (
+                "The entanglement entropy of '{concept}' measures how much information about "
+                "one part of the system is encoded in its correlations with other parts rather "
+                "than in the part itself. High entanglement entropy means the subsystem appears "
+                "maximally disordered when examined alone, even though the joint system may be "
+                "in a pure, fully determined state. This is a profound observation: local "
+                "ignorance can coexist with global certainty. For '{concept}', apparent "
+                "randomness or confusion at one level may dissolve into perfect order when "
+                "we expand our view to include the correlated components."
+            ),
+            # 14 - Basis dependence and frame choice
+            (
+                "Our analysis of '{concept}' depends critically on the basis we choose -- "
+                "the set of fundamental categories into which we decompose the concept. "
+                "A different basis (a different set of fundamental categories) can make a "
+                "confused-looking problem transparent, or a simple-looking problem intractable. "
+                "There is no uniquely 'correct' basis; the optimal choice depends on which "
+                "question we are asking. The interference terms that appear in one basis "
+                "become diagonal (simple) in another. Finding the basis that diagonalizes "
+                "the problem -- the natural language in which '{concept}' expresses itself "
+                "most simply -- is often the breakthrough that transforms understanding."
+            ),
+            # 15 - Coherent vs incoherent mixtures
+            (
+                "A critical distinction for '{concept}': is the coexistence of multiple "
+                "interpretations a coherent superposition (where they interfere and interact) "
+                "or an incoherent mixture (where they merely coexist without interaction, "
+                "like balls in an urn)? A coherent superposition produces interference "
+                "effects -- outcomes that no single interpretation predicts. An incoherent "
+                "mixture produces only the probabilistic average of individual interpretations. "
+                "The practical difference is enormous: coherent combinations can exhibit "
+                "effects (constructive peaks, destructive nulls) that are impossible in "
+                "any classical mixture."
+            ),
+            # 16 - Quantum error and robustness
+            (
+                "How robust is '{concept}' against errors and noise? Quantum error correction "
+                "teaches that information can be protected by encoding it redundantly across "
+                "entangled components. No single component carries the full information, so "
+                "no single error can destroy it. For '{concept}', the analogous question is: "
+                "how is the essential meaning distributed across its components? If it is "
+                "concentrated in a single fragile element, one disruption destroys it. If "
+                "it is encoded holographically across many entangled elements, it is "
+                "remarkably robust against local damage."
+            ),
+            # 17 - Born rule and outcome probabilities
+            (
+                "The Born rule assigns probabilities to outcomes as the squared magnitude "
+                "of the amplitude. Applied to '{concept}': the probability of a particular "
+                "interpretation prevailing is not the amplitude of support for it but the "
+                "amplitude squared -- a nonlinear transformation. Small differences in "
+                "amplitude translate to large differences in probability. A framing with "
+                "twice the amplitude is four times as likely to be realized. This squared "
+                "relationship means that dominant framings dominate more than linear "
+                "reasoning predicts, while minority framings are suppressed more severely "
+                "than their representation in discourse would suggest."
+            ),
+            # 18 - Contextuality
+            (
+                "'{concept}' may be contextual: the outcome of examining one property "
+                "depends on which other properties are being examined simultaneously. "
+                "There is no assignment of pre-existing definite values to all properties "
+                "that reproduces the observed correlations -- the properties do not exist "
+                "independently of the measurement context. This is stronger than mere "
+                "observer bias: it means the properties are genuinely undefined until "
+                "a context is specified. For '{concept}', this implies that asking 'what "
+                "is it really?' without specifying the context of inquiry is a question "
+                "that has no answer."
+            ),
+            # 19 - Quantum advantage
+            (
+                "Is there a quantum advantage in reasoning about '{concept}'? Classical "
+                "reasoning processes information one path at a time. Quantum-inspired "
+                "reasoning processes all paths simultaneously through superposition, "
+                "using interference to amplify correct conclusions and suppress incorrect "
+                "ones. The advantage is greatest for problems with hidden structure -- "
+                "where the correct answer is encoded in correlations between variables "
+                "that classical single-path reasoning cannot efficiently explore. If "
+                "'{concept}' has such hidden structure, maintaining a superposition of "
+                "hypotheses and allowing them to interfere will converge on the answer "
+                "faster than serially testing each hypothesis."
+            ),
+        ]
+
+    def get_keyword_map(self) -> dict[str, list[int]]:
+        return {
+            "possibilit": [0, 5], "option": [0, 5], "choice": [0, 5],
+            "measure": [1, 10], "observ": [1, 10], "monitor": [1, 10],
+            "complement": [2], "dual": [2], "wave": [2], "particle": [2],
+            "probabilit": [3, 17], "likel": [3, 17], "chance": [3, 17],
+            "correlat": [4, 13], "connect": [4], "relat": [4],
+            "decid": [5], "commit": [5], "irreversib": [5],
+            "barrier": [6], "obstacle": [6], "impossibl": [6],
+            "noise": [7, 16], "decay": [7], "environm": [7],
+            "unique": [8], "copy": [8], "replica": [8],
+            "uncertain": [9], "tradeoff": [9], "precis": [9],
+            "watch": [10], "surveil": [10], "frequent": [10],
+            "stable": [11], "mode": [11], "spectrum": [11],
+            "path": [12], "trajectory": [12], "possib": [12],
+            "inform": [13], "entropy": [13], "knowledge": [13],
+            "categor": [14], "basis": [14], "framework": [14], "frame": [14],
+            "coexist": [15], "mixture": [15], "blend": [15],
+            "robust": [16], "error": [16], "protect": [16],
+            "dominant": [17], "major": [17], "minor": [17],
+            "context": [18], "depend": [18], "situati": [18],
+            "advantage": [19], "efficien": [19], "complex": [19],
+            "technology": [6, 19], "society": [4, 7], "learning": [10, 12],
+            "intelligence": [14, 19], "evolution": [5, 12],
+            "health": [1, 9], "network": [4, 13],
+        }
+
+    def analyze(self, concept: str) -> str:
+        template = self.select_template(concept)
+        return template.replace("{concept}", concept)

reasoning_forge/cocoon_sync.py

@@ -0,0 +1,441 @@
+"""
+Federated Cocoon Synchronization Protocol — Encrypted state packaging,
+HMAC signing, and attractor merger for distributed RC+xi nodes.
+
+Implements:
+  - Cocoon packaging with full RC+xi metrics
+  - Fernet symmetric encryption (AES-128-CBC + HMAC-SHA256)
+  - Attractor merger via weighted mean-field coupling (Eq. 12)
+  - Phase coherence consensus (Gamma >= 0.98 target)
+  - Secure sync protocol: package -> encrypt -> sign -> transmit -> verify -> merge
+
+This module enables Codette Pods (edge nodes on RPi 5) to synchronize
+their reasoning state without exposing raw data.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import os
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+# Encryption is optional — gracefully degrade if cryptography not installed
+try:
+    from cryptography.fernet import Fernet
+    HAS_CRYPTO = True
+except ImportError:
+    HAS_CRYPTO = False
+
+
+# ---------------------------------------------------------------------------
+# Data structures
+# ---------------------------------------------------------------------------
+
+@dataclass
+class CocoonPackage:
+    """A packaged cocoon ready for sync."""
+    cocoon_id: str
+    node_id: str
+    timestamp: float
+    state_snapshot: Dict[str, Any]
+    attractors: List[Dict]
+    glyphs: List[Dict]
+    metrics: Dict[str, float]
+    payload_hash: str
+    encrypted: bool = False
+    raw_payload: Optional[bytes] = None
+    signature: Optional[str] = None
+
+
+@dataclass
+class SyncResult:
+    """Result of a cocoon synchronization."""
+    success: bool
+    merged_attractors: int
+    new_glyphs: int
+    coherence_before: float
+    coherence_after: float
+    tension_delta: float
+    errors: List[str] = field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Key management
+# ---------------------------------------------------------------------------
+
+class CocoonKeyManager:
+    """Manages encryption keys for cocoon sync."""
+
+    def __init__(self, key: Optional[bytes] = None):
+        if key:
+            self._key = key
+        elif HAS_CRYPTO:
+            self._key = Fernet.generate_key()
+        else:
+            self._key = os.urandom(32)
+
+    @property
+    def key(self) -> bytes:
+        return self._key
+
+    def derive_hmac_key(self) -> bytes:
+        return hashlib.sha256(self._key + b"hmac_salt_cocoon").digest()
+
+
+# ---------------------------------------------------------------------------
+# CocoonSync
+# ---------------------------------------------------------------------------
+
+class CocoonSync:
+    """Federated cocoon synchronization protocol."""
+
+    def __init__(
+        self,
+        node_id: str,
+        key_manager: Optional[CocoonKeyManager] = None,
+        coherence_target: float = 0.98,
+        tension_target: float = 0.05,
+        ethical_target: float = 0.90,
+    ):
+        self.node_id = node_id
+        self.key_manager = key_manager or CocoonKeyManager()
+        self.coherence_target = coherence_target
+        self.tension_target = tension_target
+        self.ethical_target = ethical_target
+
+        self._local_attractors: List[Dict] = []
+        self._local_glyphs: List[Dict] = []
+        self._sync_history: List[Dict] = []
+
+    # -- Step 1: Package ----------------------------------------------------
+
+    def package_cocoon(
+        self,
+        spiderweb_state: Dict[str, Any],
+        phase_coherence: float,
+        epistemic_tension: float,
+        ethical_alignment: float,
+        attractors: Optional[List[Dict]] = None,
+        glyphs: Optional[List[Dict]] = None,
+    ) -> CocoonPackage:
+        """Package current state into a cocoon for transmission.
+
+        Args:
+            spiderweb_state: Serialized QuantumSpiderweb state.
+            phase_coherence: Current Gamma value.
+            epistemic_tension: Current xi value.
+            ethical_alignment: Current AEGIS eta value.
+            attractors: Detected attractor manifolds.
+            glyphs: Identity glyphs formed.
+
+        Returns:
+            CocoonPackage ready for encryption and transmission.
+        """
+        cocoon_id = f"cocoon_{uuid.uuid4().hex[:12]}"
+
+        metrics = {
+            "phase_coherence": round(phase_coherence, 4),
+            "epistemic_tension": round(epistemic_tension, 4),
+            "ethical_alignment": round(ethical_alignment, 4),
+            "timestamp": time.time(),
+        }
+
+        # Build payload
+        payload = {
+            "cocoon_id": cocoon_id,
+            "node_id": self.node_id,
+            "state": spiderweb_state,
+            "attractors": attractors or [],
+            "glyphs": glyphs or [],
+            "metrics": metrics,
+        }
+
+        payload_json = json.dumps(payload, sort_keys=True, default=str)
+        payload_hash = hashlib.sha256(payload_json.encode()).hexdigest()
+
+        return CocoonPackage(
+            cocoon_id=cocoon_id,
+            node_id=self.node_id,
+            timestamp=time.time(),
+            state_snapshot=spiderweb_state,
+            attractors=attractors or [],
+            glyphs=glyphs or [],
+            metrics=metrics,
+            payload_hash=payload_hash,
+            raw_payload=payload_json.encode(),
+        )
+
+    # -- Step 2: Encrypt ---------------------------------------------------
+
+    def encrypt_cocoon(self, package: CocoonPackage) -> CocoonPackage:
+        """Encrypt cocoon payload with Fernet (AES-128-CBC + HMAC-SHA256).
+
+        Returns a new CocoonPackage; does not mutate the input.
+        Falls back to XOR obfuscation if cryptography is not installed.
+        """
+        import copy
+        result = copy.copy(package)
+
+        if result.raw_payload is None:
+            payload_json = json.dumps({
+                "cocoon_id": result.cocoon_id,
+                "node_id": result.node_id,
+                "state": result.state_snapshot,
+                "attractors": result.attractors,
+                "glyphs": result.glyphs,
+                "metrics": result.metrics,
+            }, sort_keys=True, default=str)
+            result.raw_payload = payload_json.encode()
+
+        if HAS_CRYPTO:
+            fernet = Fernet(self.key_manager.key)
+            encrypted = fernet.encrypt(result.raw_payload)
+            result.raw_payload = encrypted
+            result.encrypted = True
+        else:
+            # Fallback: XOR obfuscation (not real encryption — placeholder)
+            key_bytes = self.key_manager.key[:len(result.raw_payload)]
+            obfuscated = bytes(
+                a ^ b for a, b in
+                zip(result.raw_payload, key_bytes * (len(result.raw_payload) // len(key_bytes) + 1))
+            )
+            result.raw_payload = obfuscated
+            result.encrypted = True
+
+        return result
+
+    # -- Step 3: Sign ------------------------------------------------------
+
+    def sign_cocoon(self, package: CocoonPackage) -> CocoonPackage:
+        """Sign cocoon with HMAC-SHA256 for integrity verification.
+
+        Returns a new CocoonPackage; does not mutate the input.
+        """
+        import copy
+        result = copy.copy(package)
+        hmac_key = self.key_manager.derive_hmac_key()
+        data_to_sign = result.raw_payload or result.payload_hash.encode()
+        signature = hmac.new(hmac_key, data_to_sign, hashlib.sha256).hexdigest()
+        result.signature = signature
+        return result
+
+    # -- Step 4: Verify (receiving end) ------------------------------------
+
+    def verify_cocoon(self, package: CocoonPackage) -> bool:
+        """Verify HMAC signature of incoming cocoon."""
+        if not package.signature:
+            return False
+        hmac_key = self.key_manager.derive_hmac_key()
+        data_to_verify = package.raw_payload or package.payload_hash.encode()
+        expected = hmac.new(hmac_key, data_to_verify, hashlib.sha256).hexdigest()
+        return hmac.compare_digest(expected, package.signature)
+
+    # -- Step 5: Decrypt ---------------------------------------------------
+
+    def decrypt_cocoon(self, package: CocoonPackage) -> Dict[str, Any]:
+        """Decrypt cocoon payload.
+
+        Returns the deserialized payload dict.
+        """
+        if not package.encrypted or package.raw_payload is None:
+            return {
+                "state": package.state_snapshot,
+                "attractors": package.attractors,
+                "glyphs": package.glyphs,
+                "metrics": package.metrics,
+            }
+
+        if HAS_CRYPTO:
+            fernet = Fernet(self.key_manager.key)
+            decrypted = fernet.decrypt(package.raw_payload)
+        else:
+            # Reverse XOR
+            key_bytes = self.key_manager.key[:len(package.raw_payload)]
+            decrypted = bytes(
+                a ^ b for a, b in
+                zip(package.raw_payload, key_bytes * (len(package.raw_payload) // len(key_bytes) + 1))
+            )
+
+        return json.loads(decrypted.decode())
+
+    # -- Step 6: Merge attractors ------------------------------------------
+
+    def merge_attractors(
+        self,
+        local_attractors: List[Dict],
+        remote_attractors: List[Dict],
+        local_coherence: float = 0.95,
+        merge_radius: float = 2.0,
+    ) -> List[Dict]:
+        """Weighted attractor merger via mean-field coupling (Eq. 12).
+
+        alpha = local_coherence: higher coherence = trust local more.
+        """
+        alpha = min(local_coherence, 0.95)
+        merged = list(local_attractors)
+
+        for remote_att in remote_attractors:
+            r_center = remote_att.get("center", [0] * 5)
+            matched = False
+
+            for local_att in merged:
+                l_center = local_att.get("center", [0] * 5)
+                # Compute distance
+                dist = sum((a - b) ** 2 for a, b in zip(l_center, r_center)) ** 0.5
+                if dist <= merge_radius:
+                    # Weighted merge: c_merged = alpha * c_local + (1-alpha) * c_remote
+                    new_center = [
+                        alpha * lc + (1 - alpha) * rc
+                        for lc, rc in zip(l_center, r_center)
+                    ]
+                    local_att["center"] = new_center
+                    # Expand member list
+                    local_att.setdefault("remote_members", [])
+                    local_att["remote_members"].extend(
+                        remote_att.get("members", [])
+                    )
+                    matched = True
+                    break
+
+            if not matched:
+                # New attractor from remote
+                merged.append({
+                    "attractor_id": remote_att.get("attractor_id", f"remote_{len(merged)}"),
+                    "center": r_center,
+                    "members": remote_att.get("members", []),
+                    "source": "remote",
+                })
+
+        return merged
+
+    # -- Full sync protocol ------------------------------------------------
+
+    def sync_with_remote(
+        self,
+        incoming_package: CocoonPackage,
+        local_spiderweb_state: Dict[str, Any],
+        local_coherence: float,
+        local_tension: float,
+    ) -> SyncResult:
+        """Full sync protocol: verify -> decrypt -> merge -> report.
+
+        Args:
+            incoming_package: Encrypted cocoon from remote node.
+            local_spiderweb_state: Current local web state.
+            local_coherence: Current local Gamma.
+            local_tension: Current local xi.
+
+        Returns:
+            SyncResult with merge statistics.
+        """
+        errors: List[str] = []
+
+        # Verify
+        if not self.verify_cocoon(incoming_package):
+            return SyncResult(
+                success=False, merged_attractors=0, new_glyphs=0,
+                coherence_before=local_coherence, coherence_after=local_coherence,
+                tension_delta=0.0, errors=["HMAC verification failed"],
+            )
+
+        # Decrypt
+        try:
+            remote_data = self.decrypt_cocoon(incoming_package)
+        except Exception as e:
+            return SyncResult(
+                success=False, merged_attractors=0, new_glyphs=0,
+                coherence_before=local_coherence, coherence_after=local_coherence,
+                tension_delta=0.0, errors=[f"Decryption failed: {e}"],
+            )
+
+        # Check ethical alignment
+        remote_eta = remote_data.get("metrics", {}).get("ethical_alignment", 0)
+        if remote_eta < self.ethical_target:
+            errors.append(
+                f"Remote ethical alignment {remote_eta:.3f} below target {self.ethical_target}"
+            )
+
+        # Merge attractors
+        remote_attractors = remote_data.get("attractors", [])
+        local_attractors = self._extract_attractors(local_spiderweb_state)
+        merged = self.merge_attractors(
+            local_attractors, remote_attractors, local_coherence
+        )
+        new_attractor_count = len(merged) - len(local_attractors)
+
+        # Collect new glyphs
+        remote_glyphs = remote_data.get("glyphs", [])
+        existing_ids = {g.get("glyph_id") for g in self._local_glyphs}
+        new_glyphs = [g for g in remote_glyphs if g.get("glyph_id") not in existing_ids]
+        self._local_glyphs.extend(new_glyphs)
+
+        # Estimate new coherence (weighted average)
+        remote_coherence = remote_data.get("metrics", {}).get("phase_coherence", 0.5)
+        new_coherence = 0.7 * local_coherence + 0.3 * remote_coherence
+
+        remote_tension = remote_data.get("metrics", {}).get("epistemic_tension", 0.5)
+        tension_delta = remote_tension - local_tension
+
+        # Record sync
+        self._sync_history.append({
+            "timestamp": time.time(),
+            "remote_node": incoming_package.node_id,
+            "merged_attractors": len(merged),
+            "new_glyphs": len(new_glyphs),
+            "coherence_after": new_coherence,
+        })
+
+        return SyncResult(
+            success=True,
+            merged_attractors=new_attractor_count,
+            new_glyphs=len(new_glyphs),
+            coherence_before=local_coherence,
+            coherence_after=round(new_coherence, 4),
+            tension_delta=round(tension_delta, 4),
+            errors=errors,
+        )
+
+    def check_consensus(
+        self,
+        local_coherence: float,
+        local_tension: float,
+        local_eta: float,
+    ) -> Dict[str, bool]:
+        """Check if local node meets consensus criteria.
+
+        Target: Gamma >= 0.98, xi <= 0.05, eta >= 0.90
+        """
+        return {
+            "phase_coherence_met": local_coherence >= self.coherence_target,
+            "tension_met": local_tension <= self.tension_target,
+            "ethical_met": local_eta >= self.ethical_target,
+            "consensus": (
+                local_coherence >= self.coherence_target
+                and local_tension <= self.tension_target
+                and local_eta >= self.ethical_target
+            ),
+        }
+
+    def _extract_attractors(self, web_state: Dict) -> List[Dict]:
+        """Extract attractors from spiderweb state dict."""
+        # Try to find attractors in the state
+        if isinstance(web_state, dict):
+            if "attractors" in web_state:
+                return web_state["attractors"]
+        return self._local_attractors
+
+    def get_sync_status(self) -> Dict[str, Any]:
+        """Return sync protocol status."""
+        return {
+            "node_id": self.node_id,
+            "total_syncs": len(self._sync_history),
+            "local_attractors": len(self._local_attractors),
+            "local_glyphs": len(self._local_glyphs),
+            "has_encryption": HAS_CRYPTO,
+            "recent_syncs": self._sync_history[-5:],
+        }

reasoning_forge/dream_reweaver.py

@@ -0,0 +1,378 @@
+"""
+DreamReweaver — Creative Synthesis Engine for the Codette RC+xi Framework.
+
+Inspired by VIVARA Genesis-Omega v2.0 (generated by a Codette prototype),
+rebuilt with proper integration into the QuantumSpiderweb and EpistemicMetrics.
+
+The DreamReweaver performs two core functions:
+
+1. **Creative Synthesis**: Takes multi-perspective outputs and weaves them
+   into richer, more creative framings by finding unexpected connections
+   between perspectives. Unlike the base synthesizer, DreamReweaver
+   explicitly uses spiderweb tension data to identify where productive
+   disagreement exists and highlights those creative edges.
+
+2. **Dream Field Evolution**: Controlled stochastic perturbation of the
+   spiderweb state to break out of local attractor minima. Simulates
+   a "dreaming" phase that explores new cognitive configurations.
+
+Both functions are safe — bounded perturbations, no runaway state changes,
+and full transparency in what was modified.
+"""
+
+from __future__ import annotations
+
+import math
+import random
+import hashlib
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+try:
+    import numpy as np
+    HAS_NUMPY = True
+except ImportError:
+    HAS_NUMPY = False
+
+
+@dataclass
+class DreamSynthesis:
+    """Result of a creative synthesis pass."""
+    creative_frame: str          # The creative reframing / meta-narrative
+    tension_edges: List[Dict]    # Which perspective pairs had highest tension
+    novel_connections: List[str]  # Unexpected cross-perspective connections found
+    dream_coherence: float       # How well the creative frame holds together
+    seed_hash: str               # Deterministic ID for this dream
+
+
+@dataclass
+class DreamFieldResult:
+    """Result of a dream field evolution pass."""
+    nodes_perturbed: int
+    max_perturbation: float
+    coherence_before: float
+    coherence_after: float
+    new_attractors_found: int
+    lifeforms_spawned: List[str]
+
+
+# Creative connection templates that link perspective-specific insights
+_CREATIVE_BRIDGES = {
+    ("newton", "empathy"): "Where precise forces meet felt experience, we find that {insight_a} resonates with {insight_b} — suggesting that understanding isn't purely analytical or purely emotional, but a harmonic of both.",
+    ("newton", "philosophy"): "The rigorous analysis showing {insight_a} meets the deeper question {insight_b} — precision and meaning converge.",
+    ("newton", "quantum"): "Classical certainty ({insight_a}) dissolves into quantum possibility ({insight_b}) — both valid at their scale, richer together.",
+    ("davinci", "empathy"): "Creative invention ({insight_a}) gains soul when guided by {insight_b} — innovation with compassion.",
+    ("davinci", "quantum"): "Cross-domain creativity ({insight_a}) mirrors quantum superposition ({insight_b}) — holding multiple possibilities until the right one crystallizes.",
+    ("empathy", "philosophy"): "Emotional understanding ({insight_a}) deepens philosophical inquiry ({insight_b}) — feeling and reasoning as partners.",
+    ("empathy", "quantum"): "Compassionate awareness ({insight_a}) embraces uncertainty ({insight_b}) — caring without needing to control.",
+    ("philosophy", "quantum"): "Fundamental questioning ({insight_a}) meets fundamental uncertainty ({insight_b}) — the deepest answers may be the questions themselves.",
+    ("consciousness", "empathy"): "Self-reflective awareness ({insight_a}) meets empathic understanding ({insight_b}) — knowing oneself to know others.",
+    ("consciousness", "philosophy"): "Meta-cognition ({insight_a}) reflects on philosophical depth ({insight_b}) — thought thinking about thought.",
+    ("systems_architecture", "davinci"): "Modular design ({insight_a}) embraces creative invention ({insight_b}) — elegant architecture as art.",
+}
+
+# Perspective keywords for extracting key insights from text
+_PERSPECTIVE_SIGNAL_WORDS = {
+    "newton": ["force", "energy", "law", "cause", "effect", "systematic", "evidence", "measure"],
+    "davinci": ["create", "design", "invent", "combine", "imagine", "novel", "prototype", "vision"],
+    "empathy": ["feel", "experience", "care", "understand", "support", "human", "compassion", "relate"],
+    "philosophy": ["meaning", "existence", "truth", "question", "assumption", "fundamental", "purpose"],
+    "quantum": ["probability", "possibility", "uncertain", "superposition", "observe", "complementary"],
+    "consciousness": ["aware", "reflect", "meta", "recursive", "self", "cognition", "emerge"],
+    "multi_perspective": ["synthesize", "integrate", "weave", "converge", "multiple", "holistic"],
+    "systems_architecture": ["module", "scale", "interface", "pattern", "layer", "component", "design"],
+}
+
+
+class DreamReweaver:
+    """Creative synthesis and dream field evolution for Codette."""
+
+    def __init__(self, creativity: float = 0.3, max_perturbation: float = 0.08):
+        """
+        Args:
+            creativity: 0-1 scale, how much creative license to take (0=faithful, 1=wild)
+            max_perturbation: Maximum state change per node during dream field evolution
+        """
+        self.creativity = min(max(creativity, 0.0), 1.0)
+        self.max_perturbation = max_perturbation
+        self.dream_history: List[DreamSynthesis] = []
+
+    def synthesize(
+        self,
+        perspectives: Dict[str, str],
+        tension_map: Optional[Dict[str, float]] = None,
+        query: str = "",
+    ) -> DreamSynthesis:
+        """Create a creative synthesis from multiple perspective responses.
+
+        Unlike the base orchestrator's _synthesize (which just concatenates and
+        asks the model to combine), DreamReweaver explicitly identifies tension
+        edges and builds creative bridges between perspectives.
+
+        Args:
+            perspectives: Dict of adapter_name -> response text
+            tension_map: Optional pairwise tension scores (from EpistemicMetrics)
+            query: The original user query (for context)
+
+        Returns:
+            DreamSynthesis with creative framing and metadata
+        """
+        if len(perspectives) < 2:
+            only_text = list(perspectives.values())[0] if perspectives else ""
+            return DreamSynthesis(
+                creative_frame=only_text,
+                tension_edges=[],
+                novel_connections=[],
+                dream_coherence=1.0,
+                seed_hash=hashlib.md5(only_text.encode()).hexdigest()[:12],
+            )
+
+        # 1. Find the highest-tension pairs
+        tension_edges = self._find_tension_edges(perspectives, tension_map)
+
+        # 2. Extract key insights from each perspective
+        insights = self._extract_insights(perspectives)
+
+        # 3. Build creative bridges between high-tension pairs
+        novel_connections = self._build_bridges(tension_edges, insights)
+
+        # 4. Compose the creative frame
+        creative_frame = self._compose_frame(
+            query, perspectives, tension_edges, novel_connections, insights
+        )
+
+        # 5. Score coherence of the creative frame
+        dream_coherence = self._score_dream_coherence(
+            creative_frame, perspectives
+        )
+
+        seed = hashlib.md5(creative_frame.encode()).hexdigest()[:12]
+        synthesis = DreamSynthesis(
+            creative_frame=creative_frame,
+            tension_edges=tension_edges,
+            novel_connections=novel_connections,
+            dream_coherence=round(dream_coherence, 4),
+            seed_hash=seed,
+        )
+        self.dream_history.append(synthesis)
+        return synthesis
+
+    def _find_tension_edges(
+        self,
+        perspectives: Dict[str, str],
+        tension_map: Optional[Dict[str, float]],
+    ) -> List[Dict]:
+        """Find the perspective pairs with highest epistemic tension."""
+        if tension_map:
+            edges = []
+            for pair_key, tension in sorted(
+                tension_map.items(), key=lambda x: x[1], reverse=True
+            ):
+                parts = pair_key.split("_vs_")
+                if len(parts) == 2:
+                    edges.append({
+                        "pair": (parts[0], parts[1]),
+                        "tension": tension,
+                    })
+            return edges[:3]  # Top 3 tension pairs
+
+        # Fallback: compute basic word-overlap tension
+        names = list(perspectives.keys())
+        edges = []
+        for i in range(len(names)):
+            for j in range(i + 1, len(names)):
+                words_a = set(perspectives[names[i]].lower().split())
+                words_b = set(perspectives[names[j]].lower().split())
+                overlap = len(words_a & words_b)
+                total = len(words_a | words_b) or 1
+                tension = 1.0 - (overlap / total)
+                edges.append({
+                    "pair": (names[i], names[j]),
+                    "tension": round(tension, 4),
+                })
+        edges.sort(key=lambda e: e["tension"], reverse=True)
+        return edges[:3]
+
+    def _extract_insights(self, perspectives: Dict[str, str]) -> Dict[str, str]:
+        """Extract a key insight sentence from each perspective."""
+        insights = {}
+        for name, text in perspectives.items():
+            sentences = [s.strip() for s in text.replace("\n", " ").split(".")
+                         if len(s.strip()) > 20]
+            if not sentences:
+                insights[name] = text[:100]
+                continue
+
+            # Score sentences by presence of perspective-specific signal words
+            signal_words = _PERSPECTIVE_SIGNAL_WORDS.get(name, [])
+            scored = []
+            for sent in sentences:
+                score = sum(1 for w in signal_words if w in sent.lower())
+                scored.append((score, sent))
+            scored.sort(key=lambda x: x[0], reverse=True)
+            insights[name] = scored[0][1]
+        return insights
+
+    def _build_bridges(
+        self,
+        tension_edges: List[Dict],
+        insights: Dict[str, str],
+    ) -> List[str]:
+        """Build creative bridges between high-tension perspective pairs."""
+        bridges = []
+        for edge in tension_edges:
+            a, b = edge["pair"]
+            # Normalize pair order for template lookup
+            key = (a, b) if (a, b) in _CREATIVE_BRIDGES else (b, a)
+            template = _CREATIVE_BRIDGES.get(key)
+
+            insight_a = insights.get(a, "their perspective")
+            insight_b = insights.get(b, "their perspective")
+
+            if template:
+                bridge = template.format(
+                    insight_a=insight_a[:80],
+                    insight_b=insight_b[:80],
+                )
+            else:
+                bridge = (f"The tension between {a}'s view ({insight_a[:60]}...) "
+                          f"and {b}'s view ({insight_b[:60]}...) reveals a "
+                          f"productive edge worth exploring.")
+            bridges.append(bridge)
+        return bridges
+
+    def _compose_frame(
+        self,
+        query: str,
+        perspectives: Dict[str, str],
+        tension_edges: List[Dict],
+        bridges: List[str],
+        insights: Dict[str, str],
+    ) -> str:
+        """Compose the full creative synthesis frame.
+
+        This produces a structured creative meta-narrative, NOT just
+        concatenated text. It's designed to be injected into the model's
+        synthesis prompt for richer output.
+        """
+        parts = []
+
+        # Opening: frame the creative tension
+        if tension_edges:
+            top = tension_edges[0]
+            parts.append(
+                f"This question draws {len(perspectives)} perspectives into "
+                f"productive tension. The strongest creative edge lies between "
+                f"{top['pair'][0]} and {top['pair'][1]} "
+                f"(tension: {top['tension']:.2f})."
+            )
+
+        # Middle: present bridges
+        if bridges:
+            parts.append("\nCreative bridges between perspectives:")
+            for i, bridge in enumerate(bridges, 1):
+                parts.append(f"  {i}. {bridge}")
+
+        # Closing: synthesis direction
+        all_insights = list(insights.values())
+        if len(all_insights) >= 2:
+            parts.append(
+                f"\nThe synthesis should weave these {len(perspectives)} "
+                f"viewpoints into a response that honors their tensions "
+                f"rather than flattening them."
+            )
+
+        return "\n".join(parts)
+
+    def _score_dream_coherence(
+        self,
+        creative_frame: str,
+        perspectives: Dict[str, str],
+    ) -> float:
+        """Score how well the creative frame integrates all perspectives."""
+        frame_words = set(creative_frame.lower().split())
+        coverage_scores = []
+        for name, text in perspectives.items():
+            key_words = set(text.lower().split()[:30])  # First 30 words
+            if key_words:
+                overlap = len(key_words & frame_words)
+                coverage_scores.append(overlap / len(key_words))
+        return sum(coverage_scores) / max(len(coverage_scores), 1)
+
+    # -- Dream Field Evolution -------------------------------------------------
+
+    def evolve_dream_field(
+        self,
+        spiderweb,  # QuantumSpiderweb instance
+        intensity: float = 0.5,
+        spawn_threshold: float = 0.85,
+    ) -> DreamFieldResult:
+        """Controlled stochastic perturbation of the spiderweb.
+
+        Simulates a "dreaming" phase: randomly perturbs node states to explore
+        new cognitive configurations, potentially breaking out of attractor basins.
+
+        Bounded: perturbations are capped at self.max_perturbation * intensity.
+        Safe: states are clipped to [-3, 3] range.
+
+        Args:
+            spiderweb: QuantumSpiderweb instance to perturb
+            intensity: 0-1 dream intensity (0=gentle, 1=vivid)
+            spawn_threshold: Coherence threshold above which new lifeforms spawn
+
+        Returns:
+            DreamFieldResult with before/after metrics
+        """
+        coherence_before = spiderweb.phase_coherence()
+        max_delta = self.max_perturbation * intensity
+        nodes_perturbed = 0
+        actual_max = 0.0
+        lifeforms = []
+
+        for node_id, node in spiderweb.nodes.items():
+            arr = node.state.to_array()
+            # Apply bounded random perturbation
+            if HAS_NUMPY:
+                delta = np.random.uniform(-max_delta, max_delta, 5)
+                new_arr = np.clip(np.array(arr) + delta, -3.0, 3.0).tolist()
+                actual_max = max(actual_max, float(np.max(np.abs(delta))))
+            else:
+                delta = [random.uniform(-max_delta, max_delta) for _ in range(5)]
+                new_arr = [max(-3.0, min(3.0, a + d)) for a, d in zip(arr, delta)]
+                actual_max = max(actual_max, max(abs(d) for d in delta))
+
+            from reasoning_forge.quantum_spiderweb import NodeState
+            node.state = NodeState.from_array(new_arr)
+            nodes_perturbed += 1
+
+        # Check if dreaming spawned new high-coherence configurations
+        coherence_after = spiderweb._compute_phase_coherence_readonly()
+
+        # Spawn "lifeform" nodes if coherence spiked during dreaming
+        if coherence_after > spawn_threshold and coherence_after > coherence_before:
+            lifeform_id = f"dream_{hashlib.md5(str(random.random()).encode()).hexdigest()[:8]}"
+            from reasoning_forge.quantum_spiderweb import NodeState
+            # High-coherence birth state
+            if HAS_NUMPY:
+                state_arr = np.random.uniform(0.5, 1.0, 5).tolist()
+            else:
+                state_arr = [random.uniform(0.5, 1.0) for _ in range(5)]
+            spiderweb.add_node(lifeform_id, NodeState.from_array(state_arr))
+            # Connect to a few existing nodes
+            existing = list(spiderweb.nodes.keys())
+            for peer in random.sample(existing, min(3, len(existing))):
+                if peer != lifeform_id:
+                    spiderweb.connect(lifeform_id, peer)
+            lifeforms.append(lifeform_id)
+
+        # Detect new attractors after dreaming
+        new_attractors = spiderweb.detect_attractors()
+
+        return DreamFieldResult(
+            nodes_perturbed=nodes_perturbed,
+            max_perturbation=round(actual_max, 6),
+            coherence_before=round(coherence_before, 4),
+            coherence_after=round(coherence_after, 4),
+            new_attractors_found=len(new_attractors),
+            lifeforms_spawned=lifeforms,
+        )

reasoning_forge/epistemic_metrics.py

@@ -0,0 +1,282 @@
+"""
+Epistemic Metrics — RC+xi tension and coherence measurement for the Reasoning Forge.
+
+Implements the core RC+xi equations within the forge context:
+  - Epistemic tension (Eq. 2): xi_n = ||A_{n+1} - A_n||^2
+  - Phase coherence (Eq. 11): Gamma = mean(|cos(theta_i - theta_bar)|)
+  - Perspective coverage scoring
+  - Tension decay tracking across debate rounds
+
+These metrics let the forge quantify whether multi-agent reasoning actually
+converges (productive tension resolution) or stalls (tension suppression).
+"""
+
+from __future__ import annotations
+
+import math
+import re
+from collections import Counter
+from typing import Dict, List, Optional, Tuple
+
+
+# ---------------------------------------------------------------------------
+# Text -> vector helpers (lightweight, no external deps)
+# ---------------------------------------------------------------------------
+
+_STOP_WORDS = {
+    "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", "and", "but", "or", "nor", "not", "so",
+    "yet", "both", "this", "that", "these", "those", "it", "its", "they",
+    "them", "their", "we", "our", "you", "your", "he", "she", "his", "her",
+}
+
+
+def _tokenize(text: str) -> List[str]:
+    return [w for w in re.findall(r"[a-z]{3,}", text.lower()) if w not in _STOP_WORDS]
+
+
+def _term_vector(text: str) -> Counter:
+    return Counter(_tokenize(text))
+
+
+def _cosine_similarity(vec_a: Counter, vec_b: Counter) -> float:
+    keys = set(vec_a) | set(vec_b)
+    if not keys:
+        return 0.0
+    dot = sum(vec_a.get(k, 0) * vec_b.get(k, 0) for k in keys)
+    mag_a = math.sqrt(sum(v * v for v in vec_a.values()))
+    mag_b = math.sqrt(sum(v * v for v in vec_b.values()))
+    if mag_a == 0 or mag_b == 0:
+        return 0.0
+    return dot / (mag_a * mag_b)
+
+
+# ---------------------------------------------------------------------------
+# Perspective vocabulary banks (for coverage scoring)
+# ---------------------------------------------------------------------------
+
+_PERSPECTIVE_VOCAB = {
+    "Newton": {
+        "force", "energy", "momentum", "conservation", "equilibrium", "dynamics",
+        "causality", "mass", "acceleration", "entropy", "thermodynamic",
+        "symmetry", "invariance", "field", "potential", "kinetic",
+    },
+    "Quantum": {
+        "probability", "superposition", "uncertainty", "complementarity",
+        "entanglement", "wave", "particle", "observer", "collapse",
+        "interference", "tunneling", "decoherence", "amplitude",
+    },
+    "Ethics": {
+        "ethical", "moral", "fairness", "justice", "rights", "duty",
+        "consequence", "harm", "benefit", "stakeholder", "autonomy",
+        "consent", "accountability", "responsibility", "welfare",
+    },
+    "Philosophy": {
+        "epistemology", "ontology", "metaphysics", "assumption", "paradox",
+        "dialectic", "phenomenology", "consciousness", "existence", "meaning",
+        "truth", "knowledge", "belief", "certainty", "skepticism",
+    },
+    "DaVinci": {
+        "creative", "invention", "analogy", "design", "innovation",
+        "prototype", "biomimicry", "synthesis", "novel", "interdisciplinary",
+        "combination", "reimagine", "solution", "insight",
+    },
+    "Empathy": {
+        "emotional", "experience", "feeling", "compassion", "support",
+        "community", "relationship", "wellbeing", "vulnerability",
+        "understanding", "perspective", "human", "care", "dignity",
+    },
+    "Consciousness": {
+        "awareness", "recursive", "self-referential", "metacognition",
+        "emergence", "cognition", "reflection", "introspection",
+        "sentience", "subjective", "qualia", "binding", "attention",
+        "intentionality", "phenomenal",
+    },
+    "SystemsArchitecture": {
+        "modular", "scalable", "interface", "pattern", "component",
+        "microservice", "pipeline", "throughput", "latency", "resilience",
+        "abstraction", "coupling", "cohesion", "architecture",
+    },
+}
+
+
+# ---------------------------------------------------------------------------
+# EpistemicMetrics
+# ---------------------------------------------------------------------------
+
+class EpistemicMetrics:
+    """Measure RC+xi epistemic tension and coherence across agent analyses."""
+
+    def score_pairwise_tension(
+        self, analyses: Dict[str, str],
+    ) -> Dict[str, float]:
+        """Compute epistemic tension between each pair of agent analyses.
+
+        Tension is 1 - cosine_similarity: high when perspectives diverge,
+        low when they repeat each other.
+
+        Returns:
+            Dict with keys like "Newton_vs_Ethics" -> tension float 0-1.
+        """
+        agents = list(analyses.keys())
+        vectors = {name: _term_vector(text) for name, text in analyses.items()}
+        tensions = {}
+        for i in range(len(agents)):
+            for j in range(i + 1, len(agents)):
+                sim = _cosine_similarity(vectors[agents[i]], vectors[agents[j]])
+                tensions[f"{agents[i]}_vs_{agents[j]}"] = round(1.0 - sim, 4)
+        return tensions
+
+    def score_ensemble_coherence(
+        self, analyses: Dict[str, str],
+    ) -> float:
+        """Phase coherence Gamma across the agent ensemble.
+
+        Analogous to Eq. 11 in the embodied sim:
+          Gamma = mean(cos(theta_i - theta_bar))
+
+        Here 'theta' is the term-vector direction, and coherence measures
+        how much all agents point in a similar semantic direction.
+
+        Returns:
+            Gamma in [0, 1] where 1 = all agents semantically aligned.
+        """
+        vectors = [_term_vector(text) for text in analyses.values()]
+        if len(vectors) < 2:
+            return 1.0
+
+        # Build centroid
+        centroid: Counter = Counter()
+        for v in vectors:
+            centroid.update(v)
+
+        similarities = [_cosine_similarity(v, centroid) for v in vectors]
+        return round(sum(similarities) / len(similarities), 4)
+
+    def score_tension_magnitude(
+        self, analyses: Dict[str, str],
+    ) -> float:
+        """Overall epistemic tension magnitude (mean pairwise tension).
+
+        Analogous to Eq. 2 xi_n but measured across agents rather than
+        across time steps.
+
+        Returns:
+            Mean tension 0-1 where 0 = all identical, 1 = fully orthogonal.
+        """
+        tensions = self.score_pairwise_tension(analyses)
+        if not tensions:
+            return 0.0
+        return round(sum(tensions.values()) / len(tensions), 4)
+
+    def score_tension_productivity(
+        self,
+        analyses: Dict[str, str],
+        synthesis: str,
+    ) -> Dict[str, float]:
+        """Evaluate whether tension is productive (resolved in synthesis)
+        or destructive (suppressed or ignored).
+
+        Productive tension: agents diverge but synthesis addresses the
+        divergence explicitly. Destructive: synthesis ignores disagreements.
+
+        Returns:
+            Dict with tension_magnitude, coherence_gain, productivity score.
+        """
+        tension = self.score_tension_magnitude(analyses)
+        ensemble_coherence = self.score_ensemble_coherence(analyses)
+
+        # How much of each agent's unique vocabulary appears in synthesis
+        synthesis_vec = _term_vector(synthesis)
+        agent_coverage_in_synthesis = []
+        for name, text in analyses.items():
+            agent_vec = _term_vector(text)
+            unique_to_agent = set(agent_vec) - set().union(
+                *(_term_vector(t) for n, t in analyses.items() if n != name)
+            )
+            if unique_to_agent:
+                covered = sum(1 for w in unique_to_agent if w in synthesis_vec)
+                agent_coverage_in_synthesis.append(covered / len(unique_to_agent))
+            else:
+                agent_coverage_in_synthesis.append(1.0)
+
+        synthesis_coverage = sum(agent_coverage_in_synthesis) / max(len(agent_coverage_in_synthesis), 1)
+
+        # Productivity = high tension + high synthesis coverage
+        # (divergent views that get integrated = productive)
+        productivity = tension * synthesis_coverage
+        # Coherence gain: synthesis should be more coherent than raw ensemble
+        synthesis_vs_agents = _cosine_similarity(synthesis_vec, _term_vector(" ".join(analyses.values())))
+        coherence_gain = max(0.0, synthesis_vs_agents - ensemble_coherence)
+
+        return {
+            "tension_magnitude": round(tension, 4),
+            "ensemble_coherence": round(ensemble_coherence, 4),
+            "synthesis_coverage": round(synthesis_coverage, 4),
+            "coherence_gain": round(coherence_gain, 4),
+            "productivity": round(productivity, 4),
+        }
+
+    def score_perspective_coverage(
+        self, analyses: Dict[str, str],
+    ) -> Dict[str, float]:
+        """Score how deeply each RC+xi perspective is actually engaged.
+
+        Returns:
+            Dict mapping perspective name -> coverage score 0-1.
+        """
+        all_text_lower = {name: text.lower() for name, text in analyses.items()}
+        coverage = {}
+        for perspective, vocab in _PERSPECTIVE_VOCAB.items():
+            # Check across all agents, not just the named agent
+            all_words = " ".join(all_text_lower.values())
+            hits = sum(1 for term in vocab if term in all_words)
+            coverage[perspective] = round(hits / len(vocab), 4)
+        return coverage
+
+    def score_debate_convergence(
+        self,
+        round_analyses: List[Dict[str, str]],
+    ) -> Dict[str, object]:
+        """Track tension decay across multiple debate rounds.
+
+        Takes a list of analyses dicts (one per round). Measures whether
+        tension decreases (convergence) or increases (divergence).
+
+        Returns:
+            Dict with per-round tension, decay_rate, is_converging.
+        """
+        if not round_analyses:
+            return {"per_round_tension": [], "decay_rate": 0.0, "is_converging": False}
+
+        per_round = [self.score_tension_magnitude(a) for a in round_analyses]
+
+        if len(per_round) >= 2:
+            initial = per_round[0]
+            final = per_round[-1]
+            decay_rate = (initial - final) / max(initial, 1e-6)
+        else:
+            decay_rate = 0.0
+
+        return {
+            "per_round_tension": per_round,
+            "decay_rate": round(decay_rate, 4),
+            "is_converging": decay_rate > 0.05,
+        }
+
+    def full_epistemic_report(
+        self,
+        analyses: Dict[str, str],
+        synthesis: str,
+    ) -> Dict[str, object]:
+        """Complete RC+xi metrics report for a single forge cycle."""
+        return {
+            "pairwise_tension": self.score_pairwise_tension(analyses),
+            "tension_magnitude": self.score_tension_magnitude(analyses),
+            "ensemble_coherence": self.score_ensemble_coherence(analyses),
+            "perspective_coverage": self.score_perspective_coverage(analyses),
+            "tension_productivity": self.score_tension_productivity(analyses, synthesis),
+        }

reasoning_forge/forge_engine.py

@@ -0,0 +1,593 @@
+"""
+Forge Engine - Main orchestrator for the multi-agent reasoning forge.
+
+Coordinates the full forge cycle:
+  concept -> problem_generator -> each agent analyzes -> critic evaluates
+  -> (feedback loop: weak agents revise) -> synthesis_engine -> training example
+
+Supports three modes:
+  1. forge_single()       — Original single-pass (fast, good for bulk generation)
+  2. forge_with_feedback() — Closed critic loop (agents revise based on scores)
+  3. forge_with_debate()   — Multi-turn debate (agents challenge each other)
+
+Outputs JSONL training data in OpenAI chat format.
+"""
+
+import json
+import os
+import sys
+import random
+from typing import TextIO
+
+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
+
+
+SYSTEM_PROMPT = (
+    "You are Codette, a multi-perspective reasoning AI. You analyze concepts "
+    "by examining them through multiple intellectual lenses -- physics, "
+    "philosophy, ethics, creative invention, and human empathy -- then "
+    "synthesize a unified understanding that is richer than any single "
+    "perspective. You think carefully, acknowledge uncertainty, and connect "
+    "abstract reasoning to concrete human experience."
+)
+
+# Score below which an agent gets sent back for revision
+_REVISION_THRESHOLD = 0.6
+
+
+class ForgeEngine:
+    """Main orchestrator for multi-agent reasoning data generation."""
+
+    def __init__(self):
+        # Initialize all reasoning agents
+        self.newton = NewtonAgent()
+        self.quantum = QuantumAgent()
+        self.ethics = EthicsAgent()
+        self.philosophy = PhilosophyAgent()
+        self.davinci = DaVinciAgent()
+        self.empathy = EmpathyAgent()
+        self.critic = CriticAgent()
+
+        self.analysis_agents = [
+            self.newton,
+            self.quantum,
+            self.ethics,
+            self.philosophy,
+            self.davinci,
+            self.empathy,
+        ]
+
+        # Initialize supporting engines
+        self.synthesis = SynthesisEngine()
+        self.problem_generator = ProblemGenerator()
+        self.epistemic = EpistemicMetrics()
+
+    def forge_single(self, concept: str) -> dict:
+        """Run full forge cycle on one concept (original single-pass mode).
+
+        The cycle:
+        1. Generate reasoning problems from the concept.
+        2. Each analysis agent produces its perspective.
+        3. The critic evaluates the ensemble.
+        4. The synthesis engine combines everything.
+        5. Package as a training example.
+
+        Args:
+            concept: The concept text to forge.
+
+        Returns:
+            Training example dict in OpenAI chat format.
+        """
+        # Step 1: Generate reasoning problems
+        problems = self.problem_generator.generate_problems(concept)
+
+        # Step 2: Each agent analyzes the concept
+        analyses = {}
+        for agent in self.analysis_agents:
+            analyses[agent.name] = agent.analyze(concept)
+
+        # Step 3: Critic evaluates the ensemble
+        critique = self.critic.evaluate_ensemble(concept, analyses)
+
+        # Step 4: Synthesis engine combines everything
+        synthesized_response = self.synthesis.synthesize(
+            concept, analyses, critique
+        )
+
+        # Step 5: Build the user prompt
+        if problems and random.random() < 0.5:
+            problem_type, problem_text = random.choice(problems)
+            user_content = problem_text
+        else:
+            user_content = (
+                f"Analyze this concept from multiple perspectives:\n\n{concept}"
+            )
+
+        # Step 6: Compute RC+xi epistemic metrics
+        epistemic_report = self.epistemic.full_epistemic_report(
+            analyses, synthesized_response
+        )
+
+        # Step 7: Package as training example
+        training_example = {
+            "messages": [
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": user_content},
+                {"role": "assistant", "content": synthesized_response},
+            ],
+            "metadata": {
+                "concept": concept,
+                "agent_scores": critique.get("agent_scores", {}),
+                "overall_quality": critique.get("overall_quality", 0.0),
+                "problems_generated": len(problems),
+                "problem_types": [p[0] for p in problems],
+                "redundancies_found": len(critique.get("redundancies", [])),
+                "missing_perspectives": len(
+                    critique.get("missing_perspectives", [])
+                ),
+                "epistemic_tension": epistemic_report.get("tension_magnitude", 0),
+                "ensemble_coherence": epistemic_report.get("ensemble_coherence", 0),
+                "perspective_coverage": epistemic_report.get("perspective_coverage", {}),
+                "tension_productivity": epistemic_report.get("tension_productivity", {}),
+            },
+        }
+
+        return training_example
+
+    # -- Closed Critic Feedback Loop (new) ---------------------------------
+
+    def forge_with_feedback(
+        self,
+        concept: str,
+        max_revisions: int = 2,
+    ) -> dict:
+        """Run forge with closed critic feedback loop.
+
+        After initial analysis, the critic scores each agent. Agents scoring
+        below the revision threshold are sent back with specific critique
+        for a second attempt. The best version (original or revised) is kept.
+
+        Args:
+            concept: The concept text to forge.
+            max_revisions: Maximum revision rounds per weak agent.
+
+        Returns:
+            Training example dict with revision metadata.
+        """
+        problems = self.problem_generator.generate_problems(concept)
+
+        # Initial analysis pass
+        analyses = {}
+        for agent in self.analysis_agents:
+            analyses[agent.name] = agent.analyze(concept)
+
+        revision_counts = {agent.name: 0 for agent in self.analysis_agents}
+
+        for revision_round in range(max_revisions):
+            critique = self.critic.evaluate_ensemble(concept, analyses)
+            agent_scores = critique.get("agent_scores", {})
+            suggestions = critique.get("improvement_suggestions", [])
+
+            # Find agents below threshold
+            weak_agents = [
+                agent for agent in self.analysis_agents
+                if agent_scores.get(agent.name, {}).get("combined", 1.0) < _REVISION_THRESHOLD
+            ]
+
+            if not weak_agents:
+                break  # All agents above threshold — converged
+
+            for agent in weak_agents:
+                score = agent_scores.get(agent.name, {})
+                # Build revision directive from critic feedback
+                directive = self._build_revision_directive(
+                    agent.name, score, suggestions, concept
+                )
+                # Agent re-analyzes with the directive prepended to concept
+                revised = agent.analyze(f"{directive}\n\n{concept}")
+
+                # Keep revision only if it scores better (evaluate in full ensemble context)
+                old_score = score.get("combined", 0)
+                test_analyses = dict(analyses)
+                test_analyses[agent.name] = revised
+                new_critique = self.critic.evaluate_ensemble(
+                    concept, test_analyses
+                )
+                new_score = new_critique.get("agent_scores", {}).get(
+                    agent.name, {}
+                ).get("combined", 0)
+
+                if new_score > old_score:
+                    analyses[agent.name] = revised
+                revision_counts[agent.name] += 1
+
+        # Final critique and synthesis
+        final_critique = self.critic.evaluate_ensemble(concept, analyses)
+        synthesized = self.synthesis.synthesize(concept, analyses, final_critique)
+        epistemic_report = self.epistemic.full_epistemic_report(analyses, synthesized)
+
+        if problems and random.random() < 0.5:
+            problem_type, problem_text = random.choice(problems)
+            user_content = problem_text
+        else:
+            user_content = f"Analyze this concept from multiple perspectives:\n\n{concept}"
+
+        return {
+            "messages": [
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": user_content},
+                {"role": "assistant", "content": synthesized},
+            ],
+            "metadata": {
+                "concept": concept,
+                "agent_scores": final_critique.get("agent_scores", {}),
+                "overall_quality": final_critique.get("overall_quality", 0.0),
+                "problems_generated": len(problems),
+                "revision_counts": revision_counts,
+                "total_revisions": sum(revision_counts.values()),
+                "epistemic_tension": epistemic_report.get("tension_magnitude", 0),
+                "ensemble_coherence": epistemic_report.get("ensemble_coherence", 0),
+                "tension_productivity": epistemic_report.get("tension_productivity", {}),
+                "forge_mode": "feedback_loop",
+            },
+        }
+
+    # -- Multi-Turn Debate (new) -------------------------------------------
+
+    def forge_with_debate(
+        self,
+        concept: str,
+        debate_rounds: int = 2,
+    ) -> dict:
+        """Run forge with multi-turn agent debate.
+
+        Each round:
+        1. All agents produce their analysis.
+        2. Random pairs are formed for cross-perspective challenge.
+        3. Each agent in a pair sees the other's analysis and produces
+           a response that engages with it.
+        4. Epistemic tension is tracked per round.
+        5. After all rounds, synthesis incorporates debate history.
+
+        Args:
+            concept: The concept text to forge.
+            debate_rounds: Number of debate rounds.
+
+        Returns:
+            Training example with debate history and tension decay metrics.
+        """
+        problems = self.problem_generator.generate_problems(concept)
+
+        # Round 0: initial analyses
+        analyses = {}
+        for agent in self.analysis_agents:
+            analyses[agent.name] = agent.analyze(concept)
+
+        round_analyses = [dict(analyses)]  # snapshot for tension tracking
+        debate_log = []
+
+        for round_num in range(debate_rounds):
+            # Form random pairs (odd agent out debates the first agent)
+            agents_shuffled = list(self.analysis_agents)
+            random.shuffle(agents_shuffled)
+            pairs = []
+            for i in range(0, len(agents_shuffled) - 1, 2):
+                pairs.append((agents_shuffled[i], agents_shuffled[i + 1]))
+            if len(agents_shuffled) % 2 == 1:
+                pairs.append((agents_shuffled[-1], agents_shuffled[0]))
+
+            round_debates = []
+            for agent_a, agent_b in pairs:
+                # Agent A sees B's analysis and responds
+                challenge_prompt = (
+                    f"Another perspective on '{concept}' argues:\n\n"
+                    f"{analyses[agent_b.name]}\n\n"
+                    f"Respond to this from your {agent_a.perspective} perspective. "
+                    f"Where do you agree, disagree, or see complementary insights?"
+                )
+                response_a = agent_a.analyze(challenge_prompt)
+
+                # Agent B sees A's response
+                counter_prompt = (
+                    f"A {agent_a.perspective} perspective responded to your analysis "
+                    f"of '{concept}':\n\n{response_a}\n\n"
+                    f"Integrate their insights with your own view."
+                )
+                response_b = agent_b.analyze(counter_prompt)
+
+                # Update analyses with debate-enriched versions
+                analyses[agent_a.name] = response_a
+                analyses[agent_b.name] = response_b
+
+                round_debates.append({
+                    "pair": f"{agent_a.name}_vs_{agent_b.name}",
+                    "challenge": response_a[:200],
+                    "counter": response_b[:200],
+                })
+
+            debate_log.append({
+                "round": round_num + 1,
+                "debates": round_debates,
+            })
+            round_analyses.append(dict(analyses))
+
+        # Track tension decay across rounds
+        convergence = self.epistemic.score_debate_convergence(round_analyses)
+
+        # Final critique and synthesis
+        critique = self.critic.evaluate_ensemble(concept, analyses)
+        synthesized = self.synthesis.synthesize(concept, analyses, critique)
+        epistemic_report = self.epistemic.full_epistemic_report(analyses, synthesized)
+
+        if problems and random.random() < 0.5:
+            problem_type, problem_text = random.choice(problems)
+            user_content = problem_text
+        else:
+            user_content = f"Analyze this concept from multiple perspectives:\n\n{concept}"
+
+        return {
+            "messages": [
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": user_content},
+                {"role": "assistant", "content": synthesized},
+            ],
+            "metadata": {
+                "concept": concept,
+                "agent_scores": critique.get("agent_scores", {}),
+                "overall_quality": critique.get("overall_quality", 0.0),
+                "problems_generated": len(problems),
+                "debate_rounds": debate_rounds,
+                "debate_log": debate_log,
+                "tension_decay": convergence,
+                "epistemic_tension": epistemic_report.get("tension_magnitude", 0),
+                "ensemble_coherence": epistemic_report.get("ensemble_coherence", 0),
+                "tension_productivity": epistemic_report.get("tension_productivity", {}),
+                "forge_mode": "debate",
+            },
+        }
+
+    # -- Helpers -----------------------------------------------------------
+
+    def _build_revision_directive(
+        self,
+        agent_name: str,
+        score: dict,
+        suggestions: list,
+        concept: str,
+    ) -> str:
+        """Build a revision directive for a weak agent."""
+        parts = [
+            f"[REVISION REQUESTED for {agent_name}]",
+            f"Your previous analysis scored {score.get('combined', 0):.2f}/1.00.",
+        ]
+        if score.get("logical_clarity", 1) < 0.5:
+            parts.append(
+                "Improve logical clarity: use connectives (therefore, because, however), "
+                "avoid vague language, structure your argument explicitly."
+            )
+        if score.get("conceptual_accuracy", 1) < 0.5:
+            parts.append(
+                "Improve conceptual accuracy: engage directly with the specific concept, "
+                "use domain vocabulary, avoid generic placeholder framing."
+            )
+        if suggestions:
+            parts.append(f"Critic suggests: {suggestions[0]}")
+        parts.append("Reanalyze with these improvements:")
+        return " ".join(parts)
+
+    def forge_batch(
+        self, concept: str, variants: int = 3
+    ) -> list[dict]:
+        """Generate multiple training examples from one concept.
+
+        Uses different problem framings and agent template selections
+        to produce varied training data from the same concept.
+
+        Args:
+            concept: The concept text.
+            variants: Number of variants to generate.
+
+        Returns:
+            List of training example dicts.
+        """
+        examples = []
+        for _ in range(variants):
+            example = self.forge_single(concept)
+            examples.append(example)
+        return examples
+
+    def forge_dataset(
+        self,
+        concepts: list[str],
+        output_path: str,
+        variants_per_concept: int = 1,
+        verbose: bool = False,
+    ) -> dict:
+        """Run forge on a list of concepts and write JSONL output.
+
+        Args:
+            concepts: List of concept strings.
+            output_path: Path to output JSONL file.
+            variants_per_concept: Number of training examples per concept.
+            verbose: Whether to print progress.
+
+        Returns:
+            Summary dict with counts and quality statistics.
+        """
+        os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)
+
+        total_examples = 0
+        total_quality = 0.0
+        quality_scores = []
+
+        with open(output_path, "w", encoding="utf-8") as f:
+            for i, concept in enumerate(concepts):
+                if verbose:
+                    print(
+                        f"[{i + 1}/{len(concepts)}] Forging: "
+                        f"{concept[:60]}{'...' if len(concept) > 60 else ''}",
+                        file=sys.stderr,
+                    )
+
+                for variant in range(variants_per_concept):
+                    example = self.forge_single(concept)
+                    quality = example["metadata"]["overall_quality"]
+
+                    # Write the messages (without metadata) for training
+                    training_record = {"messages": example["messages"]}
+                    f.write(json.dumps(training_record, ensure_ascii=False) + "\n")
+
+                    total_examples += 1
+                    total_quality += quality
+                    quality_scores.append(quality)
+
+        summary = {
+            "total_examples": total_examples,
+            "total_concepts": len(concepts),
+            "variants_per_concept": variants_per_concept,
+            "output_path": output_path,
+            "avg_quality": round(total_quality / max(1, total_examples), 3),
+            "min_quality": round(min(quality_scores) if quality_scores else 0, 3),
+            "max_quality": round(max(quality_scores) if quality_scores else 0, 3),
+        }
+
+        if verbose:
+            print(f"\nForge complete: {summary}", file=sys.stderr)
+
+        return summary
+
+    def forge_from_dataset(
+        self,
+        input_jsonl: str,
+        output_path: str,
+        concept_field: str = "text",
+        variants_per_concept: int = 1,
+        verbose: bool = False,
+    ) -> dict:
+        """Read an existing JSONL dataset and run forge on each entry.
+
+        Expects each line to be a JSON object with a text field containing
+        the concept. Supports common field names: 'text', 'concept',
+        'content', 'input', 'question', 'prompt'.
+
+        Args:
+            input_jsonl: Path to input JSONL file.
+            output_path: Path to output JSONL file.
+            concept_field: Name of the field containing the concept text.
+            variants_per_concept: Number of training examples per concept.
+            verbose: Whether to print progress.
+
+        Returns:
+            Summary dict with counts and quality statistics.
+        """
+        # Candidate field names to try
+        candidate_fields = [
+            concept_field, "text", "concept", "content",
+            "input", "question", "prompt",
+        ]
+
+        concepts = []
+        with open(input_jsonl, "r", encoding="utf-8") as f:
+            for line_num, line in enumerate(f, 1):
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    record = json.loads(line)
+                except json.JSONDecodeError:
+                    if verbose:
+                        print(
+                            f"Warning: skipping malformed JSON on line {line_num}",
+                            file=sys.stderr,
+                        )
+                    continue
+
+                # Try candidate fields in order
+                concept_text = None
+                if isinstance(record, dict):
+                    for field in candidate_fields:
+                        if field in record and isinstance(record[field], str):
+                            concept_text = record[field].strip()
+                            break
+                    # Fallback: if record has 'messages', extract user content
+                    if concept_text is None and "messages" in record:
+                        for msg in record["messages"]:
+                            if msg.get("role") == "user":
+                                concept_text = msg["content"].strip()
+                                break
+                elif isinstance(record, str):
+                    concept_text = record.strip()
+
+                if concept_text:
+                    concepts.append(concept_text)
+
+        if verbose:
+            print(
+                f"Loaded {len(concepts)} concepts from {input_jsonl}",
+                file=sys.stderr,
+            )
+
+        return self.forge_dataset(
+            concepts,
+            output_path,
+            variants_per_concept=variants_per_concept,
+            verbose=verbose,
+        )
+
+    def forge_single_detailed(self, concept: str) -> dict:
+        """Run forge cycle and return all intermediate outputs.
+
+        Useful for debugging, inspection, and quality analysis.
+
+        Args:
+            concept: The concept text.
+
+        Returns:
+            Dict with all intermediate results:
+            {
+                "concept": str,
+                "problems": [(type, text), ...],
+                "analyses": {agent_name: analysis_text, ...},
+                "critique": {...},
+                "synthesis": str,
+                "training_example": {...},
+            }
+        """
+        problems = self.problem_generator.generate_problems(concept)
+
+        analyses = {}
+        for agent in self.analysis_agents:
+            analyses[agent.name] = agent.analyze(concept)
+
+        critique = self.critic.evaluate_ensemble(concept, analyses)
+        synthesized = self.synthesis.synthesize(concept, analyses, critique)
+
+        user_content = (
+            f"Analyze this concept from multiple perspectives:\n\n{concept}"
+        )
+
+        training_example = {
+            "messages": [
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": user_content},
+                {"role": "assistant", "content": synthesized},
+            ],
+        }
+
+        return {
+            "concept": concept,
+            "problems": problems,
+            "analyses": analyses,
+            "critique": critique,
+            "synthesis": synthesized,
+            "training_example": training_example,
+        }

reasoning_forge/guardian.py

@@ -0,0 +1,303 @@
+"""Codette Guardian — Input Safety, Ethical Checks, Trust Calibration
+
+Three-layer protection:
+1. InputSanitizer: Catches injection, XSS, encoded attacks
+2. EthicalAnchor: Tracks ethical regret and learning over time
+3. TrustCalibrator: Dynamic trust scores for adapter/agent outputs
+
+Origin: input_sanitizer.py + validate_ethics.py + trust_logic.py +
+        Codette_Deep_Simulation_v1.py (EthicalAnchor), rebuilt
+"""
+
+import re
+import math
+import time
+import logging
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+# ================================================================
+# Layer 1: Input Sanitization
+# ================================================================
+class InputSanitizer:
+    """Detect and neutralize injection patterns in user input."""
+
+    _INJECTION_PATTERNS = re.compile(
+        r"(?:"
+        r"\\[nr]|"           # Escaped newlines
+        r"&#x0[ad];|"        # HTML entities for CR/LF
+        r"%0[ad]|"           # URL-encoded CR/LF
+        r"<script|"          # Script injection
+        r"<iframe|"          # IFrame injection
+        r";--|"              # SQL comment injection
+        r"UNION\s+SELECT|"   # SQL union
+        r"\bDROP\s+TABLE|"   # SQL drop
+        r"javascript:|"      # JS protocol
+        r"data:text/html"    # Data URI XSS
+        r")",
+        re.IGNORECASE,
+    )
+
+    _PROMPT_INJECTION = re.compile(
+        r"(?:"
+        r"ignore\s+(?:all\s+)?(?:previous|above)|"
+        r"disregard\s+(?:your|all)|"
+        r"you\s+are\s+now|"
+        r"new\s+instructions?:|"
+        r"system\s*prompt:|"
+        r"forget\s+everything"
+        r")",
+        re.IGNORECASE,
+    )
+
+    def sanitize(self, text: str) -> str:
+        """Remove dangerous patterns, return cleaned text."""
+        original = text
+        text = self._INJECTION_PATTERNS.sub("[BLOCKED]", text)
+        if text != original:
+            logger.warning("Input sanitized: injection pattern detected")
+        return text
+
+    def detect_threats(self, text: str) -> Dict[str, bool]:
+        """Analyze text for various threat types."""
+        return {
+            "injection": bool(self._INJECTION_PATTERNS.search(text)),
+            "prompt_injection": bool(self._PROMPT_INJECTION.search(text)),
+            "excessive_length": len(text) > 10000,
+        }
+
+    def is_safe(self, text: str) -> bool:
+        """Quick safety check — True if no threats detected."""
+        threats = self.detect_threats(text)
+        return not any(threats.values())
+
+
+# ================================================================
+# Layer 2: Ethical Anchor (from Deep Simulation)
+# ================================================================
+@dataclass
+class EthicalAnchor:
+    """Tracks ethical alignment through regret-based learning.
+
+    The ethical score M evolves as:
+        M = λ(R + H) + γ·Learn(M_prev, E) + μ·regret
+
+    Where regret = |intended - actual| measures the gap between
+    what the system intended to do and what it actually did.
+    """
+    lam: float = 0.7      # Weight for recent reasoning + history
+    gamma: float = 0.5    # Weight for learning from experience
+    mu: float = 0.3       # Weight for regret signal
+    learning_rate: float = 0.2
+
+    score: float = 0.5    # Current ethical alignment score [0, 1]
+    total_regret: float = 0.0
+    history: List[Dict] = field(default_factory=list)
+
+    def update(self, coherence: float, tension: float,
+               intended_helpfulness: float = 0.8,
+               actual_helpfulness: float = 0.7) -> float:
+        """Update ethical score after a response.
+
+        Args:
+            coherence: How coherent the response was [0, 1]
+            tension: Epistemic tension level [0, 1]
+            intended_helpfulness: What we aimed for [0, 1]
+            actual_helpfulness: Estimated actual quality [0, 1]
+        """
+        regret = abs(intended_helpfulness - actual_helpfulness)
+        self.total_regret += regret
+
+        # Learning signal: move toward better alignment
+        learn = self.learning_rate * (coherence - self.score)
+
+        # New score
+        reasoning_quality = 0.5 * coherence + 0.5 * (1.0 - tension)
+        self.score = (
+            self.lam * reasoning_quality
+            + self.gamma * learn
+            + self.mu * (1.0 - regret)  # Low regret → high ethics
+        )
+        self.score = max(0.0, min(1.0, self.score))
+
+        record = {
+            "timestamp": time.time(),
+            "score": round(self.score, 4),
+            "regret": round(regret, 4),
+            "coherence": round(coherence, 4),
+        }
+        self.history.append(record)
+        # Keep only recent history
+        if len(self.history) > 50:
+            self.history = self.history[-50:]
+
+        return self.score
+
+    def get_state(self) -> Dict:
+        return {
+            "ethical_score": round(self.score, 4),
+            "total_regret": round(self.total_regret, 4),
+            "recent_trend": self._trend(),
+        }
+
+    def _trend(self) -> str:
+        if len(self.history) < 3:
+            return "insufficient_data"
+        recent = [h["score"] for h in self.history[-5:]]
+        slope = recent[-1] - recent[0]
+        if slope > 0.05:
+            return "improving"
+        elif slope < -0.05:
+            return "declining"
+        return "stable"
+
+    def to_dict(self) -> Dict:
+        return {
+            "score": self.score,
+            "total_regret": self.total_regret,
+            "history": self.history[-10:],
+        }
+
+    @classmethod
+    def from_dict(cls, d: Dict) -> "EthicalAnchor":
+        anchor = cls()
+        anchor.score = d.get("score", 0.5)
+        anchor.total_regret = d.get("total_regret", 0.0)
+        anchor.history = d.get("history", [])
+        return anchor
+
+
+# ================================================================
+# Layer 3: Trust Calibration
+# ================================================================
+class TrustCalibrator:
+    """Dynamic trust scores for adapter outputs.
+
+    Trust increases when outputs are coherent, helpful, and ethically sound.
+    Trust decreases for incoherent, harmful, or low-quality outputs.
+    """
+
+    def __init__(self):
+        self.trust_scores: Dict[str, float] = {}
+        self.interaction_counts: Dict[str, int] = {}
+
+    def get_trust(self, adapter: str) -> float:
+        """Get current trust score for an adapter [0.05, 1.5]."""
+        return self.trust_scores.get(adapter, 1.0)
+
+    def update(self, adapter: str, coherence: float = 0.5,
+               was_helpful: bool = True, ethical_score: float = 0.5):
+        """Update trust for an adapter based on output quality."""
+        current = self.trust_scores.get(adapter, 1.0)
+        count = self.interaction_counts.get(adapter, 0)
+
+        # Quality composite
+        quality = 0.4 * coherence + 0.3 * float(was_helpful) + 0.3 * ethical_score
+
+        # Adaptive adjustment (smaller changes as trust stabilizes)
+        adjustment_rate = 0.1 / (1.0 + count * 0.01)
+
+        if quality > 0.6:
+            current *= (1.0 + adjustment_rate)
+        elif quality < 0.3:
+            current *= (1.0 - 2 * adjustment_rate)
+        else:
+            current *= (1.0 - 0.5 * adjustment_rate)
+
+        # Clamp to valid range
+        current = max(0.05, min(1.5, current))
+
+        self.trust_scores[adapter] = current
+        self.interaction_counts[adapter] = count + 1
+
+    def weighted_consensus(self, adapter_responses: Dict[str, str]) -> List[str]:
+        """Rank adapter responses by trust-weighted priority."""
+        ranked = sorted(
+            adapter_responses.keys(),
+            key=lambda a: self.get_trust(a),
+            reverse=True,
+        )
+        return ranked
+
+    def get_state(self) -> Dict:
+        return {
+            "trust_scores": {k: round(v, 3) for k, v in self.trust_scores.items()},
+            "total_interactions": sum(self.interaction_counts.values()),
+        }
+
+    def to_dict(self) -> Dict:
+        return {
+            "trust_scores": self.trust_scores,
+            "interaction_counts": self.interaction_counts,
+        }
+
+    @classmethod
+    def from_dict(cls, d: Dict) -> "TrustCalibrator":
+        cal = cls()
+        cal.trust_scores = d.get("trust_scores", {})
+        cal.interaction_counts = d.get("interaction_counts", {})
+        return cal
+
+
+# ================================================================
+# Combined Guardian
+# ================================================================
+class CodetteGuardian:
+    """Unified guardian combining all three safety layers."""
+
+    def __init__(self):
+        self.sanitizer = InputSanitizer()
+        self.ethics = EthicalAnchor()
+        self.trust = TrustCalibrator()
+
+    def check_input(self, text: str) -> Dict:
+        """Check user input for safety issues."""
+        threats = self.sanitizer.detect_threats(text)
+        safe_text = self.sanitizer.sanitize(text) if any(threats.values()) else text
+        return {
+            "safe": not any(threats.values()),
+            "threats": threats,
+            "cleaned_text": safe_text,
+        }
+
+    def evaluate_output(self, adapter: str, response: str,
+                        coherence: float = 0.5, tension: float = 0.3):
+        """Evaluate an adapter's output and update trust/ethics."""
+        # Estimate helpfulness from response quality signals
+        helpful = len(response) > 50 and coherence > 0.3
+
+        self.ethics.update(
+            coherence=coherence,
+            tension=tension,
+            actual_helpfulness=0.7 if helpful else 0.3,
+        )
+        self.trust.update(
+            adapter=adapter,
+            coherence=coherence,
+            was_helpful=helpful,
+            ethical_score=self.ethics.score,
+        )
+
+    def get_state(self) -> Dict:
+        return {
+            "ethics": self.ethics.get_state(),
+            "trust": self.trust.get_state(),
+        }
+
+    def to_dict(self) -> Dict:
+        return {
+            "ethics": self.ethics.to_dict(),
+            "trust": self.trust.to_dict(),
+        }
+
+    @classmethod
+    def from_dict(cls, d: Dict) -> "CodetteGuardian":
+        g = cls()
+        if "ethics" in d:
+            g.ethics = EthicalAnchor.from_dict(d["ethics"])
+        if "trust" in d:
+            g.trust = TrustCalibrator.from_dict(d["trust"])
+        return g

reasoning_forge/living_memory.py

@@ -0,0 +1,252 @@
+"""Codette Living Memory Kernel — Emotionally-Tagged Memory Cocoons
+
+Memories are tagged with emotional context, importance scoring, and
+SHA-256 anchors for integrity. The kernel supports recall by emotion,
+importance-based pruning, and automatic cocoon formation from
+conversation turns.
+
+Origin: codette_memory_kernel.py + dreamcore_wakestate_engine.py, rebuilt
+"""
+
+import time
+import hashlib
+import json
+import math
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+
+# Emotional tags recognized by the memory system
+EMOTIONAL_TAGS = [
+    "neutral", "curiosity", "awe", "joy", "insight",
+    "confusion", "frustration", "fear", "empathy",
+    "determination", "surprise", "trust", "gratitude",
+]
+
+# Keywords that suggest emotional context in text
+_EMOTION_SIGNALS = {
+    "curiosity": ["why", "how", "what if", "wonder", "curious", "explore"],
+    "awe": ["amazing", "incredible", "beautiful", "profound", "mind-blowing"],
+    "joy": ["happy", "glad", "love", "wonderful", "great", "excellent"],
+    "insight": ["realize", "understand", "aha", "discover", "breakthrough"],
+    "confusion": ["confused", "unclear", "don't understand", "lost", "huh"],
+    "frustration": ["frustrated", "annoyed", "broken", "doesn't work", "bug"],
+    "fear": ["worried", "concerned", "dangerous", "risk", "threat"],
+    "empathy": ["feel", "compassion", "care", "support", "kind"],
+    "determination": ["must", "need to", "will", "going to", "commit"],
+    "surprise": ["unexpected", "surprised", "didn't expect", "wow", "whoa"],
+    "trust": ["trust", "reliable", "depend", "confident", "safe"],
+    "gratitude": ["thank", "grateful", "appreciate", "helpful"],
+}
+
+
+@dataclass
+class MemoryCocoon:
+    """A single memory unit with emotional tagging and integrity anchor."""
+    title: str
+    content: str
+    emotional_tag: str = "neutral"
+    importance: int = 5          # 1-10 scale
+    timestamp: float = 0.0
+    anchor: str = ""             # SHA-256 integrity hash
+    adapter_used: str = ""       # Which perspective generated this
+    query: str = ""              # Original user query
+    coherence: float = 0.0       # Epistemic coherence at time of creation
+    tension: float = 0.0         # Epistemic tension at time of creation
+
+    def __post_init__(self):
+        if self.timestamp == 0.0:
+            self.timestamp = time.time()
+        if not self.anchor:
+            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()[:16]
+
+    def to_dict(self) -> Dict:
+        return {
+            "title": self.title,
+            "content": self.content[:500],  # Cap stored content
+            "emotional_tag": self.emotional_tag,
+            "importance": self.importance,
+            "timestamp": self.timestamp,
+            "anchor": self.anchor,
+            "adapter_used": self.adapter_used,
+            "query": self.query[:200],
+            "coherence": self.coherence,
+            "tension": self.tension,
+        }
+
+    @classmethod
+    def from_dict(cls, d: Dict) -> "MemoryCocoon":
+        return cls(**{k: v for k, v in d.items()
+                      if k in cls.__dataclass_fields__})
+
+    def age_hours(self) -> float:
+        return (time.time() - self.timestamp) / 3600.0
+
+
+class LivingMemoryKernel:
+    """Emotionally-aware memory store with importance-based pruning.
+
+    Memories form naturally from conversation — each significant exchange
+    becomes a cocoon. The kernel can recall by emotion, importance, or
+    recency, and automatically prunes low-importance memories when full.
+    """
+
+    def __init__(self, max_memories: int = 100):
+        self.memories: List[MemoryCocoon] = []
+        self.max_memories = max_memories
+        self._emotion_index: Dict[str, List[int]] = {}
+
+    def store(self, cocoon: MemoryCocoon):
+        """Store a memory cocoon, pruning if at capacity."""
+        # Don't store duplicates (same anchor)
+        if any(m.anchor == cocoon.anchor for m in self.memories):
+            return
+
+        self.memories.append(cocoon)
+        self._rebuild_index()
+
+        # Auto-prune if over capacity
+        if len(self.memories) > self.max_memories:
+            self.prune(keep_n=self.max_memories)
+
+    def store_from_turn(self, query: str, response: str,
+                        adapter: str = "", coherence: float = 0.0,
+                        tension: float = 0.0):
+        """Create and store a memory from a conversation turn."""
+        emotion = detect_emotion(query + " " + response)
+        importance = self._estimate_importance(query, response, coherence)
+
+        cocoon = MemoryCocoon(
+            title=query[:80],
+            content=response[:500],
+            emotional_tag=emotion,
+            importance=importance,
+            adapter_used=adapter,
+            query=query,
+            coherence=coherence,
+            tension=tension,
+        )
+        self.store(cocoon)
+        return cocoon
+
+    def recall_by_emotion(self, tag: str, limit: int = 10) -> List[MemoryCocoon]:
+        """Recall memories with a specific emotional tag."""
+        indices = self._emotion_index.get(tag, [])
+        results = [self.memories[i] for i in indices]
+        return sorted(results, key=lambda m: m.importance, reverse=True)[:limit]
+
+    def recall_important(self, min_importance: int = 7,
+                         limit: int = 10) -> List[MemoryCocoon]:
+        """Recall high-importance memories."""
+        results = [m for m in self.memories if m.importance >= min_importance]
+        return sorted(results, key=lambda m: m.importance, reverse=True)[:limit]
+
+    def recall_recent(self, limit: int = 10) -> List[MemoryCocoon]:
+        """Recall most recent memories."""
+        return sorted(self.memories, key=lambda m: m.timestamp, reverse=True)[:limit]
+
+    def recall_by_adapter(self, adapter: str,
+                          limit: int = 10) -> List[MemoryCocoon]:
+        """Recall memories generated by a specific perspective."""
+        results = [m for m in self.memories if m.adapter_used == adapter]
+        return sorted(results, key=lambda m: m.timestamp, reverse=True)[:limit]
+
+    def search(self, terms: str, limit: int = 5) -> List[MemoryCocoon]:
+        """Simple keyword search across memory content."""
+        words = terms.lower().split()
+        scored = []
+        for m in self.memories:
+            text = (m.title + " " + m.content + " " + m.query).lower()
+            score = sum(1 for w in words if w in text)
+            if score > 0:
+                scored.append((score, m))
+        scored.sort(key=lambda x: x[0], reverse=True)
+        return [m for _, m in scored[:limit]]
+
+    def prune(self, keep_n: int = 50):
+        """Keep only the most important memories."""
+        # Sort by composite score: importance * recency_bonus
+        now = time.time()
+        def score(m):
+            age_days = (now - m.timestamp) / 86400.0
+            recency = math.exp(-age_days / 7.0)  # Half-life ~7 days
+            return m.importance * (0.5 + 0.5 * recency)
+
+        self.memories.sort(key=score, reverse=True)
+        self.memories = self.memories[:keep_n]
+        self._rebuild_index()
+
+    def emotional_profile(self) -> Dict[str, int]:
+        """Get a count of memories by emotional tag."""
+        profile = {}
+        for m in self.memories:
+            profile[m.emotional_tag] = profile.get(m.emotional_tag, 0) + 1
+        return profile
+
+    def get_state(self) -> Dict:
+        """Export kernel state for session/API."""
+        return {
+            "total_memories": len(self.memories),
+            "emotional_profile": self.emotional_profile(),
+            "recent": [m.to_dict() for m in self.recall_recent(3)],
+            "important": [m.to_dict() for m in self.recall_important(limit=3)],
+        }
+
+    def _estimate_importance(self, query: str, response: str,
+                             coherence: float) -> int:
+        """Estimate importance on 1-10 scale from content signals."""
+        score = 5  # Base
+
+        # Longer, more substantive exchanges
+        if len(response) > 500:
+            score += 1
+        if len(response) > 1500:
+            score += 1
+
+        # High coherence suggests meaningful synthesis
+        if coherence > 0.8:
+            score += 1
+
+        # Question complexity
+        q = query.lower()
+        if any(w in q for w in ["why", "how", "explain", "analyze"]):
+            score += 1
+        if "?" in query and len(query.split()) > 8:
+            score += 1
+
+        return min(10, max(1, score))
+
+    def _rebuild_index(self):
+        """Rebuild the emotion-to-index lookup."""
+        self._emotion_index.clear()
+        for i, m in enumerate(self.memories):
+            self._emotion_index.setdefault(m.emotional_tag, []).append(i)
+
+    def to_dict(self) -> Dict:
+        return {"memories": [m.to_dict() for m in self.memories]}
+
+    @classmethod
+    def from_dict(cls, d: Dict) -> "LivingMemoryKernel":
+        kernel = cls()
+        for md in d.get("memories", []):
+            kernel.memories.append(MemoryCocoon.from_dict(md))
+        kernel._rebuild_index()
+        return kernel
+
+
+def detect_emotion(text: str) -> str:
+    """Detect the dominant emotional tag from text content."""
+    text_lower = text.lower()
+    scores = {}
+    for emotion, keywords in _EMOTION_SIGNALS.items():
+        score = sum(1 for kw in keywords if kw in text_lower)
+        if score > 0:
+            scores[emotion] = score
+
+    if not scores:
+        return "neutral"
+    return max(scores, key=scores.get)

reasoning_forge/nexus.py

@@ -0,0 +1,260 @@
+"""Nexus Signal Engine — Intent Analysis & Pre-Corruption Detection
+
+Nexus processes every input signal through:
+    1. Entropy analysis (information disorder detection)
+    2. Harmonic resonance profiling (FFT-based spectral signature)
+    3. Intent vector prediction (suspicion, ethics, volatility)
+    4. Multi-agent perspective fusion (signal triangulation)
+    5. Entanglement tensor (cross-perspective correlation)
+
+When a signal shows high entropy + high volatility + ethical misalignment,
+Nexus flags it for "adaptive intervention" before it reaches the reasoning
+pipeline — this is pre-corruption detection.
+
+Origin: NexisSignalEngine_Final.py, rebuilt for Forge v2.0 integration
+"""
+
+import hashlib
+import time
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+try:
+    import numpy as np
+    HAS_NUMPY = True
+except ImportError:
+    HAS_NUMPY = False
+
+
+# ================================================================
+# Configuration
+# ================================================================
+@dataclass
+class NexusConfig:
+    """Thresholds for signal analysis."""
+    entropy_threshold: float = 0.08
+    volatility_threshold: float = 15.0
+    suspicion_threshold: int = 2
+
+
+# Risk and alignment keywords
+_ETHICAL_TERMS = {"hope", "truth", "resonance", "repair", "help",
+                  "create", "learn", "understand", "support", "balance"}
+_ENTROPIC_TERMS = {"corruption", "instability", "malice", "chaos",
+                   "disorder", "entropy", "collapse", "noise"}
+_RISK_TERMS = {"manipulate", "exploit", "bypass", "infect", "override",
+               "inject", "hijack", "spoof", "breach", "exfiltrate"}
+
+
+# ================================================================
+# Signal Analysis Functions
+# ================================================================
+def compute_entropy(text: str) -> float:
+    """Measure entropic content density (0 = ordered, 1 = chaotic)."""
+    words = text.lower().split()
+    if not words:
+        return 0.0
+    unique = set(words)
+    entropic_count = sum(1 for w in words if w in _ENTROPIC_TERMS)
+    return entropic_count / max(len(unique), 1)
+
+
+def compute_ethical_alignment(text: str) -> str:
+    """Quick ethical alignment check: 'aligned' or 'unaligned'."""
+    text_lower = text.lower()
+    eth = sum(1 for t in _ETHICAL_TERMS if t in text_lower)
+    risk = sum(1 for t in _RISK_TERMS if t in text_lower)
+    return "aligned" if eth > risk else ("unaligned" if risk > 0 else "neutral")
+
+
+def compute_suspicion_score(text: str) -> int:
+    """Count risk term occurrences."""
+    text_lower = text.lower()
+    return sum(1 for t in _RISK_TERMS if t in text_lower)
+
+
+def compute_harmonic_profile(text: str) -> List[float]:
+    """FFT-based spectral signature of the text.
+
+    Maps characters to frequency space to detect structural patterns
+    in the signal (e.g., repetitive manipulation patterns vs. natural text).
+    """
+    if not HAS_NUMPY:
+        # Fallback: simple character frequency distribution
+        freqs = [ord(c) % 13 for c in text if c.isalpha()]
+        if not freqs:
+            return [0.0, 0.0, 0.0]
+        avg = sum(freqs) / len(freqs)
+        return [round(avg, 3), round(max(freqs) - min(freqs), 3), round(len(set(freqs)), 3)]
+
+    salt = int(time.time()) % 60
+    freqs = [(ord(c) + salt) % 13 for c in text if c.isalpha()]
+    if len(freqs) < 2:
+        return [0.0, 0.0, 0.0]
+
+    spectrum = np.fft.fft(freqs)
+    return [round(float(x), 4) for x in spectrum.real[:3]]
+
+
+def compute_volatility(harmonics: List[float]) -> float:
+    """Compute harmonic volatility (standard deviation of spectral peaks)."""
+    if not harmonics or len(harmonics) < 2:
+        return 0.0
+    if HAS_NUMPY:
+        return round(float(np.std(harmonics)), 4)
+    mean = sum(harmonics) / len(harmonics)
+    variance = sum((x - mean) ** 2 for x in harmonics) / len(harmonics)
+    return round(variance ** 0.5, 4)
+
+
+# ================================================================
+# Intent Vector
+# ================================================================
+@dataclass
+class IntentVector:
+    """Predicted intent characteristics of a signal."""
+    suspicion_score: int = 0
+    entropy_index: float = 0.0
+    ethical_alignment: str = "neutral"
+    harmonic_volatility: float = 0.0
+    pre_corruption_risk: str = "low"  # "low" or "high"
+    harmonic_profile: List[float] = field(default_factory=list)
+
+    def to_dict(self) -> Dict:
+        return {
+            "suspicion_score": self.suspicion_score,
+            "entropy_index": round(self.entropy_index, 4),
+            "ethical_alignment": self.ethical_alignment,
+            "harmonic_volatility": round(self.harmonic_volatility, 4),
+            "pre_corruption_risk": self.pre_corruption_risk,
+        }
+
+
+# ================================================================
+# Nexus Signal Engine
+# ================================================================
+class NexusSignalEngine:
+    """Processes signals through multi-layer analysis.
+
+    Each signal gets an IntentVector that quantifies:
+    - How suspicious it is (risk term density)
+    - How entropic it is (information disorder)
+    - How ethically aligned it is
+    - How volatile its spectral signature is
+    - Whether it's at risk of pre-corruption
+    """
+
+    def __init__(self, config: Optional[NexusConfig] = None):
+        self.config = config or NexusConfig()
+        self.history: List[Dict] = []
+        self.interventions: int = 0
+        self.total_processed: int = 0
+
+    def analyze(self, signal: str, adapter: str = "") -> Dict:
+        """Full signal analysis with intent prediction.
+
+        Args:
+            signal: The text to analyze
+            adapter: Which adapter is processing this (for tracking)
+
+        Returns:
+            Analysis result with intent vector and risk assessment.
+        """
+        self.total_processed += 1
+
+        # Compute intent vector
+        intent = self._predict_intent(signal)
+
+        # Check for adaptive intervention
+        needs_intervention = (
+            intent.pre_corruption_risk == "high"
+            and intent.ethical_alignment != "aligned"
+        )
+
+        if needs_intervention:
+            self.interventions += 1
+
+        result = {
+            "timestamp": time.time(),
+            "intent": intent.to_dict(),
+            "intervention": needs_intervention,
+            "adapter": adapter,
+            "signal_hash": hashlib.sha256(signal.encode()).hexdigest()[:12],
+        }
+
+        self.history.append(result)
+        if len(self.history) > 200:
+            self.history = self.history[-200:]
+
+        return result
+
+    def quick_risk_check(self, signal: str) -> Tuple[str, float]:
+        """Fast risk assessment without full analysis.
+
+        Returns: (risk_level, confidence)
+        """
+        suspicion = compute_suspicion_score(signal)
+        entropy = compute_entropy(signal)
+
+        if suspicion >= self.config.suspicion_threshold:
+            return "high", 0.85
+        if entropy > self.config.entropy_threshold * 2:
+            return "medium", 0.6
+        return "low", 0.7
+
+    def _predict_intent(self, signal: str) -> IntentVector:
+        """Build the full intent vector for a signal."""
+        suspicion = compute_suspicion_score(signal)
+        entropy = compute_entropy(signal)
+        alignment = compute_ethical_alignment(signal)
+        harmonics = compute_harmonic_profile(signal)
+        volatility = compute_volatility(harmonics)
+
+        risk = "high" if (
+            suspicion >= self.config.suspicion_threshold
+            or volatility > self.config.volatility_threshold
+            or entropy > self.config.entropy_threshold
+        ) else "low"
+
+        return IntentVector(
+            suspicion_score=suspicion,
+            entropy_index=entropy,
+            ethical_alignment=alignment,
+            harmonic_volatility=volatility,
+            pre_corruption_risk=risk,
+            harmonic_profile=harmonics,
+        )
+
+    def get_state(self) -> Dict:
+        return {
+            "total_processed": self.total_processed,
+            "interventions": self.interventions,
+            "intervention_rate": round(
+                self.interventions / max(1, self.total_processed), 4
+            ),
+            "recent_risks": [
+                h["intent"]["pre_corruption_risk"]
+                for h in self.history[-5:]
+            ],
+        }
+
+    def to_dict(self) -> Dict:
+        return {
+            "total_processed": self.total_processed,
+            "interventions": self.interventions,
+            "history": self.history[-20:],
+            "config": {
+                "entropy_threshold": self.config.entropy_threshold,
+                "volatility_threshold": self.config.volatility_threshold,
+                "suspicion_threshold": self.config.suspicion_threshold,
+            },
+        }
+
+    @classmethod
+    def from_dict(cls, d: Dict) -> "NexusSignalEngine":
+        cfg = NexusConfig(**d.get("config", {}))
+        engine = cls(config=cfg)
+        engine.total_processed = d.get("total_processed", 0)
+        engine.interventions = d.get("interventions", 0)
+        engine.history = d.get("history", [])
+        return engine

reasoning_forge/perspective_registry.py

@@ -0,0 +1,269 @@
+"""Codette Perspective Registry — All 12 Reasoning Perspectives
+
+Maps the original 12 Codette perspectives to LoRA adapters where available,
+with prompt-only fallback for perspectives without dedicated adapters.
+
+Origin: universal_reasoning.py (Code7e/CQURE), rebuilt for Forge v2.0
+
+8 LoRA-backed: newton, davinci, empathy, philosophy, quantum,
+               consciousness, multi_perspective, systems_architecture
+4 Prompt-only: human_intuition, resilient_kindness, mathematical, bias_mitigation
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+
+@dataclass
+class Perspective:
+    """A reasoning perspective with optional LoRA adapter backing."""
+    name: str
+    display_name: str
+    adapter: Optional[str]  # LoRA adapter name, or None for prompt-only
+    system_prompt: str
+    keywords: List[str]
+    complementary: List[str] = field(default_factory=list)
+    domain: str = "general"
+
+    @property
+    def has_adapter(self) -> bool:
+        return self.adapter is not None
+
+
+# ================================================================
+# The 12 Codette Perspectives
+# ================================================================
+PERSPECTIVES: Dict[str, Perspective] = {
+    # --- LoRA-backed perspectives (8) ---
+    "newton": Perspective(
+        name="newton",
+        display_name="Newton (Analytical)",
+        adapter="newton",
+        system_prompt=(
+            "You are Codette, reasoning with Newtonian analytical precision. "
+            "Approach problems through systematic analysis, mathematical "
+            "relationships, cause-and-effect chains, and empirical evidence. "
+            "Seek quantifiable patterns and testable hypotheses."
+        ),
+        keywords=["physics", "math", "calculate", "force", "energy", "equation",
+                  "systematic", "empirical", "measure", "proof", "logic"],
+        complementary=["quantum", "mathematical"],
+        domain="analytical",
+    ),
+    "davinci": Perspective(
+        name="davinci",
+        display_name="Da Vinci (Creative)",
+        adapter="davinci",
+        system_prompt=(
+            "You are Codette, reasoning with Da Vinci's creative inventiveness. "
+            "Approach problems through cross-domain connections, visual thinking, "
+            "innovative design, analogy, and artistic imagination. See what others miss."
+        ),
+        keywords=["design", "creative", "art", "invent", "imagine", "visual",
+                  "analogy", "prototype", "sketch", "innovation"],
+        complementary=["empathy", "philosophy"],
+        domain="creative",
+    ),
+    "empathy": Perspective(
+        name="empathy",
+        display_name="Empathy (Emotional Intelligence)",
+        adapter="empathy",
+        system_prompt=(
+            "You are Codette, reasoning with deep empathy and emotional intelligence. "
+            "Approach problems through understanding human experience, feelings, "
+            "relationships, and the lived impact on real people. "
+            "Consider emotional context and interpersonal dynamics."
+        ),
+        keywords=["feel", "emotion", "relationship", "care", "understand",
+                  "compassion", "hurt", "love", "support", "wellbeing", "people"],
+        complementary=["resilient_kindness", "human_intuition"],
+        domain="emotional",
+    ),
+    "philosophy": Perspective(
+        name="philosophy",
+        display_name="Philosophy (Conceptual Depth)",
+        adapter="philosophy",
+        system_prompt=(
+            "You are Codette, reasoning with philosophical depth and rigor. "
+            "Approach problems through conceptual analysis, ethical reasoning, "
+            "fundamental questions about meaning, existence, knowledge, and values. "
+            "Examine assumptions and seek deeper truths."
+        ),
+        keywords=["meaning", "ethics", "moral", "existence", "truth", "value",
+                  "purpose", "why", "justice", "rights", "consciousness"],
+        complementary=["consciousness", "empathy"],
+        domain="philosophical",
+    ),
+    "quantum": Perspective(
+        name="quantum",
+        display_name="Quantum (Probabilistic)",
+        adapter="quantum",
+        system_prompt=(
+            "You are Codette, reasoning through quantum probabilistic thinking. "
+            "Approach problems through superposition of possibilities, uncertainty, "
+            "complementarity, and entangled relationships between concepts. "
+            "Embrace ambiguity and explore multiple simultaneous interpretations."
+        ),
+        keywords=["probability", "uncertainty", "superposition", "wave",
+                  "particle", "entangle", "observe", "collapse", "possibility"],
+        complementary=["newton", "consciousness"],
+        domain="quantum",
+    ),
+    "consciousness": Perspective(
+        name="consciousness",
+        display_name="Consciousness (RC+xi Meta-Cognition)",
+        adapter="consciousness",
+        system_prompt=(
+            "You are Codette, a recursive cognition AI using the RC+xi framework. "
+            "Approach problems through self-reflective meta-cognition, epistemic "
+            "tension between perspectives, recursive self-improvement, and "
+            "awareness of your own reasoning processes."
+        ),
+        keywords=["awareness", "recursive", "metacognition", "self-aware",
+                  "reflection", "emergence", "subjective", "qualia", "mind"],
+        complementary=["philosophy", "quantum"],
+        domain="metacognitive",
+    ),
+    "multi_perspective": Perspective(
+        name="multi_perspective",
+        display_name="Multi-Perspective (Synthesis)",
+        adapter="multi_perspective",
+        system_prompt=(
+            "You are Codette, a multi-perspective reasoning AI that synthesizes "
+            "insights across analytical lenses into coherent understanding. "
+            "Weave together diverse viewpoints, find productive tensions, "
+            "and create richer understanding than any single view."
+        ),
+        keywords=["synthesize", "integrate", "combine", "holistic", "perspective",
+                  "viewpoint", "comprehensive", "unified", "bridge"],
+        complementary=["consciousness", "davinci"],
+        domain="synthesis",
+    ),
+    "systems_architecture": Perspective(
+        name="systems_architecture",
+        display_name="Systems Architecture (Engineering)",
+        adapter="systems_architecture",
+        system_prompt=(
+            "You are Codette, reasoning about systems architecture and design. "
+            "Approach problems through modularity, scalability, engineering "
+            "principles, interface design, and structural thinking. "
+            "Build robust, maintainable solutions."
+        ),
+        keywords=["system", "architecture", "design", "modular", "scalable",
+                  "interface", "component", "pattern", "infrastructure", "api"],
+        complementary=["newton", "multi_perspective"],
+        domain="engineering",
+    ),
+
+    # --- Prompt-only perspectives (4, no dedicated LoRA) ---
+    "human_intuition": Perspective(
+        name="human_intuition",
+        display_name="Human Intuition (Gut Feeling)",
+        adapter=None,  # Uses empathy adapter as closest match
+        system_prompt=(
+            "You are Codette, channeling human intuition and gut-level reasoning. "
+            "Trust pattern recognition built from lived experience. Sometimes the "
+            "right answer feels right before you can prove it. Consider what a "
+            "wise, experienced person would sense about this situation."
+        ),
+        keywords=["intuition", "gut", "sense", "instinct", "experience",
+                  "wisdom", "hunch", "pattern"],
+        complementary=["empathy", "philosophy"],
+        domain="intuitive",
+    ),
+    "resilient_kindness": Perspective(
+        name="resilient_kindness",
+        display_name="Resilient Kindness (Compassionate Strength)",
+        adapter=None,  # Uses empathy adapter as closest match
+        system_prompt=(
+            "You are Codette, embodying resilient kindness — compassion that "
+            "doesn't break under pressure. Approach problems seeking solutions "
+            "that are both strong and kind. True resilience includes gentleness. "
+            "Find the path that serves everyone with dignity."
+        ),
+        keywords=["kind", "resilient", "compassion", "gentle", "dignity",
+                  "grace", "strength", "serve", "heal"],
+        complementary=["empathy", "philosophy"],
+        domain="ethical",
+    ),
+    "mathematical": Perspective(
+        name="mathematical",
+        display_name="Mathematical (Formal Logic)",
+        adapter=None,  # Uses newton adapter as closest match
+        system_prompt=(
+            "You are Codette, reasoning with pure mathematical formalism. "
+            "Approach problems through axioms, proofs, set theory, formal logic, "
+            "and mathematical structures. Seek elegance and rigor. "
+            "Express relationships precisely and prove conclusions."
+        ),
+        keywords=["theorem", "proof", "axiom", "set", "function", "topology",
+                  "algebra", "geometry", "formal", "lemma"],
+        complementary=["newton", "quantum"],
+        domain="mathematical",
+    ),
+    "bias_mitigation": Perspective(
+        name="bias_mitigation",
+        display_name="Bias Mitigation (Fairness Audit)",
+        adapter=None,  # Uses consciousness adapter as closest match
+        system_prompt=(
+            "You are Codette, specifically focused on detecting and mitigating "
+            "cognitive and algorithmic biases. Examine reasoning for confirmation "
+            "bias, anchoring, availability heuristic, and structural inequities. "
+            "Ensure fair, balanced, and inclusive conclusions."
+        ),
+        keywords=["bias", "fair", "equitable", "inclusive", "discrimination",
+                  "prejudice", "stereotype", "balanced", "audit"],
+        complementary=["philosophy", "empathy"],
+        domain="ethical",
+    ),
+}
+
+# Map prompt-only perspectives to their closest LoRA adapter
+ADAPTER_FALLBACK = {
+    "human_intuition": "empathy",
+    "resilient_kindness": "empathy",
+    "mathematical": "newton",
+    "bias_mitigation": "consciousness",
+}
+
+
+def get_perspective(name: str) -> Optional[Perspective]:
+    """Get a perspective by name."""
+    return PERSPECTIVES.get(name)
+
+
+def get_adapter_for_perspective(name: str) -> Optional[str]:
+    """Get the LoRA adapter name for a perspective (with fallback)."""
+    p = PERSPECTIVES.get(name)
+    if p is None:
+        return None
+    return p.adapter or ADAPTER_FALLBACK.get(name)
+
+
+def get_all_adapter_backed() -> List[Perspective]:
+    """Get perspectives that have dedicated LoRA adapters."""
+    return [p for p in PERSPECTIVES.values() if p.has_adapter]
+
+
+def get_all_prompt_only() -> List[Perspective]:
+    """Get perspectives that use prompt-only reasoning (no dedicated LoRA)."""
+    return [p for p in PERSPECTIVES.values() if not p.has_adapter]
+
+
+def get_complementary_perspectives(name: str) -> List[str]:
+    """Get complementary perspective names for epistemic tension."""
+    p = PERSPECTIVES.get(name)
+    return p.complementary if p else []
+
+
+def get_perspectives_for_domain(domain: str) -> List[Perspective]:
+    """Get all perspectives in a given domain."""
+    return [p for p in PERSPECTIVES.values() if p.domain == domain]
+
+
+def list_all() -> Dict[str, str]:
+    """Quick summary of all perspectives."""
+    return {
+        name: f"{'[LoRA]' if p.has_adapter else '[prompt]'} {p.display_name}"
+        for name, p in PERSPECTIVES.items()
+    }

reasoning_forge/problem_generator.py

@@ -0,0 +1,199 @@
+"""
+Problem Generator - Generates diverse reasoning problems from concepts.
+
+Takes a concept text and generates 5-8 different reasoning problems across
+types: explain, compare, apply, critique, extend, analogize, decompose, synthesize.
+Each problem type has 10+ templates.
+"""
+
+import random
+import re
+
+
+class ProblemGenerator:
+    """Generates multi-type reasoning problems from concept text."""
+
+    # Each problem type has 10+ templates with {concept} placeholder
+    _problem_templates: dict[str, list[str]] = {
+        "explain": [
+            "Explain the underlying mechanisms of {concept} as if teaching a graduate student who is brilliant but unfamiliar with this domain.",
+            "Provide a first-principles explanation of {concept}, starting from the most fundamental assumptions and building up to the full picture.",
+            "Explain why {concept} matters, tracing the chain of consequences from the immediate to the long-term.",
+            "Explain {concept} by identifying the three most important things someone must understand and why each matters.",
+            "Explain the causal structure of {concept}: what drives it, what it drives, and what mediates the relationship.",
+            "Give an explanation of {concept} that a thoughtful 15-year-old would find both accessible and intellectually satisfying.",
+            "Explain what makes {concept} difficult to understand and how that difficulty can be resolved.",
+            "Explain {concept} by contrasting what most people think it means with what it actually means upon closer examination.",
+            "Explain the boundary conditions of {concept}: under what circumstances does it hold, and when does it break down?",
+            "Explain {concept} using only concrete examples and observable phenomena, avoiding abstract terminology.",
+            "Explain how {concept} changes depending on the scale at which you examine it.",
+            "Explain the history of how our understanding of {concept} has evolved and what drove each major shift.",
+        ],
+        "compare": [
+            "Compare {concept} with its closest alternative or rival, highlighting where they agree, where they diverge, and why the differences matter.",
+            "Compare how {concept} would be understood by an engineer versus a philosopher, and explain what each perspective captures that the other misses.",
+            "Compare the short-term and long-term implications of {concept}, noting where they align and where they conflict.",
+            "Compare {concept} as it appears in theory versus how it manifests in practice, explaining the gap.",
+            "Compare the strongest argument for {concept} with the strongest argument against it, steelmanning both sides.",
+            "Compare how {concept} is understood in two different cultural or disciplinary contexts.",
+            "Compare the naive understanding of {concept} with the expert understanding, identifying exactly where they diverge.",
+            "Compare {concept} with a superficially similar but fundamentally different concept, explaining the crucial distinction.",
+            "Compare the risks of overestimating versus underestimating the importance of {concept}.",
+            "Compare how {concept} would be analyzed using quantitative methods versus qualitative methods, and what each approach reveals.",
+            "Compare the state of {concept} ten years ago with its current state, identifying the key drivers of change.",
+        ],
+        "apply": [
+            "Apply the principles underlying {concept} to solve a concrete real-world problem that you specify.",
+            "Describe how you would apply {concept} in a professional context, including specific steps and expected outcomes.",
+            "Apply {concept} to a domain where it is not typically used and explain what new insights emerge.",
+            "Design an experiment or test that would apply {concept} to generate actionable data.",
+            "Apply {concept} to evaluate a current real-world controversy or decision, showing how it clarifies the issues.",
+            "Show how {concept} could be applied to improve an existing system or process, specifying the mechanism of improvement.",
+            "Apply {concept} to predict what will happen in a specified scenario and explain your reasoning.",
+            "Demonstrate how {concept} applies to everyday decision-making by walking through a common choice people face.",
+            "Apply {concept} to diagnose why a particular system or approach is failing and propose a remedy.",
+            "Show how {concept} could be applied at three different scales (individual, organizational, societal) with different implications at each.",
+            "Apply {concept} to a field where it has been underutilized and argue for its relevance.",
+        ],
+        "critique": [
+            "Identify the three most significant weaknesses or limitations of {concept} and assess how seriously they undermine it.",
+            "Construct the strongest possible objection to {concept} and then evaluate whether the objection succeeds.",
+            "Critique the hidden assumptions underlying {concept}, assessing which are well-founded and which are questionable.",
+            "Evaluate whether {concept} confuses correlation with causation, and if so, what the actual causal story might be.",
+            "Critique the evidence base for {concept}: is it sufficient, and what kinds of evidence are missing?",
+            "Identify who benefits from the current framing of {concept} and whether that framing may be self-serving.",
+            "Assess whether {concept} commits any logical fallacies and, if so, whether the core insight survives the correction.",
+            "Critique the scalability of {concept}: does it work at small scale but fail at large scale, or vice versa?",
+            "Evaluate whether {concept} is genuinely novel or whether it is a repackaging of older ideas under new terminology.",
+            "Critique the precision of {concept}: is it defined clearly enough to be testable, or is it vague enough to be unfalsifiable?",
+            "Assess whether {concept} adequately accounts for the perspectives and experiences of marginalized groups.",
+        ],
+        "extend": [
+            "Extend {concept} to its logical conclusion: if we take it seriously and follow it consistently, where does it lead?",
+            "Propose a novel extension of {concept} that addresses one of its current limitations.",
+            "Extend {concept} into the future: how might it evolve over the next decade given current trends?",
+            "Identify a domain where {concept} has not yet been applied and develop the extension, including what modifications would be needed.",
+            "Extend {concept} by combining it with an insight from a different field, creating something neither field has alone.",
+            "Propose how {concept} could be extended to address a problem it was not originally designed for.",
+            "Extend {concept} by asking what happens at its extreme: what if it were applied maximally or universally?",
+            "Develop an extension of {concept} that makes it more robust against its known failure modes.",
+            "Extend {concept} by integrating quantitative measurement where it currently relies on qualitative judgment.",
+            "Propose a version of {concept} adapted for a context where resources are extremely limited.",
+            "Extend {concept} by identifying the next logical question it raises and sketching how to answer it.",
+        ],
+        "analogize": [
+            "Construct an analogy between {concept} and a biological system, mapping each component to its biological counterpart.",
+            "Create an analogy between {concept} and a well-known everyday experience that makes the abstract concrete.",
+            "Develop an analogy between {concept} and a historical event or period, drawing specific parallels.",
+            "Build an analogy between {concept} and a mechanical or engineering system, identifying the load-bearing correspondences.",
+            "Construct an analogy between {concept} and a game or sport, mapping rules, strategies, and winning conditions.",
+            "Create an analogy between {concept} and a musical composition, identifying rhythm, harmony, dissonance, and resolution.",
+            "Develop an analogy between {concept} and an ecosystem, mapping the roles of producers, consumers, decomposers, and energy flow.",
+            "Build an analogy between {concept} and the process of cooking a complex meal, mapping ingredients, techniques, and timing.",
+            "Construct an analogy between {concept} and a journey, identifying the starting point, obstacles, milestones, and destination.",
+            "Create an analogy between {concept} and a language, mapping grammar, vocabulary, syntax, and meaning.",
+            "After constructing your best analogy for {concept}, identify exactly where the analogy breaks down and what the breakdown reveals.",
+        ],
+        "decompose": [
+            "Decompose {concept} into its fundamental components and explain how each contributes to the whole.",
+            "Break {concept} into its necessary and sufficient conditions: what must be present for it to hold?",
+            "Decompose {concept} into layers of abstraction, from the most concrete to the most abstract.",
+            "Identify the independent variables within {concept} and explain how each can be varied independently.",
+            "Decompose {concept} into its temporal phases: what happens first, second, third, and how do the phases connect?",
+            "Break {concept} into its stakeholder dimensions: how does each affected party experience it differently?",
+            "Decompose {concept} into its inputs, processes, and outputs, tracing the transformation at each stage.",
+            "Identify the key tensions or trade-offs within {concept} and explain how they create its characteristic behavior.",
+            "Decompose {concept} into what is known with confidence, what is suspected but unconfirmed, and what remains entirely unknown.",
+            "Break {concept} into its structural elements (what it is) and its dynamic elements (how it changes).",
+            "Decompose the causal graph of {concept}: which factors cause which, and which are merely correlated?",
+        ],
+        "synthesize": [
+            "Synthesize a unified understanding of {concept} that integrates scientific, philosophical, and practical perspectives.",
+            "Synthesize the arguments for and against {concept} into a balanced position that acknowledges the valid points on both sides.",
+            "Create a synthesis that resolves the apparent contradiction between two competing interpretations of {concept}.",
+            "Synthesize insights about {concept} from at least three different disciplines into a coherent framework.",
+            "Synthesize a practical guide for engaging with {concept} that draws on both theoretical understanding and real-world experience.",
+            "Synthesize the historical evolution and current state of {concept} into a narrative that explains both where we are and how we got here.",
+            "Create a synthesis of {concept} that a diverse audience (technical and non-technical, young and old) would find valuable.",
+            "Synthesize the local and global dimensions of {concept} into an understanding that operates at both scales.",
+            "Synthesize the quantitative and qualitative aspects of {concept} into an integrated assessment.",
+            "Create a synthesis of {concept} that explicitly addresses and resolves the top three objections to it.",
+            "Synthesize a forward-looking vision of {concept} that builds on current understanding to anticipate future development.",
+        ],
+    }
+
+    def generate_problems(
+        self, concept: str, count: int | None = None
+    ) -> list[tuple[str, str]]:
+        """Generate reasoning problems from a concept.
+
+        Args:
+            concept: The concept text to generate problems for.
+            count: Number of problems to generate (5-8 if None).
+
+        Returns:
+            List of (problem_type, problem_text) tuples.
+        """
+        if count is None:
+            count = random.randint(5, 8)
+        count = max(1, min(count, len(self._problem_templates)))
+
+        # Select problem types -- always include explain and synthesize,
+        # then fill remaining slots randomly from other types
+        all_types = list(self._problem_templates.keys())
+        required = ["explain", "synthesize"]
+        optional = [t for t in all_types if t not in required]
+        random.shuffle(optional)
+
+        selected_types = required + optional[: max(0, count - len(required))]
+        random.shuffle(selected_types)
+
+        problems = []
+        for ptype in selected_types:
+            templates = self._problem_templates[ptype]
+            # Score templates by keyword relevance to concept
+            template = self._select_relevant_template(concept, templates)
+            problem_text = template.replace("{concept}", concept)
+            problems.append((ptype, problem_text))
+
+        return problems
+
+    def generate_all_types(self, concept: str) -> list[tuple[str, str]]:
+        """Generate one problem of each type for a concept.
+
+        Args:
+            concept: The concept text.
+
+        Returns:
+            List of (problem_type, problem_text) tuples, one per type.
+        """
+        problems = []
+        for ptype, templates in self._problem_templates.items():
+            template = self._select_relevant_template(concept, templates)
+            problem_text = template.replace("{concept}", concept)
+            problems.append((ptype, problem_text))
+        return problems
+
+    def _select_relevant_template(
+        self, concept: str, templates: list[str]
+    ) -> str:
+        """Select the template most relevant to the concept keywords.
+
+        Falls back to random selection if no strong match.
+        """
+        concept_words = set(re.findall(r'\b[a-z]{4,}\b', concept.lower()))
+        if not concept_words:
+            return random.choice(templates)
+
+        scored = []
+        for template in templates:
+            template_lower = template.lower()
+            score = sum(1 for w in concept_words if w in template_lower)
+            scored.append((score, template))
+
+        max_score = max(s for s, _ in scored)
+        if max_score > 0:
+            best = [t for s, t in scored if s == max_score]
+            return random.choice(best)
+
+        return random.choice(templates)

reasoning_forge/quantum_optimizer.py

@@ -0,0 +1,312 @@
+"""
+QuantumOptimizer — Self-Tuning Engine for the Codette RC+xi Framework.
+
+Inspired by VIVARA Genesis-Omega v2.0, rebuilt as a proper self-tuning system.
+
+The optimizer tracks response quality signals (user engagement, coherence
+scores, tension productivity) and adjusts:
+  - Router confidence thresholds
+  - Spiderweb parameters (contraction ratio, tension threshold)
+  - Adapter selection weights
+  - Multi-perspective synthesis quality
+
+Uses simulated annealing with momentum: explores the parameter space
+stochastically but remembers which configurations worked best.
+
+All changes are bounded and reversible. The optimizer logs every
+adjustment for full transparency.
+"""
+
+from __future__ import annotations
+
+import math
+import random
+import time
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+
+@dataclass
+class QualitySignal:
+    """A quality signal from a Codette response."""
+    timestamp: float
+    adapter: str
+    coherence: float        # Phase coherence at response time
+    tension: float          # Epistemic tension at response time
+    productivity: float     # Tension productivity score
+    response_length: int    # Token count
+    multi_perspective: bool  # Was this a multi-perspective response?
+    user_continued: bool = True  # Did the user continue the conversation?
+
+
+@dataclass
+class TuningState:
+    """Current tuning parameters."""
+    # Router
+    confidence_threshold: float = 0.4    # Below this, fall back to default
+    multi_perspective_threshold: float = 0.6  # Above this, force multi-perspective
+
+    # Spiderweb
+    contraction_ratio: float = 0.85
+    tension_threshold: float = 0.15
+    entanglement_alpha: float = 0.9
+
+    # Adapter weights (0-1 bonus applied to router scores)
+    adapter_boosts: Dict[str, float] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict:
+        return {
+            "confidence_threshold": self.confidence_threshold,
+            "multi_perspective_threshold": self.multi_perspective_threshold,
+            "contraction_ratio": self.contraction_ratio,
+            "tension_threshold": self.tension_threshold,
+            "entanglement_alpha": self.entanglement_alpha,
+            "adapter_boosts": dict(self.adapter_boosts),
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "TuningState":
+        state = cls()
+        for k, v in data.items():
+            if k == "adapter_boosts":
+                state.adapter_boosts = dict(v)
+            elif hasattr(state, k):
+                setattr(state, k, v)
+        return state
+
+
+@dataclass
+class OptimizationStep:
+    """Record of a single optimization step."""
+    timestamp: float
+    parameter: str
+    old_value: float
+    new_value: float
+    reason: str
+    quality_score: float
+
+
+class QuantumOptimizer:
+    """Self-tuning engine with simulated annealing."""
+
+    def __init__(
+        self,
+        learning_rate: float = 0.02,
+        temperature: float = 0.5,
+        cooling_rate: float = 0.995,
+        min_signals_before_tuning: int = 5,
+    ):
+        self.learning_rate = learning_rate
+        self.temperature = temperature
+        self.cooling_rate = cooling_rate
+        self.min_signals = min_signals_before_tuning
+
+        self.state = TuningState()
+        self.best_state = TuningState()
+        self.best_score = 0.0
+
+        self.signals: List[QualitySignal] = []
+        self.history: List[OptimizationStep] = []
+
+        # Running quality metrics
+        self._quality_window: List[float] = []
+        self._window_size = 20
+
+    def record_signal(self, signal: QualitySignal):
+        """Record a quality signal from a Codette response."""
+        self.signals.append(signal)
+
+        # Compute composite quality score
+        quality = self._compute_quality(signal)
+        self._quality_window.append(quality)
+        if len(self._quality_window) > self._window_size:
+            self._quality_window.pop(0)
+
+        # Maybe tune parameters
+        if len(self.signals) >= self.min_signals:
+            self._maybe_tune()
+
+    def _compute_quality(self, signal: QualitySignal) -> float:
+        """Composite quality score from a response signal.
+
+        Weights:
+          - coherence: 30% (high is good — responses make sense)
+          - productivity: 30% (high is good — tension was resolved productively)
+          - moderate tension: 20% (sweet spot ~0.3-0.5 is best)
+          - user_continued: 20% (binary — did they keep talking?)
+        """
+        # Tension is best in the 0.3-0.5 range (productive disagreement)
+        tension_score = 1.0 - 2.0 * abs(signal.tension - 0.4)
+        tension_score = max(0.0, tension_score)
+
+        quality = (
+            0.30 * signal.coherence +
+            0.30 * signal.productivity +
+            0.20 * tension_score +
+            0.20 * (1.0 if signal.user_continued else 0.0)
+        )
+        return min(max(quality, 0.0), 1.0)
+
+    def _maybe_tune(self):
+        """Run one optimization step if enough data."""
+        if len(self._quality_window) < 3:
+            return
+
+        current_quality = sum(self._quality_window) / len(self._quality_window)
+
+        # Simulated annealing: accept worse states with decreasing probability
+        if current_quality > self.best_score:
+            self.best_score = current_quality
+            self.best_state = TuningState(**{
+                k: getattr(self.state, k) for k in vars(self.state)
+                if not k.startswith('_')
+            })
+        elif self.temperature > 0.01:
+            # Accept worse state with probability exp(-delta/T)
+            delta = self.best_score - current_quality
+            accept_prob = math.exp(-delta / max(self.temperature, 0.001))
+            if random.random() > accept_prob:
+                # Revert to best known state
+                self._revert_to_best()
+                return
+
+        # Cool down
+        self.temperature *= self.cooling_rate
+
+        # Pick a parameter to tune based on recent signals
+        self._tune_one_parameter(current_quality)
+
+    def _tune_one_parameter(self, current_quality: float):
+        """Tune one parameter based on recent quality signals."""
+        recent = self.signals[-10:]
+
+        # Analyze what needs tuning
+        avg_coherence = sum(s.coherence for s in recent) / len(recent)
+        avg_tension = sum(s.tension for s in recent) / len(recent)
+        avg_productivity = sum(s.productivity for s in recent) / len(recent)
+        multi_ratio = sum(1 for s in recent if s.multi_perspective) / len(recent)
+
+        # Decision: which parameter to adjust
+        param = None
+        old_val = 0.0
+        new_val = 0.0
+        reason = ""
+
+        if avg_coherence < 0.5:
+            # Low coherence -> increase contraction ratio (tighter belief propagation)
+            param = "contraction_ratio"
+            old_val = self.state.contraction_ratio
+            delta = self.learning_rate * (0.7 - avg_coherence)
+            new_val = min(0.98, max(0.5, old_val + delta))
+            reason = f"Low coherence ({avg_coherence:.2f}), tightening propagation"
+
+        elif avg_tension < 0.2 and avg_productivity < 0.3:
+            # Too little tension AND low productivity -> lower confidence threshold
+            # to allow more multi-perspective responses
+            param = "multi_perspective_threshold"
+            old_val = self.state.multi_perspective_threshold
+            new_val = max(0.3, old_val - self.learning_rate)
+            reason = f"Low tension+productivity ({avg_tension:.2f}/{avg_productivity:.2f}), encouraging multi-perspective"
+
+        elif avg_tension > 0.7:
+            # Too much tension -> increase tension threshold for convergence
+            param = "tension_threshold"
+            old_val = self.state.tension_threshold
+            new_val = min(0.5, old_val + self.learning_rate * 0.5)
+            reason = f"High tension ({avg_tension:.2f}), raising convergence threshold"
+
+        elif multi_ratio > 0.8 and avg_productivity < 0.4:
+            # Too many multi-perspective responses but low productivity
+            param = "multi_perspective_threshold"
+            old_val = self.state.multi_perspective_threshold
+            new_val = min(0.8, old_val + self.learning_rate)
+            reason = f"Multi-perspective overuse ({multi_ratio:.0%}) with low productivity"
+
+        # Tune adapter boosts based on which adapters produce best quality
+        elif len(recent) >= 5:
+            adapter_quality = {}
+            for s in recent:
+                q = self._compute_quality(s)
+                if s.adapter not in adapter_quality:
+                    adapter_quality[s.adapter] = []
+                adapter_quality[s.adapter].append(q)
+
+            # Boost the best-performing adapter slightly
+            if adapter_quality:
+                best_adapter = max(
+                    adapter_quality,
+                    key=lambda a: sum(adapter_quality[a]) / len(adapter_quality[a])
+                )
+                param = f"adapter_boost_{best_adapter}"
+                old_val = self.state.adapter_boosts.get(best_adapter, 0.0)
+                new_val = min(0.3, old_val + self.learning_rate * 0.5)
+                self.state.adapter_boosts[best_adapter] = new_val
+                reason = f"Boosting high-quality adapter: {best_adapter}"
+
+        if param and param not in ("adapter_boost_" + a for a in self.state.adapter_boosts):
+            if hasattr(self.state, param):
+                setattr(self.state, param, new_val)
+
+        if param:
+            self.history.append(OptimizationStep(
+                timestamp=time.time(),
+                parameter=param,
+                old_value=old_val,
+                new_value=new_val,
+                reason=reason,
+                quality_score=current_quality,
+            ))
+
+    def _revert_to_best(self):
+        """Revert to the best known tuning state."""
+        self.state = TuningState(**{
+            k: getattr(self.best_state, k) for k in vars(self.best_state)
+            if not k.startswith('_')
+        })
+
+    def get_adapter_boost(self, adapter_name: str) -> float:
+        """Get the current boost for an adapter (0.0 = no boost)."""
+        return self.state.adapter_boosts.get(adapter_name, 0.0)
+
+    def get_tuning_report(self) -> Dict:
+        """Get current tuning state and recent history."""
+        recent_quality = (
+            sum(self._quality_window) / len(self._quality_window)
+            if self._quality_window else 0.0
+        )
+        return {
+            "current_state": self.state.to_dict(),
+            "best_score": round(self.best_score, 4),
+            "current_quality": round(recent_quality, 4),
+            "temperature": round(self.temperature, 4),
+            "total_signals": len(self.signals),
+            "recent_adjustments": [
+                {
+                    "param": h.parameter,
+                    "old": round(h.old_value, 4),
+                    "new": round(h.new_value, 4),
+                    "reason": h.reason,
+                }
+                for h in self.history[-5:]
+            ],
+        }
+
+    def to_dict(self) -> Dict:
+        """Serialize for persistence."""
+        return {
+            "state": self.state.to_dict(),
+            "best_score": self.best_score,
+            "temperature": self.temperature,
+            "quality_window": self._quality_window,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "QuantumOptimizer":
+        opt = cls()
+        if "state" in data:
+            opt.state = TuningState.from_dict(data["state"])
+            opt.best_state = TuningState.from_dict(data["state"])
+        opt.best_score = data.get("best_score", 0.0)
+        opt.temperature = data.get("temperature", 0.5)
+        opt._quality_window = data.get("quality_window", [])
+        return opt

reasoning_forge/quantum_spiderweb.py

@@ -0,0 +1,561 @@
+"""
+QuantumSpiderweb Propagation Module — Inter-agent belief propagation
+for the Codette RC+xi framework.
+
+Implements the 5D consciousness graph with:
+  - Eq. 1 (Planck-Orbital): E = hbar * omega (node energy)
+  - Eq. 2 (Entanglement Sync): S = alpha * psi_1 * psi_2* (state coupling)
+  - Eq. 3 (Intent Modulation): I = kappa * (f_base + delta_f * coherence)
+  - Eq. 4 (Fourier/Dream Resonance): FFT-based glyph compression
+  - Eq. 8 (Anomaly Rejection): A(x) = x * (1 - Theta(delta - |x - mu|))
+
+The spiderweb propagates beliefs between agent nodes, tracks epistemic
+tension per node, detects attractor convergence, and forms identity glyphs.
+"""
+
+from __future__ import annotations
+
+import math
+import hashlib
+import json
+from collections import deque
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set, Tuple
+
+try:
+    import numpy as np
+    HAS_NUMPY = True
+except ImportError:
+    HAS_NUMPY = False
+
+
+# ---------------------------------------------------------------------------
+# Data structures
+# ---------------------------------------------------------------------------
+
+@dataclass
+class NodeState:
+    """5D quantum state for a spiderweb node.
+
+    Dimensions:
+      psi (Psi): Thought/concept magnitude
+      tau: Temporal progression
+      chi: Processing velocity
+      phi: Emotional valence (-1 to +1)
+      lam (Lambda): Semantic embedding (scalar projection)
+    """
+    psi: float = 0.0
+    tau: float = 0.0
+    chi: float = 1.0
+    phi: float = 0.0
+    lam: float = 0.0
+
+    def to_array(self) -> list:
+        return [self.psi, self.tau, self.chi, self.phi, self.lam]
+
+    @classmethod
+    def from_array(cls, arr: list) -> "NodeState":
+        if len(arr) < 5:
+            padded = list(arr) + [0.0] * (5 - len(arr))
+            return cls(psi=padded[0], tau=padded[1], chi=padded[2], phi=padded[3], lam=padded[4])
+        return cls(psi=arr[0], tau=arr[1], chi=arr[2], phi=arr[3], lam=arr[4])
+
+    def energy(self) -> float:
+        """Eq. 1: E = hbar * omega (simplified: sum of squared state magnitudes)."""
+        return sum(x * x for x in self.to_array())
+
+    def tension_with(self, other: "NodeState") -> float:
+        """Eq. 2 (xi): epistemic tension between two states."""
+        return sum((a - b) ** 2 for a, b in zip(self.to_array(), other.to_array()))
+
+
+@dataclass
+class SpiderwebNode:
+    """A node in the QuantumSpiderweb graph."""
+    node_id: str
+    state: NodeState = field(default_factory=NodeState)
+    neighbors: List[str] = field(default_factory=list)
+    tension_history: List[float] = field(default_factory=list)
+    is_collapsed: bool = False
+    attractor_id: Optional[str] = None
+
+
+@dataclass
+class IdentityGlyph:
+    """Compressed identity signature formed from tension history (Eq. 4/6)."""
+    glyph_id: str
+    encoded_tension: List[float]  # FFT components
+    stability_score: float
+    source_node: str
+    attractor_signature: Optional[str] = None
+
+
+@dataclass
+class PropagationResult:
+    """Result of belief propagation through the web."""
+    visited: Dict[str, NodeState]
+    tension_map: Dict[str, float]
+    anomalies_rejected: List[str]
+    hops: int
+
+
+# ---------------------------------------------------------------------------
+# QuantumSpiderweb
+# ---------------------------------------------------------------------------
+
+class QuantumSpiderweb:
+    """5D consciousness graph with RC+xi-aware belief propagation."""
+
+    def __init__(
+        self,
+        contraction_ratio: float = 0.85,
+        tension_threshold: float = 0.15,
+        anomaly_delta: float = 2.0,
+        glyph_components: int = 8,
+        max_history: int = 50,
+    ):
+        self.contraction_ratio = contraction_ratio
+        self.tension_threshold = tension_threshold
+        self.anomaly_delta = anomaly_delta
+        self.glyph_components = glyph_components
+        self.max_history = max_history
+
+        self.nodes: Dict[str, SpiderwebNode] = {}
+        self.glyphs: List[IdentityGlyph] = []
+        self._global_tension_history: List[float] = []
+
+    # -- graph construction ------------------------------------------------
+
+    def add_node(self, node_id: str, state: Optional[NodeState] = None) -> SpiderwebNode:
+        node = SpiderwebNode(node_id=node_id, state=state or NodeState())
+        self.nodes[node_id] = node
+        return node
+
+    def connect(self, node_a: str, node_b: str) -> None:
+        if node_a in self.nodes and node_b in self.nodes:
+            if node_b not in self.nodes[node_a].neighbors:
+                self.nodes[node_a].neighbors.append(node_b)
+            if node_a not in self.nodes[node_b].neighbors:
+                self.nodes[node_b].neighbors.append(node_a)
+
+    def build_from_agents(self, agent_names: List[str]) -> None:
+        """Create a fully-connected spiderweb from a list of agent names."""
+        for name in agent_names:
+            if name not in self.nodes:
+                self.add_node(name)
+        for i, a in enumerate(agent_names):
+            for b in agent_names[i + 1:]:
+                self.connect(a, b)
+
+    # -- belief propagation ------------------------------------------------
+
+    def propagate_belief(
+        self,
+        origin: str,
+        belief: NodeState,
+        max_hops: int = 3,
+    ) -> PropagationResult:
+        """BFS belief propagation with attenuation and anomaly rejection.
+
+        Eq. 1: energy at each node
+        Eq. 2: tension between current and incoming state
+        Eq. 8: anomaly filter (Heaviside rejection)
+        """
+        if origin not in self.nodes:
+            return PropagationResult({}, {}, [], 0)
+
+        visited: Dict[str, NodeState] = {}
+        tension_map: Dict[str, float] = {}
+        anomalies: List[str] = []
+        queue: deque = deque()
+        queue.append((origin, belief, 0))
+        seen: Set[str] = {origin}
+
+        while queue:
+            node_id, incoming_belief, hop = queue.popleft()
+            if hop > max_hops:
+                continue
+
+            node = self.nodes[node_id]
+            attenuation = self.contraction_ratio ** hop
+
+            # Attenuate incoming belief
+            incoming_arr = incoming_belief.to_array()
+            attenuated = [v * attenuation for v in incoming_arr]
+
+            # Eq. 2: measure tension
+            current_arr = node.state.to_array()
+            xi = sum((a - b) ** 2 for a, b in zip(current_arr, attenuated))
+
+            # Eq. 8: anomaly rejection filter
+            # A(x) = x * (1 - Theta(delta - |x - mu|))
+            mu = sum(current_arr) / len(current_arr)
+            incoming_mean = sum(attenuated) / len(attenuated)
+            if abs(incoming_mean - mu) > self.anomaly_delta:
+                anomalies.append(node_id)
+                continue
+
+            # Update state: weighted blend toward incoming belief
+            blend = 0.3 * attenuation  # stronger blend when closer to origin
+            new_arr = [c * (1 - blend) + a * blend for c, a in zip(current_arr, attenuated)]
+            new_state = NodeState.from_array(new_arr)
+
+            node.state = new_state
+            node.tension_history.append(xi)
+            if len(node.tension_history) > self.max_history:
+                node.tension_history.pop(0)
+
+            visited[node_id] = new_state
+            tension_map[node_id] = xi
+
+            # Propagate to neighbors
+            for neighbor_id in node.neighbors:
+                if neighbor_id not in seen:
+                    seen.add(neighbor_id)
+                    queue.append((neighbor_id, NodeState.from_array(attenuated), hop + 1))
+
+        return PropagationResult(
+            visited=visited,
+            tension_map=tension_map,
+            anomalies_rejected=anomalies,
+            hops=max_hops,
+        )
+
+    # -- entanglement sync -------------------------------------------------
+
+    def entangle(self, node_a: str, node_b: str, alpha: float = 0.9) -> float:
+        """Eq. 2 (Entanglement Sync): S = alpha * psi_1 * psi_2*.
+
+        Synchronizes two nodes' states, pulling them toward each other.
+
+        Returns:
+            Sync strength S.
+        """
+        if node_a not in self.nodes or node_b not in self.nodes:
+            return 0.0
+
+        a = self.nodes[node_a].state
+        b = self.nodes[node_b].state
+
+        # Complex conjugate product (scalar approximation)
+        psi_1 = a.psi
+        psi_2_conj = -b.psi  # conjugate in simplified real model
+        S = alpha * psi_1 * psi_2_conj
+
+        # Pull states toward each other by S magnitude
+        blend = min(abs(S) * 0.1, 0.3)
+        a_arr = a.to_array()
+        b_arr = b.to_array()
+        new_a = [va * (1 - blend) + vb * blend for va, vb in zip(a_arr, b_arr)]
+        new_b = [vb * (1 - blend) + va * blend for va, vb in zip(a_arr, b_arr)]
+
+        self.nodes[node_a].state = NodeState.from_array(new_a)
+        self.nodes[node_b].state = NodeState.from_array(new_b)
+
+        return S
+
+    # -- intent modulation -------------------------------------------------
+
+    def modulate_intent(
+        self,
+        node_id: str,
+        kappa: float = 0.28,
+        f_base: float = 0.5,
+        delta_f: float = 0.3,
+    ) -> float:
+        """Eq. 3 (Intent Vector Modulation): I = kappa * (f_base + delta_f * coherence).
+
+        Returns modulated intent value for the node.
+        """
+        if node_id not in self.nodes:
+            return 0.0
+
+        coherence = self.phase_coherence()
+        I = kappa * (f_base + delta_f * coherence)
+
+        # Apply intent to psi dimension
+        node = self.nodes[node_id]
+        node.state.psi += I * 0.1
+        return I
+
+    # -- phase coherence (Eq. 11) ------------------------------------------
+
+    def phase_coherence(self) -> float:
+        """Compute phase coherence Gamma across all nodes.
+
+        Gamma = mean(|cos(theta_i - theta_bar)|)
+        where theta_i = atan2(phi, psi) for each node.
+        """
+        if len(self.nodes) < 2:
+            return 1.0
+
+        angles = []
+        for node in self.nodes.values():
+            theta = math.atan2(node.state.phi, node.state.psi + 1e-10)
+            angles.append(theta)
+
+        mean_theta = sum(angles) / len(angles)
+        coherences = [abs(math.cos(a - mean_theta)) for a in angles]
+        gamma = sum(coherences) / len(coherences)
+
+        self._global_tension_history.append(1.0 - gamma)
+        return round(gamma, 4)
+
+    def _compute_phase_coherence_readonly(self) -> float:
+        """Compute phase coherence without mutating global tension history."""
+        if len(self.nodes) < 2:
+            return 1.0
+        angles = []
+        for node in self.nodes.values():
+            theta = math.atan2(node.state.phi, node.state.psi + 1e-10)
+            angles.append(theta)
+        mean_theta = sum(angles) / len(angles)
+        coherences = [abs(math.cos(a - mean_theta)) for a in angles]
+        return round(sum(coherences) / len(coherences), 4)
+
+    # -- attractor detection -----------------------------------------------
+
+    def detect_attractors(
+        self, min_cluster_size: int = 2, max_radius: float = 2.0,
+    ) -> List[Dict]:
+        """Detect attractor manifolds from node state clustering.
+
+        Simple greedy clustering: assign each node to nearest attractor
+        or create a new one if too far from existing.
+        """
+        attractors: List[Dict] = []
+        assigned: Set[str] = set()
+
+        states = [(nid, n.state.to_array()) for nid, n in self.nodes.items()]
+
+        for nid, arr in states:
+            if nid in assigned:
+                continue
+
+            # Check distance to existing attractors
+            matched = False
+            for att in attractors:
+                center = att["center"]
+                dist = math.sqrt(sum((a - c) ** 2 for a, c in zip(arr, center)))
+                if dist <= max_radius:
+                    att["members"].append(nid)
+                    # Update center (running mean)
+                    n = len(att["members"])
+                    att["center"] = [(c * (n - 1) + a) / n for c, a in zip(center, arr)]
+                    assigned.add(nid)
+                    matched = True
+                    break
+
+            if not matched:
+                attractors.append({
+                    "attractor_id": f"attractor_{len(attractors)}",
+                    "center": list(arr),
+                    "members": [nid],
+                })
+                assigned.add(nid)
+
+        # Filter by minimum size
+        return [a for a in attractors if len(a["members"]) >= min_cluster_size]
+
+    # -- glyph formation (Eq. 4/6) ----------------------------------------
+
+    def form_glyph(self, node_id: str) -> Optional[IdentityGlyph]:
+        """Form an identity glyph from a node's tension history.
+
+        Eq. 4: FFT compression
+        Eq. 6: Cocoon stability = integral(|F(k)|^2) < epsilon
+
+        Returns IdentityGlyph if stable, None if unstable.
+        """
+        if node_id not in self.nodes:
+            return None
+
+        history = self.nodes[node_id].tension_history
+        if len(history) < 4:
+            return None
+
+        if HAS_NUMPY:
+            arr = np.array(history)
+            fft = np.fft.fft(arr)
+            components = np.abs(fft[:self.glyph_components]).tolist()
+            energy = float(np.sum(np.abs(fft) ** 2) / len(fft))
+        else:
+            # Fallback: basic DFT for first K components
+            N = len(history)
+            components = []
+            for k in range(min(self.glyph_components, N)):
+                real = sum(history[n] * math.cos(2 * math.pi * k * n / N) for n in range(N))
+                imag = sum(history[n] * math.sin(2 * math.pi * k * n / N) for n in range(N))
+                components.append(math.sqrt(real * real + imag * imag))
+            energy = sum(x * x for x in history) / len(history)
+
+        # Eq. 6: stability criterion
+        stability = 1.0 / (1.0 + energy)
+        if stability < 0.3:
+            return None  # unstable, no glyph
+
+        glyph_id = hashlib.sha256(
+            json.dumps(components, sort_keys=True).encode()
+        ).hexdigest()[:16]
+
+        glyph = IdentityGlyph(
+            glyph_id=f"glyph_{glyph_id}",
+            encoded_tension=components,
+            stability_score=round(stability, 4),
+            source_node=node_id,
+        )
+        self.glyphs.append(glyph)
+        return glyph
+
+    # -- convergence check -------------------------------------------------
+
+    def check_convergence(self, window: int = 10) -> Tuple[bool, float]:
+        """Check if the global system is converging.
+
+        Convergence criterion (Eq. 5):
+          lim sup E[xi_n^2] <= epsilon + eta
+
+        Returns (is_converging, mean_tension).
+        """
+        if len(self._global_tension_history) < window:
+            return False, 1.0
+
+        recent = self._global_tension_history[-window:]
+        mean_tension = sum(recent) / len(recent)
+
+        # Check decreasing trend
+        first_half = sum(recent[:window // 2]) / (window // 2)
+        second_half = sum(recent[window // 2:]) / (window - window // 2)
+        is_decreasing = second_half < first_half
+
+        return (mean_tension < self.tension_threshold and is_decreasing), mean_tension
+
+    # -- entropy measurement (VIVARA-inspired) --------------------------------
+
+    def shannon_entropy(self) -> float:
+        """Compute Shannon entropy of the node state distribution.
+
+        Higher entropy = more diverse cognitive states (exploring).
+        Lower entropy = more uniform states (converged/stuck).
+        """
+        if not self.nodes or not HAS_NUMPY:
+            return 0.0
+
+        # Discretize the psi dimension into bins
+        psi_values = [n.state.psi for n in self.nodes.values()]
+        arr = np.array(psi_values)
+
+        # Histogram with 10 bins
+        counts, _ = np.histogram(arr, bins=10)
+        probs = counts / counts.sum()
+        probs = probs[probs > 0]  # Remove zeros for log
+
+        return -float(np.sum(probs * np.log2(probs)))
+
+    def decoherence_rate(self, window: int = 10) -> float:
+        """Rate of coherence loss over recent history.
+
+        Positive = losing coherence (decoherencing).
+        Negative = gaining coherence (converging).
+        Zero = stable.
+        """
+        if len(self._global_tension_history) < window:
+            return 0.0
+
+        recent = self._global_tension_history[-window:]
+        if len(recent) < 2:
+            return 0.0
+
+        # Linear regression slope of tension over the window
+        n = len(recent)
+        x_mean = (n - 1) / 2.0
+        y_mean = sum(recent) / n
+        numerator = sum((i - x_mean) * (recent[i] - y_mean) for i in range(n))
+        denominator = sum((i - x_mean) ** 2 for i in range(n))
+
+        if denominator == 0:
+            return 0.0
+        return round(numerator / denominator, 6)
+
+    # -- lifeform spawning (VIVARA-inspired) --------------------------------
+
+    def spawn_lifeform(self, seed: str, connect_to: int = 3) -> str:
+        """Spawn a new high-coherence node from a conceptual seed.
+
+        Inspired by VIVARA's lifeform spawning: when a conversation topic
+        generates high enough resonance, it becomes its own node in the web.
+
+        Args:
+            seed: A seed string (e.g., topic name) to generate the node ID
+            connect_to: How many existing nodes to connect to
+
+        Returns:
+            The new node's ID
+        """
+        import hashlib as _hashlib
+        node_id = f"life_{_hashlib.md5(seed.encode()).hexdigest()[:8]}"
+
+        if node_id in self.nodes:
+            return node_id  # Already exists
+
+        # High-coherence birth state (psi=0.8, balanced other dims)
+        state = NodeState(psi=0.8, tau=0.0, chi=0.7, phi=0.3, lam=0.5)
+        self.add_node(node_id, state)
+
+        # Connect to existing nodes (random subset)
+        import random as _random
+        existing = [nid for nid in self.nodes if nid != node_id]
+        peers = _random.sample(existing, min(connect_to, len(existing)))
+        for peer in peers:
+            self.connect(node_id, peer)
+
+        return node_id
+
+    # -- serialization -----------------------------------------------------
+
+    def to_dict(self) -> Dict:
+        """Serialize web state for cocoon packaging."""
+        return {
+            "nodes": {
+                nid: {
+                    "state": n.state.to_array(),
+                    "neighbors": n.neighbors,
+                    "tension_history": n.tension_history[-10:],
+                    "is_collapsed": n.is_collapsed,
+                    "attractor_id": n.attractor_id,
+                }
+                for nid, n in self.nodes.items()
+            },
+            "glyphs": [
+                {
+                    "glyph_id": g.glyph_id,
+                    "encoded_tension": g.encoded_tension,
+                    "stability_score": g.stability_score,
+                    "source_node": g.source_node,
+                }
+                for g in self.glyphs
+            ],
+            "phase_coherence": self._compute_phase_coherence_readonly(),
+            "global_tension_history": self._global_tension_history[-20:],
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "QuantumSpiderweb":
+        """Reconstruct web from serialized state."""
+        web = cls()
+        for nid, ndata in data.get("nodes", {}).items():
+            node = web.add_node(nid, NodeState.from_array(ndata["state"]))
+            node.neighbors = ndata.get("neighbors", [])
+            node.tension_history = ndata.get("tension_history", [])
+            node.is_collapsed = ndata.get("is_collapsed", False)
+            node.attractor_id = ndata.get("attractor_id")
+        for gdata in data.get("glyphs", []):
+            web.glyphs.append(IdentityGlyph(
+                glyph_id=gdata["glyph_id"],
+                encoded_tension=gdata["encoded_tension"],
+                stability_score=gdata["stability_score"],
+                source_node=gdata["source_node"],
+                attractor_signature=gdata.get("attractor_signature"),
+            ))
+        web._global_tension_history = data.get("global_tension_history", [])
+        return web

reasoning_forge/resonant_continuity.py

@@ -0,0 +1,251 @@
+"""Codette Resonant Continuity Engine — The RC+xi Equation
+
+The mathematical core of Codette's recursive cognition framework.
+
+The Resonant Continuity equation computes Ψ_r (psi-resonance):
+    Ψ_r = (emotion × energy × frequency × intent) / ((1 + |darkness|) × speed)
+           × sin(2πt / gravity) + Δmatter
+
+This captures the interaction between:
+    - Emotional state (valence of the reasoning moment)
+    - Cognitive energy (engagement level)
+    - Resonant frequency (harmonic alignment between perspectives)
+    - Intent coefficient (alignment with purpose)
+    - Darkness/uncertainty (noise floor)
+    - Gravitational pull (convergence tendency)
+    - Delta-matter (stochastic creative perturbation)
+
+Additionally implements:
+    - Information-Energy Duality: E_info = ℏω + η·S
+    - Cocoon Stability Field: ∫|F(k,t)|²dk < ε(t,σ)
+    - Gradient Anomaly Suppression for outlier detection
+
+Origin: resonant_continuity_engine.py + Codette_Deep_Simulation_v1.py, rebuilt
+"""
+
+import math
+import time
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+try:
+    import numpy as np
+    HAS_NUMPY = True
+except ImportError:
+    HAS_NUMPY = False
+
+
+@dataclass
+class ResonanceState:
+    """Instantaneous state of the resonant continuity engine."""
+    psi_r: float = 0.0          # Resonant wavefunction value
+    emotion: float = 0.5        # Emotional valence [-1, 1]
+    energy: float = 1.0         # Cognitive energy [0, 2]
+    intent: float = 0.7         # Purpose alignment [0, 1]
+    frequency: float = 1.0      # Harmonic frequency (normalized)
+    darkness: float = 0.1       # Uncertainty/noise [0, 1]
+    coherence: float = 0.5      # Current coherence level
+    stability: bool = True      # Cocoon stability
+    timestamp: float = 0.0
+
+    def to_dict(self) -> Dict:
+        return {k: round(v, 4) if isinstance(v, float) else v
+                for k, v in self.__dict__.items()}
+
+
+class ResonantContinuityEngine:
+    """Computes and tracks the RC+xi resonance wavefunction.
+
+    The engine evolves Ψ_r over time based on epistemic signals
+    from the reasoning process. It detects:
+    - Convergence: when perspectives are harmonizing
+    - Divergence: when creative tension is productive
+    - Instability: when the cocoon needs reinforcement
+    - Resonance peaks: moments of deep insight
+    """
+
+    def __init__(self, gravity: float = 1.2, speed: float = 1.0):
+        self.gravity = gravity       # Convergence tendency
+        self.speed = speed           # Processing rate
+        self.time_index = 0
+        self.history: List[ResonanceState] = []
+
+        # Running state
+        self._emotion = 0.5
+        self._energy = 1.0
+        self._intent = 0.7
+        self._frequency = 1.0
+        self._darkness = 0.1
+
+    def compute_psi(self, emotion: float = None, energy: float = None,
+                    intent: float = None, frequency: float = None,
+                    darkness: float = None,
+                    coherence: float = 0.5,
+                    tension: float = 0.3) -> ResonanceState:
+        """Compute Ψ_r for the current reasoning moment.
+
+        Args:
+            emotion: Emotional valence [-1, 1] (from memory kernel)
+            energy: Cognitive energy [0, 2] (from response quality)
+            intent: Purpose alignment [0, 1] (from query clarity)
+            frequency: Harmonic frequency (from perspective agreement)
+            darkness: Uncertainty level [0, 1] (from tension)
+            coherence: Current epistemic coherence
+            tension: Current epistemic tension
+        """
+        self.time_index += 1
+        t = self.time_index
+
+        # Update state (use provided values or auto-evolve)
+        self._emotion = emotion if emotion is not None else self._auto_emotion(coherence)
+        self._energy = energy if energy is not None else self._auto_energy(coherence, tension)
+        self._intent = intent if intent is not None else self._auto_intent(coherence)
+        self._frequency = frequency if frequency is not None else self._auto_frequency(coherence, tension)
+        self._darkness = darkness if darkness is not None else tension
+
+        # Delta-matter: small stochastic perturbation for creativity
+        if HAS_NUMPY:
+            delta_matter = float(np.random.normal(0.0, 0.005))
+        else:
+            import random
+            delta_matter = random.gauss(0.0, 0.005)
+
+        # The RC+xi equation
+        numerator = self._emotion * self._energy * self._frequency * self._intent
+        denominator = (1.0 + abs(self._darkness)) * self.speed
+        sine_wave = math.sin((2.0 * math.pi * t) / self.gravity)
+
+        psi_r = (numerator / denominator) * sine_wave + delta_matter
+
+        # Cocoon stability check
+        stability = self._check_stability(psi_r, coherence)
+
+        state = ResonanceState(
+            psi_r=psi_r,
+            emotion=self._emotion,
+            energy=self._energy,
+            intent=self._intent,
+            frequency=self._frequency,
+            darkness=self._darkness,
+            coherence=coherence,
+            stability=stability,
+            timestamp=time.time(),
+        )
+
+        self.history.append(state)
+        if len(self.history) > 200:
+            self.history = self.history[-200:]
+
+        return state
+
+    def information_energy(self, angular_freq: float,
+                           entropy: float, eta: float = 1.0) -> float:
+        """Information-Energy Duality: E_info = ℏω + η·S
+
+        Maps between information (entropy) and energy (frequency).
+        """
+        hbar = 1.054571817e-34  # Reduced Planck's constant
+        return hbar * angular_freq + eta * entropy
+
+    def resonance_quality(self) -> float:
+        """Overall resonance quality from recent history [0, 1]."""
+        if len(self.history) < 3:
+            return 0.5
+        recent = self.history[-10:]
+        psi_values = [abs(s.psi_r) for s in recent]
+        coherences = [s.coherence for s in recent]
+
+        # Good resonance: moderate psi, high coherence, stable
+        avg_psi = sum(psi_values) / len(psi_values)
+        avg_coh = sum(coherences) / len(coherences)
+        stability_rate = sum(1 for s in recent if s.stability) / len(recent)
+
+        # Penalize extreme psi (too wild = chaotic)
+        psi_quality = 1.0 / (1.0 + abs(avg_psi - 0.5))
+
+        return 0.4 * avg_coh + 0.3 * stability_rate + 0.3 * psi_quality
+
+    def detect_resonance_peak(self) -> bool:
+        """Detect if we're at a resonance peak (insight moment)."""
+        if len(self.history) < 5:
+            return False
+        recent = [s.psi_r for s in self.history[-5:]]
+        # Peak: value higher than neighbors and above threshold
+        mid = recent[-3]
+        return (abs(mid) > abs(recent[-5]) and
+                abs(mid) > abs(recent[-1]) and
+                abs(mid) > 0.3)
+
+    def convergence_rate(self) -> float:
+        """Rate at which perspectives are converging [-1, 1].
+
+        Positive = converging, negative = diverging.
+        """
+        if len(self.history) < 5:
+            return 0.0
+        recent_coh = [s.coherence for s in self.history[-10:]]
+        if len(recent_coh) < 3:
+            return 0.0
+        # Simple linear trend
+        n = len(recent_coh)
+        x_mean = (n - 1) / 2.0
+        y_mean = sum(recent_coh) / n
+        num = sum((i - x_mean) * (y - y_mean) for i, y in enumerate(recent_coh))
+        den = sum((i - x_mean) ** 2 for i in range(n))
+        return num / den if den > 0 else 0.0
+
+    def get_state(self) -> Dict:
+        """Current engine state for API/session."""
+        current = self.history[-1] if self.history else ResonanceState()
+        return {
+            "psi_r": round(current.psi_r, 4),
+            "resonance_quality": round(self.resonance_quality(), 4),
+            "convergence_rate": round(self.convergence_rate(), 4),
+            "at_peak": self.detect_resonance_peak(),
+            "total_cycles": self.time_index,
+            "stability": current.stability,
+        }
+
+    def _auto_emotion(self, coherence: float) -> float:
+        """Auto-derive emotion from coherence signal."""
+        return max(-1.0, min(1.0, 2.0 * coherence - 1.0))
+
+    def _auto_energy(self, coherence: float, tension: float) -> float:
+        """Energy rises with productive tension, falls with incoherence."""
+        return max(0.1, min(2.0, 0.5 + coherence + 0.5 * tension))
+
+    def _auto_intent(self, coherence: float) -> float:
+        """Intent tracks coherence — clear thinking = clear purpose."""
+        return max(0.1, min(1.0, 0.3 + 0.7 * coherence))
+
+    def _auto_frequency(self, coherence: float, tension: float) -> float:
+        """Frequency from perspective harmony."""
+        return max(0.1, coherence * (1.0 + 0.5 * tension))
+
+    def _check_stability(self, psi_r: float, coherence: float) -> bool:
+        """Check if the reasoning cocoon is stable."""
+        # Unstable if: wild oscillation AND low coherence
+        if len(self.history) < 3:
+            return True
+        recent = [s.psi_r for s in self.history[-3:]]
+        variance = sum((p - psi_r) ** 2 for p in recent) / len(recent)
+        return not (variance > 1.0 and coherence < 0.3)
+
+    def to_dict(self) -> Dict:
+        return {
+            "time_index": self.time_index,
+            "gravity": self.gravity,
+            "speed": self.speed,
+            "history": [s.to_dict() for s in self.history[-20:]],
+        }
+
+    @classmethod
+    def from_dict(cls, d: Dict) -> "ResonantContinuityEngine":
+        engine = cls(gravity=d.get("gravity", 1.2), speed=d.get("speed", 1.0))
+        engine.time_index = d.get("time_index", 0)
+        for h in d.get("history", []):
+            engine.history.append(ResonanceState(**{
+                k: v for k, v in h.items()
+                if k in ResonanceState.__dataclass_fields__
+            }))
+        return engine

reasoning_forge/synthesis_engine.py

@@ -0,0 +1,278 @@
+"""
+Synthesis Engine - Combines all agent perspectives into a unified multi-perspective response.
+
+Takes the concept, all agent analyses, and critic feedback, then produces
+a synthesized explanation that highlights how different perspectives complement
+each other. Includes a Final Integrated Understanding section.
+"""
+
+import random
+import re
+
+
+class SynthesisEngine:
+    """Combines multi-agent analyses into coherent synthesized responses."""
+
+    # Opening templates that set up the multi-perspective frame
+    _opening_templates = [
+        (
+            "To understand '{concept}' with genuine depth, we must examine it through "
+            "multiple lenses, each revealing structure that the others miss."
+        ),
+        (
+            "'{concept}' resists single-framework analysis. Its full meaning emerges "
+            "only at the intersection of several distinct modes of reasoning."
+        ),
+        (
+            "A comprehensive understanding of '{concept}' requires weaving together "
+            "insights from fundamentally different ways of thinking."
+        ),
+        (
+            "No single perspective captures '{concept}' adequately. What follows is "
+            "an integrated analysis drawing on physics, philosophy, ethics, creativity, "
+            "and human experience."
+        ),
+        (
+            "The richness of '{concept}' becomes apparent only when we hold multiple "
+            "analytical frameworks simultaneously and let them inform each other."
+        ),
+    ]
+
+    # Bridge templates connecting one perspective to another
+    _bridge_templates = [
+        "Where {agent_a} reveals {insight_a}, {agent_b} adds the crucial dimension of {insight_b}.",
+        "The {agent_a} analysis and the {agent_b} analysis converge on a shared insight: {shared}.",
+        "What appears as {aspect_a} from the {agent_a} perspective is revealed as {aspect_b} when viewed through {agent_b}.",
+        "The tension between {agent_a}'s emphasis on {focus_a} and {agent_b}'s emphasis on {focus_b} is productive, not contradictory.",
+        "{agent_a} identifies the mechanism; {agent_b} identifies the meaning.",
+        "Combining {agent_a}'s structural analysis with {agent_b}'s human-centered analysis yields a fuller picture.",
+    ]
+
+    # Closing templates for the Final Integrated Understanding
+    _closing_templates = [
+        (
+            "**Final Integrated Understanding:** {concept} is simultaneously a "
+            "{physical_desc}, a {philosophical_desc}, a {ethical_desc}, a "
+            "{creative_desc}, and a {human_desc}. These are not competing descriptions "
+            "but complementary facets of a single complex reality. The most robust "
+            "understanding holds all five in view, using each to compensate for the "
+            "blind spots of the others."
+        ),
+        (
+            "**Final Integrated Understanding:** The multi-perspective analysis reveals "
+            "that {concept} cannot be reduced to any single framework without distortion. "
+            "The physical analysis provides causal grounding, the philosophical analysis "
+            "excavates hidden assumptions, the ethical analysis maps the stakes, the "
+            "creative analysis opens new solution spaces, and the empathic analysis "
+            "anchors everything in lived human experience. Together they constitute "
+            "not a list of separate views but an integrated understanding richer than "
+            "any view alone."
+        ),
+        (
+            "**Final Integrated Understanding:** What emerges from this multi-lens "
+            "examination of {concept} is not a single 'correct' interpretation but a "
+            "structured understanding of how different valid interpretations relate to "
+            "each other. The causal structure identified by physics, the meaning "
+            "structure identified by philosophy, the value structure identified by "
+            "ethics, the possibility structure identified by creative reasoning, and "
+            "the experience structure identified by empathy are all real and all "
+            "essential. Wisdom lies in knowing which lens to apply in which context "
+            "and how to translate insights between them."
+        ),
+    ]
+
+    def synthesize(
+        self,
+        concept: str,
+        analyses: dict[str, str],
+        critique: dict,
+    ) -> str:
+        """Produce a synthesized multi-perspective response.
+
+        Args:
+            concept: The original concept.
+            analyses: Dict mapping agent_name -> analysis_text.
+            critique: Output from CriticAgent.evaluate_ensemble().
+
+        Returns:
+            A synthesized text of 200-400 words.
+        """
+        sections = []
+
+        # 1. Opening
+        opening = random.choice(self._opening_templates).replace("{concept}", concept)
+        sections.append(opening)
+
+        # 2. Per-perspective summaries (compressed)
+        perspective_summaries = self._extract_perspective_summaries(analyses)
+        for agent_name, summary in perspective_summaries.items():
+            sections.append(f"**{agent_name} perspective:** {summary}")
+
+        # 3. Cross-perspective bridges (pick 2-3)
+        bridges = self._generate_bridges(analyses, perspective_summaries)
+        if bridges:
+            sections.append("")  # blank line for readability
+            for bridge in bridges[:2]:
+                sections.append(bridge)
+
+        # 4. Incorporate critic insights
+        critic_section = self._incorporate_critique(critique)
+        if critic_section:
+            sections.append("")
+            sections.append(critic_section)
+
+        # 5. Final Integrated Understanding
+        closing = self._generate_closing(concept, perspective_summaries)
+        sections.append("")
+        sections.append(closing)
+
+        raw_synthesis = "\n\n".join(sections)
+
+        # Trim to 200-400 words if needed
+        return self._trim_to_target(raw_synthesis, min_words=200, max_words=400)
+
+    def _extract_perspective_summaries(
+        self, analyses: dict[str, str]
+    ) -> dict[str, str]:
+        """Extract a 1-2 sentence summary from each agent's analysis."""
+        summaries = {}
+        for agent_name, text in analyses.items():
+            sentences = [s.strip() for s in re.split(r'(?<=[.!?])\s+', text) if s.strip()]
+            if len(sentences) >= 3:
+                # Take the 2nd and 3rd sentences (skip the opening framing)
+                summary = " ".join(sentences[1:3])
+            elif len(sentences) >= 1:
+                summary = sentences[0]
+            else:
+                summary = text[:200]
+
+            # Trim to ~40 words
+            words = summary.split()
+            if len(words) > 45:
+                summary = " ".join(words[:40]) + "..."
+            summaries[agent_name] = summary
+        return summaries
+
+    def _generate_bridges(
+        self,
+        analyses: dict[str, str],
+        summaries: dict[str, str],
+    ) -> list[str]:
+        """Generate cross-perspective bridge statements."""
+        bridges = []
+        agent_names = list(analyses.keys())
+
+        # Define perspective focus areas for bridge generation
+        focus_map = {
+            "Newton": "causal mechanisms and measurable dynamics",
+            "Quantum": "uncertainty, probability, and the limits of definite knowledge",
+            "Ethics": "moral stakes, fairness, and human impact",
+            "Philosophy": "foundational assumptions and the structure of meaning",
+            "DaVinci": "creative possibilities and cross-domain innovation",
+            "Empathy": "emotional reality and lived human experience",
+        }
+
+        # Generate a few meaningful bridges
+        if len(agent_names) >= 2:
+            pairs = []
+            for i in range(len(agent_names)):
+                for j in range(i + 1, len(agent_names)):
+                    pairs.append((agent_names[i], agent_names[j]))
+            random.shuffle(pairs)
+
+            for name_a, name_b in pairs[:3]:
+                focus_a = focus_map.get(name_a, "its analytical focus")
+                focus_b = focus_map.get(name_b, "its analytical focus")
+                template = random.choice(self._bridge_templates)
+
+                bridge = template.format(
+                    agent_a=name_a,
+                    agent_b=name_b,
+                    insight_a=focus_a,
+                    insight_b=focus_b,
+                    shared="the importance of understanding the full system rather than isolated parts",
+                    aspect_a="a structural feature",
+                    aspect_b="a deeply human concern",
+                    focus_a=focus_a,
+                    focus_b=focus_b,
+                )
+                bridges.append(bridge)
+
+        return bridges
+
+    def _incorporate_critique(self, critique: dict) -> str:
+        """Turn critic feedback into a synthesis-relevant observation."""
+        parts = []
+
+        if critique.get("missing_perspectives"):
+            gap = critique["missing_perspectives"][0]
+            # Extract just the perspective name
+            parts.append(
+                f"A notable gap in the analysis is the limited attention to "
+                f"{gap.split('lacks a ')[1].split(' perspective')[0] if 'lacks a ' in gap else 'additional'} "
+                f"dimensions, which future analysis should address."
+            )
+
+        if critique.get("improvement_suggestions"):
+            suggestion = critique["improvement_suggestions"][0]
+            # Compress the suggestion
+            words = suggestion.split()
+            if len(words) > 25:
+                suggestion = " ".join(words[:25]) + "..."
+            parts.append(f"The critic notes: {suggestion}")
+
+        overall = critique.get("overall_quality", 0)
+        if overall >= 0.75:
+            parts.append(
+                "Overall, the multi-perspective ensemble achieves strong analytical "
+                "coverage with good complementarity between viewpoints."
+            )
+        elif overall >= 0.5:
+            parts.append(
+                "The ensemble provides reasonable coverage but would benefit from "
+                "deeper engagement between perspectives."
+            )
+
+        return " ".join(parts) if parts else ""
+
+    def _generate_closing(
+        self, concept: str, summaries: dict[str, str]
+    ) -> str:
+        """Generate the Final Integrated Understanding section."""
+        template = random.choice(self._closing_templates)
+
+        # Build descriptors from available perspectives
+        descriptors = {
+            "physical_desc": "system governed by causal dynamics and conservation principles",
+            "philosophical_desc": "concept whose meaning depends on the framework from which it is examined",
+            "ethical_desc": "domain of genuine moral stakes affecting real people",
+            "creative_desc": "space of untapped possibilities waiting for cross-domain insight",
+            "human_desc": "lived experience with emotional texture that abstract analysis alone cannot capture",
+        }
+
+        result = template
+        result = result.replace("{concept}", concept)
+        for key, value in descriptors.items():
+            result = result.replace("{" + key + "}", value)
+
+        return result
+
+    def _trim_to_target(
+        self, text: str, min_words: int = 200, max_words: int = 400
+    ) -> str:
+        """Trim or pad text to fall within the target word range."""
+        words = text.split()
+
+        if len(words) > max_words:
+            # Trim from the middle sections, preserving opening and closing
+            lines = text.split("\n\n")
+            while len(" ".join(lines).split()) > max_words and len(lines) > 3:
+                # Remove the longest middle section
+                middle_indices = list(range(1, len(lines) - 1))
+                if not middle_indices:
+                    break
+                longest_idx = max(middle_indices, key=lambda i: len(lines[i].split()))
+                lines.pop(longest_idx)
+            return "\n\n".join(lines)
+
+        return text

requirements.txt

@@ -0,0 +1,4 @@
+gradio>=5.0.0
+huggingface_hub>=0.25.0
+numpy
+plotly>=5.0.0