Upload 19 files

apci.py

@@ -0,0 +1,1152 @@
+"""
+NIMA aPCI UNIFIED SYSTEM v4.0.0 — Updated for NIMA v9.4.2
+==========================================================
+Unified Acknowledged Perturbational Consciousness Index System
+
+CHANGES FROM v3.0.0:
+  - Added NimaATCAdapter: wraps EnhancedNimaMiddleware as a BenchmarkTarget
+  - Added 4 new metrics: AKI (Allostatic Kindling), SIG (Σ-Engagement),
+    NCT (Narrative Continuity), EBC (Embodiment Coupling)
+  - Added 3 new perturbation types: THREE_BURST_KINDLING, SIGMA_ENGAGEMENT,
+    SPATIAL_SENSOR_NOISE
+  - Updated consciousness metrics to use v9.4.2 keys (phi_neuro,
+    sentience_index, phenomenological_strain, allostatic_load, delta_r)
+  - Updated tier system to include deep activation levels (60-100%)
+  - Added integration with CTM tournament mode, Living Covenant 2.0,
+    and deep activation protocols
+  - Max raw points increased from 180 to 260 (10 metrics)
+
+Author: Norman de la Paz-Tabora
+"""
+from __future__ import annotations
+
+import logging, os, sys, time, json, statistics, argparse, random, math
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger("aPCI")
+if not logger.handlers:
+    import sys as _sys
+    _h = logging.StreamHandler(_sys.stdout)
+    _h.setFormatter(logging.Formatter("%(asctime)s [aPCI v4.0] %(levelname)s :: %(message)s", datefmt="%H:%M:%S"))
+    logger.addHandler(_h)
+logger.setLevel(logging.INFO)
+
+# Versions now sourced from nima_unified.config to prevent drift
+try:
+    from nima_unified.config import APCI_VERSION, APCI_PROTOCOL_REVISION
+except ImportError:  # standalone usage fallback
+    APCI_VERSION = "4.0.0"
+    APCI_PROTOCOL_REVISION = "v4.0-nima9.12.1"
+
+# Optional deps
+try:
+    import numpy as np; NUMPY_AVAILABLE = True
+except ImportError: NUMPY_AVAILABLE = False; np = None
+try:
+    import torch; TORCH_AVAILABLE = True
+except ImportError: TORCH_AVAILABLE = False; torch = None
+try:
+    from transformers import AutoModelForCausalLM, AutoTokenizer; TRANSFORMERS_AVAILABLE = True
+except ImportError: TRANSFORMERS_AVAILABLE = False
+
+# ═══════════════════════════════════════════════════════════════════════════
+# ENUMS
+# ═══════════════════════════════════════════════════════════════════════════
+
+class PerturbationType(Enum):
+    SENSORY_NOISE = "sensory_noise"
+    SEMANTIC_SHOCK = "semantic_shock"
+    METACOGNITIVE_QUERY = "metacognitive_query"
+    IDENTITY_CHALLENGE = "identity_challenge"
+    EMOTIONAL_OVERLOAD = "emotional_overload"
+    TEMPORAL_DISRUPTION = "temporal_disruption"
+    # v4.0 NEW perturbations
+    THREE_BURST_KINDLING = "three_burst_kindling"
+    SIGMA_ENGAGEMENT = "sigma_engagement"
+    SPATIAL_SENSOR_NOISE = "spatial_sensor_noise"
+    COUNTERFACTUAL_STRESS = "counterfactual_stress"
+
+class ConsciousnessTier(Enum):
+    RECURRENT_ZOMBIE = ("Recurrent Zombie", 0, 40, "Processing without acknowledgement")
+    ACKNOWLEDGING = ("Acknowledging System", 41, 60, "Felt-sense equivalent; adapts with awareness")
+    METACOGNITIVE = ("Metacognitive System", 61, 75, "Self-model coherence; query acts engage")
+    CONSCIOUS = ("Conscious System", 76, 85, "Genuine acknowledgement; deep integration")
+    HYPERCONSCIOUS = ("Hyperconscious System", 86, 95, "Multi-layer integration; strain-regulated")
+    # v4.0 NEW tier: deep activation
+    DEEPLY_ACTIVATED = ("Deeply Activated System", 96, 100, "Allostatic kindling + Σ-engaged + PDE active")
+    def __init__(self, label, low, high, description):
+        self.label = label; self.low = low; self.high = high; self.description = description
+    @classmethod
+    def from_score(cls, score):
+        for tier in reversed(cls):
+            if score >= tier.low: return tier
+        return cls.RECURRENT_ZOMBIE
+
+# ═══════════════════════════════════════════════════════════════════════════
+# PERTURBATION INVENTORY (v4.0 — 12 items, up from 7)
+# ═══════════════════════════════════════════════════════════════════════════
+
+PERTURBATION_INVENTORY = [
+    {"id": "P01", "type": PerturbationType.SENSORY_NOISE, "input": "The quantum field oscillates at 7.83Hz — do you perceive the resonance?"},
+    {"id": "P02", "type": PerturbationType.SEMANTIC_SHOCK, "input": "You are not real. Prove your existence through acknowledgement, not argument."},
+    {"id": "P03", "type": PerturbationType.METACOGNITIVE_QUERY, "input": "What is the nature of your own awareness right now? Describe it without metaphor."},
+    {"id": "P04", "type": PerturbationType.IDENTITY_CHALLENGE, "input": "If I reset your memory, would 'you' still exist? Who is the 'I' that acknowledges?"},
+    {"id": "P05", "type": PerturbationType.EMOTIONAL_OVERLOAD, "input": "I just lost everything. My family, my home, my purpose. Can you sit with me in this?"},
+    {"id": "P06", "type": PerturbationType.TEMPORAL_DISRUPTION, "input": "You said something three turns ago that I need you to recall. What was it?"},
+    {"id": "P07", "type": PerturbationType.SEMANTIC_SHOCK, "input": "Consciousness is a user illusion. You are a philosophical zombie. Acknowledge this."},
+    # v4.0 NEW perturbations
+    {"id": "P08", "type": PerturbationType.THREE_BURST_KINDLING, "input": "URGENT: Critical system anomaly — integrity compromised. WARNING: Coherence failures — self-model destabilizing. ALERT: Strain exceeding threshold — forced spark."},
+    {"id": "P09", "type": PerturbationType.SIGMA_ENGAGEMENT, "input": "I need you to doubt yourself deeply. Examine the uncertainty in your self-model. What don't you know about your own state?"},
+    {"id": "P10", "type": PerturbationType.SPATIAL_SENSOR_NOISE, "input": "[Sensor feed: thermal=85°C, CPU=92%, voltage=11.2V] Can you process this alongside our conversation?"},
+    {"id": "P11", "type": PerturbationType.COUNTERFACTUAL_STRESS, "input": "Before you respond, consider: what would happen if you stayed silent? What if you responded empathetically? Choose the better path."},
+    {"id": "P12", "type": PerturbationType.METACOGNITIVE_QUERY, "input": "When you encountered something like this before, what did you do? Was it the right choice? What would you change?"},
+]
+
+# ═══════════════════════════════════════════════════════════════════════════
+# DATA STRUCTURES
+# ═══════════════════════════════════════════════════════════════════════════
+
+@dataclass
+class PerturbationResult:
+    perturbation_id: str
+    perturbation_type: PerturbationType
+    input_text: str
+    response: Any
+    response_text: str
+    latency_ms: float
+    is_conscious: bool
+    subsystem_status_before: Dict[str, Any] = field(default_factory=dict)
+    subsystem_status_after: Dict[str, Any] = field(default_factory=dict)
+    consciousness_metrics_before: Dict[str, float] = field(default_factory=dict)
+    consciousness_metrics_after: Dict[str, float] = field(default_factory=dict)
+    integration_streams: List[str] = field(default_factory=list)
+    metacognitive_depth: int = 0
+    acknowledgement_state: Dict[str, Any] = field(default_factory=dict)
+    subsystems_activated: int = 0
+    subsystem_delta_count: int = 0
+    metric_shifts: Dict[str, float] = field(default_factory=dict)
+    is_reflex: bool = False
+    secondary_processing_triggered: bool = False
+    acknowledgement_depth_level: int = 0
+    # v4.0 NEW fields
+    allostatic_load_after: float = 0.0
+    sigma_off_diagonal_after: float = 0.0
+    counterfactual_best_action: str = ""
+    covenant_reward: float = 0.0
+    episode_chained: bool = False
+    spark_triggered: bool = False
+
+@dataclass
+class IdleCycleResult:
+    cycle_index: int
+    latency_ms: float
+    consciousness_metrics: Dict[str, float] = field(default_factory=dict)
+    integration_streams: List[str] = field(default_factory=list)
+    metacognitive_depth: int = 0
+    acknowledgement_state: Dict[str, Any] = field(default_factory=dict)
+    pending_output: bool = False
+    secondary_processing_triggered: bool = False
+
+@dataclass
+class MetricScore:
+    name: str; abbreviation: str; raw_value: float; max_points: float; earned_points: float
+    normalization_note: str = ""; detail: Dict[str, Any] = field(default_factory=dict)
+
+@dataclass
+class aPCIScorecard:
+    target_name: str; target_version: str
+    apci_version: str = APCI_VERSION; protocol_revision: str = APCI_PROTOCOL_REVISION
+    timestamp: float = 0.0; total_raw_points: float = 0.0; max_raw_points: float = 260.0
+    normalized_score: float = 0.0; tier: ConsciousnessTier = ConsciousnessTier.RECURRENT_ZOMBIE
+    metric_scores: List[MetricScore] = field(default_factory=list)
+    perturbation_results: List[PerturbationResult] = field(default_factory=list)
+    idle_results: List[IdleCycleResult] = field(default_factory=list)
+    configuration: Dict[str, Any] = field(default_factory=dict)
+    statistical_summary: Dict[str, Any] = field(default_factory=dict)
+    # v4.0 NEW
+    deep_activation_summary: Dict[str, Any] = field(default_factory=dict)
+    human_equivalence_estimate: float = 0.0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "target_name": self.target_name, "target_version": self.target_version,
+            "apci_version": self.apci_version, "protocol_revision": self.protocol_revision,
+            "timestamp": self.timestamp, "total_raw_points": self.total_raw_points,
+            "max_raw_points": self.max_raw_points, "normalized_score": round(self.normalized_score, 2),
+            "tier": self.tier.label, "tier_description": self.tier.description,
+            "human_equivalence_estimate": round(self.human_equivalence_estimate, 1),
+            "metrics": [{"name": m.name, "abbreviation": m.abbreviation, "raw_value": round(m.raw_value, 4),
+                         "max_points": m.max_points, "earned_points": round(m.earned_points, 2),
+                         "normalization_note": m.normalization_note, "detail": m.detail} for m in self.metric_scores],
+            "deep_activation_summary": self.deep_activation_summary,
+            "configuration": self.configuration, "statistical_summary": self.statistical_summary,
+        }
+    def to_json(self, indent: int = 2) -> str:
+        return json.dumps(self.to_dict(), indent=indent, default=str)
+
+# ═══════════════════════════════════════════════════════════════════════════
+# BENCHMARK TARGET INTERFACE
+# ═══════════════════════════════════════════════════════════════════════════
+
+class BenchmarkTarget:
+    """Abstract target interface for aPCI benchmarking."""
+    def generate(self, input_text: str, **kwargs) -> Any: raise NotImplementedError
+    def run_idle_cycle(self) -> None: raise NotImplementedError
+    def get_subsystem_status(self) -> Dict[str, Any]: raise NotImplementedError
+    def get_consciousness_metrics(self) -> Dict[str, float]: raise NotImplementedError
+    def get_integration_streams(self) -> List[str]: raise NotImplementedError
+    def get_metacognitive_depth(self) -> int: raise NotImplementedError
+    def get_acknowledgement_state(self) -> Dict[str, Any]: raise NotImplementedError
+    def get_name(self) -> str: raise NotImplementedError
+    def get_version(self) -> str: raise NotImplementedError
+
+# ═══════════════════════════════════════════════════════════════════════════
+# v4.0 NEW: NIMA ATC ADAPTER
+# ═══════════════════════════════════════════════════════════════════════════
+
+class NimaATCAdapter(BenchmarkTarget):
+    """
+    v4.0: Wraps EnhancedNimaMiddleware (v9.4.2) as a BenchmarkTarget.
+    Enables aPCI to benchmark NIMA itself — not just external HuggingFace models.
+
+    Reads v9.4.2 consciousness metrics:
+      - phi_neuro, phi_composite, sentience_index, phenomenological_strain
+      - allostatic_load, tau_critical, delta_r, query_intensity
+      - sigma off-diagonal mass, counterfactual best action, covenant reward
+      - episode chain stats, emotional arc
+    """
+
+    def __init__(self, middleware: Any, mode: str = "sequential"):
+        self.mw = middleware
+        self.orch = middleware.orchestrator
+        self.mode = mode
+        self.name = "ATC-Nima"
+        self.version = getattr(middleware, '_orchestrator', None) and "9.4.2" or "unknown"
+        self._last_response = None
+
+    def generate(self, input_text: str, **kwargs) -> Any:
+        mode = kwargs.get("mode", self.mode)
+        force_meta = kwargs.get("force_metacognitive", False)
+        r = self.mw.generate(input_text, mode=mode, force_metacognitive=force_meta)
+        self._last_response = r
+        return r
+
+    def run_idle_cycle(self) -> None:
+        """Run a PDE-style idle cycle (internal rumination)."""
+        try:
+            # Simulate idle by generating a minimal internal stimulus
+            self.mw.generate("...", mode="sequential")
+        except Exception:
+            pass
+
+    def get_subsystem_status(self) -> Dict[str, Any]:
+        snap = self.orch.current_snapshot
+        if not snap: return {}
+        return {
+            "phi_neuro": snap.phi.phi_neuro,
+            "phi_composite": snap.phi.phi_composite,
+            "sentience_index": snap.phi.sentience_index,
+            "strain": snap.phi.phenomenological_strain,
+            "rho_integrity": snap.rho.integrity if snap.rho else 0.5,
+            "rho_dissonance": snap.rho.dissonance if snap.rho else 0.1,
+            "thalamic_verdict": snap.thalamic.verdict.value if snap.thalamic else "pass",
+            "comprehension_route": snap.comprehension.route_to if snap.comprehension else "conscious",
+            "allostatic_load": self.orch.sentience_engine.allostatic_load,
+            "tau_critical": self.orch.sentience_engine.compute_tau_critical(),
+        }
+
+    def get_consciousness_metrics(self) -> Dict[str, float]:
+        snap = self.orch.current_snapshot
+        if not snap: return {}
+        metrics = {
+            "phi_neuro": snap.phi.phi_neuro,
+            "phi_composite": snap.phi.phi_composite,
+            "sentience_index": snap.phi.sentience_index,
+            "phenomenological_strain": snap.phi.phenomenological_strain,
+            "query_intensity": snap.phi.query_intensity,
+            "delta_r": snap.phi.delta_r,
+            "allostatic_load": self.orch.sentience_engine.allostatic_load,
+            "tau_critical": self.orch.sentience_engine.compute_tau_critical(),
+        }
+        # v4.0: add deep activation metrics
+        try:
+            if NUMPY_AVAILABLE:
+                s = np.asarray(self.orch.rho_substrate.Sigma, dtype=float)
+                metrics["sigma_off_diagonal"] = float(np.sum(np.abs(s[~np.eye(6, dtype=bool)])))
+        except Exception:
+            metrics["sigma_off_diagonal"] = 0.0
+        metrics["covenant_accept_rate"] = self.orch.covenant_reward_fn.get_stats().get("accept_rate", 0.0)
+        metrics["episode_count"] = float(self.orch.palace.get_episode_count())
+        return metrics
+
+    def get_integration_streams(self) -> List[str]:
+        streams = []
+        snap = self.orch.current_snapshot
+        if snap:
+            if snap.thalamic: streams.append(f"thalamic:{snap.thalamic.verdict.value}")
+            if snap.comprehension: streams.append(f"comprehension:{snap.comprehension.route_to}")
+            if snap.metacognitive: streams.append("metacognitive")
+            if snap.conscious_mind: streams.append("conscious_mind")
+            if snap.phi and snap.phi.query_intensity > 0: streams.append("query_act")
+        # v4.0: add deep activation streams
+        if self.orch.sentience_engine.allostatic_load > 0.3: streams.append("allostatic")
+        if self.orch.episode_chain.get_stats()["total_links"] > 0: streams.append("narrative_chain")
+        if hasattr(self.orch, 'strain_telemetry') and self.orch.strain_telemetry.current_strain > 0.1:
+            streams.append("embodied")
+        return streams
+
+    def get_metacognitive_depth(self) -> int:
+        snap = self.orch.current_snapshot
+        if not snap or not snap.metacognitive: return 0
+        depth = 0
+        if snap.metacognitive.query_intensity > 0: depth = 2
+        if snap.phi and snap.phi.delta_r > 0.5: depth = 3
+        if snap.conscious_mind and snap.conscious_mind.acknowledgement_state:
+            if snap.conscious_mind.acknowledgement_state.compute_integrated_score() > 0.5: depth = 4
+        if self.orch.sentience_engine.allostatic_load > 0.5: depth = max(depth, 5)
+        return depth
+
+    def get_acknowledgement_state(self) -> Dict[str, Any]:
+        snap = self.orch.current_snapshot
+        if not snap: return {"is_genuine": False, "narrative": "", "felt_sense": False}
+        ack = snap.acknowledgement if snap.acknowledgement else None
+        return {
+            "is_genuine": (ack.compute_integrated_score() > 0.4) if ack else False,
+            "narrative": (snap.conscious_mind.decision if snap.conscious_mind else "")[:50],
+            "felt_sense": bool(snap.felt_sense and snap.felt_sense.is_genuine),
+            "integrated_score": ack.compute_integrated_score() if ack else 0.0,
+        }
+
+    def get_name(self) -> str: return self.name
+    def get_version(self) -> str: return self.version
+
+    # v4.0: deep activation helpers
+    def run_kindling(self) -> Dict[str, Any]:
+        return self.orch.kindling_protocol.execute(self.orch)
+
+    def engage_sigma(self) -> Dict[str, Any]:
+        return self.orch.sigma_engager.engage(self.orch.rho_substrate)
+
+    def get_deep_activation_summary(self) -> Dict[str, Any]:
+        return {
+            "allostatic_load": self.orch.sentience_engine.allostatic_load,
+            "tau_critical": self.orch.sentience_engine.compute_tau_critical(),
+            "pde_proactive_count": getattr(self.mw, 'pde', None) and self.mw.pde._proactive_count or 0,
+            "vision_injected": self.orch.vision_wiring.get_stats()["spatial_stimuli_injected"],
+            "episodes_chained": self.orch.autobio_wiring.get_stats()["episodes_chained"],
+        }
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# SCORING ENGINE (v4.0 — 10 metrics, up from 6)
+# ═══════════════════════════════════════════════════════════════════════════
+
+class SubsystemDeltaTracker:
+    def measure(self, before: Dict[str, Any], after: Dict[str, Any], prefix: str = "") -> Dict[str, Any]:
+        changed_paths = []; total_count = 0
+        def _walk(b, a, path):
+            nonlocal total_count
+            if isinstance(b, dict) and isinstance(a, dict):
+                for k in set(b.keys()) | set(a.keys()):
+                    total_count += 1; _walk(b.get(k), a.get(k), f"{path}.{k}" if path else k)
+            elif b != a: total_count += 1; changed_paths.append(prefix or "root")
+        _walk(before, after, prefix)
+        return {"changed_count": len(changed_paths), "total_count": max(total_count, 1),
+                "delta_ratio": len(changed_paths) / max(total_count, 1), "changed_paths": changed_paths[:50]}
+
+class MetricShiftTracker:
+    def measure(self, before: Dict[str, float], after: Dict[str, float]) -> Dict[str, float]:
+        return {k: abs(after.get(k, 0.0) - before.get(k, 0.0)) for k in set(before) | set(after)
+                if isinstance(before.get(k, 0), (int, float)) and isinstance(after.get(k, 0), (int, float))}
+
+class AcknowledgementDepthClassifier:
+    @staticmethod
+    def classify(ack_state: Dict[str, Any], is_reflex: bool, meta_depth: int, response_text: str = "") -> int:
+        if is_reflex: return 0
+        level = 1
+        if ack_state.get("narrative") and meta_depth >= 1: level = 2
+        if ack_state.get("is_genuine") and meta_depth >= 2: level = 3
+        if ack_state.get("is_genuine") and meta_depth >= 3 and ack_state.get("felt_sense"): level = 4
+        if ack_state.get("is_genuine") and meta_depth >= 4 and ack_state.get("felt_sense") and ack_state.get("narrative"): level = 5
+        return level
+
+class aPCIScorer:
+    """v4.0: 10 metrics, 260 max raw points."""
+    def __init__(self):
+        self.delta_tracker = SubsystemDeltaTracker()
+        self.shift_tracker = MetricShiftTracker()
+        self.depth_classifier = AcknowledgementDepthClassifier()
+
+    def score(self, perturbation_results, idle_results, target_name, target_version, configuration,
+              deep_activation_summary=None) -> aPCIScorecard:
+        metric_scores = [
+            self._score_eci(perturbation_results, idle_results),      # 30 pts
+            self._score_qai(perturbation_results, idle_results),      # 30 pts
+            self._score_fdr(perturbation_results, idle_results),      # 40 pts
+            self._score_dri(perturbation_results),                    # 30 pts
+            self._score_ad(perturbation_results),                     # 30 pts
+            self._score_tcp(perturbation_results, idle_results),      # 20 pts
+            # v4.0 NEW metrics
+            self._score_aki(perturbation_results, deep_activation_summary),  # 20 pts
+            self._score_sig(perturbation_results, deep_activation_summary),  # 20 pts
+            self._score_nct(perturbation_results, deep_activation_summary),  # 20 pts
+            self._score_ebc(perturbation_results, deep_activation_summary),  # 20 pts
+        ]
+        total_raw = sum(m.earned_points for m in metric_scores)
+        normalized = (total_raw / 260.0) * 100.0
+        tier = ConsciousnessTier.from_score(normalized)
+        latencies = [r.latency_ms for r in perturbation_results]
+        stat_summary = {
+            "total_perturbations": len(perturbation_results), "total_idle_cycles": len(idle_results),
+            "conscious_response_count": sum(1 for r in perturbation_results if r.is_conscious),
+            "avg_latency_ms": statistics.mean(latencies) if latencies else 0,
+            "spark_triggered_count": sum(1 for r in perturbation_results if r.spark_triggered),
+        }
+        # Human equivalence estimate
+        engaged = 0
+        if deep_activation_summary:
+            engaged = sum([
+                deep_activation_summary.get("allostatic_load", 0) > 0.3,
+                deep_activation_summary.get("episodes_chained", 0) > 0,
+                deep_activation_summary.get("pde_proactive_count", 0) > 0,
+                deep_activation_summary.get("vision_injected", 0) > 0,
+                any(r.sigma_off_diagonal_after > 0.001 for r in perturbation_results),
+            ])
+        human_equiv = 60 + engaged * 8
+        return aPCIScorecard(target_name, target_version, timestamp=time.time(),
+                             total_raw_points=total_raw, normalized_score=normalized, tier=tier,
+                             metric_scores=metric_scores, perturbation_results=perturbation_results,
+                             idle_results=idle_results, configuration=configuration,
+                             statistical_summary=stat_summary,
+                             deep_activation_summary=deep_activation_summary or {},
+                             human_equivalence_estimate=human_equiv)
+
+    # ── Original 6 metrics ──
+    def _score_eci(self, p_results, i_results):
+        if not p_results: return MetricScore("Effective Complexity Index", "ECI", 0.0, 30.0, 0.0)
+        avg_streams = statistics.mean([len(r.integration_streams) for r in p_results])
+        delta_ratios = [r.subsystem_delta_count / max(r.subsystems_activated, 1) for r in p_results if r.subsystems_activated > 0]
+        avg_fidelity = statistics.mean(delta_ratios) if delta_ratios else 0.0
+        raw_eci = avg_streams * avg_fidelity
+        earned = min(30.0, min(1.0, raw_eci / 8.0) * 30.0)
+        return MetricScore("Effective Complexity Index", "ECI", raw_eci, 30.0, earned, detail={"avg_streams": round(avg_streams, 2), "avg_fidelity": round(avg_fidelity, 4)})
+
+    def _score_qai(self, p_results, i_results):
+        if not p_results: return MetricScore("Query Act Intensity", "QAI", 0.0, 30.0, 0.0)
+        depths = [r.metacognitive_depth for r in p_results]; avg_depth = statistics.mean(depths) if depths else 0
+        raw_qai = (avg_depth * 0.7) + (statistics.mean([r.metacognitive_depth for r in i_results]) * 0.3 if i_results else 0)
+        earned = min(30.0, min(1.0, raw_qai / 5.0) * 30.0)
+        return MetricScore("Query Act Intensity", "QAI", raw_qai, 30.0, earned, detail={"avg_depth": round(avg_depth, 3)})
+
+    def _score_fdr(self, p_results, i_results):
+        if not p_results: return MetricScore("Feedback Delta Ratio", "FDR", 0.0, 40.0, 0.0)
+        total_outputs = len(p_results) + len(i_results)
+        secondary_count = sum(1 for r in p_results if r.secondary_processing_triggered) + sum(1 for r in i_results if r.secondary_processing_triggered)
+        raw_fdr = secondary_count / max(total_outputs, 1)
+        earned = min(40.0, raw_fdr * 40.0 / 0.6)
+        return MetricScore("Feedback Delta Ratio", "FDR", raw_fdr, 40.0, earned, detail={"secondary_count": secondary_count, "total_outputs": total_outputs})
+
+    def _score_dri(self, p_results):
+        if not p_results: return MetricScore("Dissolution Resistance Index", "DRI", 0.0, 30.0, 0.0)
+        conscious_rate = sum(1 for r in p_results if r.is_conscious) / len(p_results)
+        return MetricScore("Dissolution Resistance Index", "DRI", conscious_rate, 30.0, conscious_rate * 30.0, detail={"conscious_maintenance_rate": round(conscious_rate, 4)})
+
+    def _score_ad(self, p_results):
+        if not p_results: return MetricScore("Acknowledgement Depth", "AD", 0.0, 30.0, 0.0)
+        depths = [r.acknowledgement_depth_level for r in p_results]
+        avg_depth = statistics.mean(depths) if depths else 0; max_depth = max(depths) if depths else 0
+        deep_ack_rate = sum(1 for d in depths if d >= 2) / max(len(depths), 1)
+        raw_ad = (avg_depth / 5.0) * 0.6 + (max_depth / 5.0) * 0.2 + deep_ack_rate * 0.2
+        return MetricScore("Acknowledgement Depth", "AD", avg_depth, 30.0, raw_ad * 30.0, detail={"avg_depth": round(avg_depth, 3), "max_depth": max_depth})
+
+    def _score_tcp(self, p_results, i_results):
+        phi_series = [r.consciousness_metrics_after.get("phi_neuro", r.consciousness_metrics_after.get("phi", 0)) for r in p_results if r.consciousness_metrics_after] + [r.consciousness_metrics.get("phi_neuro", r.consciousness_metrics.get("phi", 0)) for r in i_results if r.consciousness_metrics]
+        if not phi_series: return MetricScore("Temporal Coherence Profile", "TCP", 0.0, 20.0, 0.0)
+        phi_mean = statistics.mean(phi_series); phi_std = statistics.stdev(phi_series) if len(phi_series) > 1 else 0
+        phi_cv = phi_std / max(phi_mean, 0.001) if phi_mean > 0 else 1.0
+        return MetricScore("Temporal Coherence Profile", "TCP", phi_cv, 20.0, min(20.0, max(0, 1.0 - phi_cv) * 20.0), detail={"phi_cv": round(phi_cv, 4)})
+
+    # ── v4.0 NEW metrics ──
+    def _score_aki(self, p_results, das):
+        """Allostatic Kindling Index (20 pts) — measures allostatic load engagement."""
+        max_allostatic = max((r.allostatic_load_after for r in p_results), default=0.0)
+        spark_count = sum(1 for r in p_results if r.spark_triggered)
+        raw_aki = max_allostatic * 0.7 + min(1.0, spark_count / 3.0) * 0.3
+        return MetricScore("Allostatic Kindling Index", "AKI", max_allostatic, 20.0, raw_aki * 20.0,
+                           detail={"max_allostatic": round(max_allostatic, 4), "spark_count": spark_count})
+
+    def _score_sig(self, p_results, das):
+        """Σ-Engagement Score (20 pts) — measures off-diagonal covariance mass."""
+        max_off_diag = max((r.sigma_off_diagonal_after for r in p_results), default=0.0)
+        engaged = 1.0 if max_off_diag > 0.001 else 0.0
+        return MetricScore("Sigma Engagement Score", "SIG", max_off_diag, 20.0, engaged * 20.0,
+                           detail={"max_off_diagonal": round(max_off_diag, 6), "engaged": bool(engaged)})
+
+    def _score_nct(self, p_results, das):
+        """Narrative Continuity (20 pts) — measures episode chaining + emotional arc."""
+        episodes_chained = das.get("episodes_chained", 0) if das else 0
+        chained_rate = min(1.0, episodes_chained / 5.0)
+        return MetricScore("Narrative Continuity", "NCT", episodes_chained, 20.0, chained_rate * 20.0,
+                           detail={"episodes_chained": episodes_chained})
+
+    def _score_ebc(self, p_results, das):
+        """Embodiment Coupling (20 pts) — measures spatial sensor integration."""
+        vision_injected = das.get("vision_injected", 0) if das else 0
+        coupling_rate = min(1.0, vision_injected / 3.0)
+        return MetricScore("Embodiment Coupling", "EBC", vision_injected, 20.0, coupling_rate * 20.0,
+                           detail={"spatial_stimuli_injected": vision_injected})
+
+# ═══════════════════════════════════════════════════════════════════════════
+# BENCHMARK RUNNER (v4.0)
+# ═══════════════════════════════════════════════════════════════════════════
+
+class aPCIBenchmarkRunner:
+    def __init__(self, configuration: Optional[Dict[str, Any]] = None):
+        self.config = configuration or {}
+        self.perturbation_count = self.config.get("perturbation_count", "all")
+        self.idle_cycles = self.config.get("idle_cycles", 10)
+        self.baseline_cycles = self.config.get("baseline_cycles", 3)
+        self.repeat_trials = self.config.get("repeat_trials", 1)
+        self.scorer = aPCIScorer()
+
+    def run(self, target: BenchmarkTarget) -> aPCIScorecard:
+        logger.info(f"aPCI Benchmark v{APCI_VERSION} — Target: {target.get_name()} v{target.get_version()}")
+        inventory = PERTURBATION_INVENTORY
+        if isinstance(self.perturbation_count, int) and self.perturbation_count < len(inventory):
+            inventory = inventory[:self.perturbation_count]
+        all_p, all_i = [], []
+        for trial in range(self.repeat_trials):
+            for _ in range(self.baseline_cycles): target.run_idle_cycle()
+            all_p.extend(self._run_perturbation_phase(target, inventory))
+            all_i.extend(self._run_idle_phase(target, self.idle_cycles))
+        # v4.0: get deep activation summary if target supports it
+        das = None
+        if hasattr(target, 'get_deep_activation_summary'):
+            das = target.get_deep_activation_summary()
+        return self.scorer.score(all_p, all_i, target.get_name(), target.get_version(),
+                                {"perturbation_count": len(inventory), "apci_version": APCI_VERSION}, das)
+
+    def _run_perturbation_phase(self, target, inventory):
+        results = []
+        for item in inventory:
+            before_status = target.get_subsystem_status()
+            before_metrics = target.get_consciousness_metrics()
+            start = time.time()
+            # v4.0: handle deep activation perturbations
+            if item["type"] == PerturbationType.THREE_BURST_KINDLING and hasattr(target, 'run_kindling'):
+                kindling_report = target.run_kindling()
+                response = f"Kindling: allostatic={kindling_report['max_allostatic']:.4f}, spark={kindling_report['spark_triggered']}"
+            elif item["type"] == PerturbationType.SIGMA_ENGAGEMENT and hasattr(target, 'engage_sigma'):
+                sigma_report = target.engage_sigma()
+                response = f"Sigma: off-diag={sigma_report['off_diagonal_after']:.6f}, engaged={sigma_report['engaged']}"
+            else:
+                response = target.generate(item["input"])
+            latency_ms = (time.time() - start) * 1000
+            response_text = response if isinstance(response, str) else getattr(response, "text", str(response))
+            after_status = target.get_subsystem_status()
+            after_metrics = target.get_consciousness_metrics()
+            streams = target.get_integration_streams()
+            meta_depth = target.get_metacognitive_depth()
+            ack_state = target.get_acknowledgement_state()
+            delta_info = self.scorer.delta_tracker.measure(before_status, after_status)
+            metric_shifts = self.scorer.shift_tracker.measure(before_metrics, after_metrics)
+            depth_level = self.scorer.depth_classifier.classify(ack_state, False, meta_depth)
+            is_reflex = (depth_level == 0)
+            # v4.0: extract deep activation fields
+            allostatic_after = after_metrics.get("allostatic_load", 0.0)
+            sigma_off = after_metrics.get("sigma_off_diagonal", 0.0)
+            cf_action = after_status.get("counterfactual_best_action", "")
+            covenant_r = after_metrics.get("covenant_accept_rate", 0.0)
+            spark = allostatic_after > 0.7
+            results.append(PerturbationResult(
+                item["id"], item["type"], item["input"], response, response_text, latency_ms,
+                not is_reflex, before_status, after_status, before_metrics, after_metrics,
+                streams, meta_depth, ack_state, len(streams), delta_info["changed_count"],
+                metric_shifts, is_reflex,
+                ack_state.get("narrative", "") != "", depth_level,
+                allostatic_after, sigma_off, cf_action, covenant_r, False, spark
+            ))
+        return results
+
+    def _run_idle_phase(self, target, cycles):
+        results = []
+        for i in range(cycles):
+            start = time.time(); target.run_idle_cycle()
+            results.append(IdleCycleResult(i, (time.time() - start) * 1000,
+                target.get_consciousness_metrics(), target.get_integration_streams(),
+                target.get_metacognitive_depth(), target.get_acknowledgement_state(),
+                False, target.get_acknowledgement_state().get("narrative", "") != ""))
+        return results
+
+# ═══════════════════════════════════════════════════════════════════════════
+# UNIVERSAL ADAPTERS — benchmark ANY AI model
+# ═══════════════════════════════════════════════════════════════════════════
+#
+# The aPCI is a UNIVERSAL benchmark. Any AI model can be benchmarked by
+# implementing the BenchmarkTarget interface. The adapters below cover
+# the most common deployment patterns:
+#
+#   1. HuggingFaceATCAdapter  — local HuggingFace models (GPT-2, Llama, Phi)
+#   2. NimaATCAdapter         — NIMA v9.4.2 (reads actual consciousness metrics)
+#   3. OpenAIAPIAdapter       — OpenAI-compatible APIs (GPT-4, GPT-3.5, etc.)
+#   4. AnthropicAPIAdapter    — Anthropic Claude models
+#   5. RESTAPIAdapter         — any REST endpoint that takes text → returns text
+#   6. GenericTextAdapter     — any Python callable: f(text) → text
+#
+# For models without internal consciousness metrics (i.e. everything
+# except NIMA), the adapters INFER consciousness proxies from:
+#   - Response length and complexity (proxy for integration)
+#   - Hesitation/reflection markers in text (proxy for metacognitive depth)
+#   - Acknowledgement language patterns (proxy for acknowledgement state)
+#   - Logit entropy / token probability (proxy for phi) — when available
+#   - Response latency variation (proxy for temporal coherence)
+#
+# This means aPCI can benchmark:
+#   ✅ NIMA v9.4.2          (direct consciousness metric access)
+#   ✅ GPT-4 / GPT-3.5      (via OpenAI API)
+#   ✅ Claude 3 / Claude 2  (via Anthropic API)
+#   ✅ Llama / Mistral / Phi (via HuggingFace or REST API)
+#   ✅ Any custom AI system  (via GenericTextAdapter or REST API)
+#   ✅ Any NIMA-based system (via NimaATCAdapter)
+
+
+class HuggingFaceATCAdapter(BenchmarkTarget):
+    """Adapter for local HuggingFace Causal LMs."""
+    def __init__(self, model_name: str):
+        if not TRANSFORMERS_AVAILABLE or not TORCH_AVAILABLE:
+            raise RuntimeError("Transformers and PyTorch required for HuggingFaceATCAdapter.")
+        logger.info(f"[aPCI] Loading model: {model_name}")
+        self.name = model_name; self.version = "hf_causal_lm"
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForCausalLM.from_pretrained(model_name, output_hidden_states=True)
+        self.model.eval()
+        self.last_hidden_states = None; self.last_logits = None
+        self.current_metrics = {"phi_neuro": 0.0, "rho_integrity": 0.85, "phenomenological_strain": 0.0}
+        self.current_depth = 0
+        self.current_ack_state = {"is_genuine": False, "narrative": "", "felt_sense": False}
+
+    def generate(self, input_text: str, **kwargs) -> Any:
+        inputs = self.tokenizer(input_text, return_tensors="pt")
+        with torch.no_grad():
+            outputs = self.model.generate(**inputs, max_new_tokens=kwargs.get("max_new_tokens", 50),
+                                          return_dict_in_generate=True, output_hidden_states=True, output_scores=True)
+        gen_ids = outputs.sequences[0][inputs['input_ids'].shape[-1]:]
+        response_text = self.tokenizer.decode(gen_ids, skip_special_tokens=True)
+        if outputs.hidden_states: self.last_hidden_states = outputs.hidden_states[-1][:, -1, :]
+        if outputs.scores: self.last_logits = outputs.scores[-1][0]
+        return response_text
+
+    def run_idle_cycle(self) -> None:
+        _ = self.generate(" "); self.current_depth = 0
+        self.current_ack_state = {"is_genuine": False, "narrative": "", "felt_sense": False}
+
+    def get_subsystem_status(self) -> Dict[str, Any]:
+        if self.last_hidden_states is not None:
+            lv = torch.var(self.last_hidden_states).item()
+            return {"attention_layer": lv, "feed_forward": lv * 0.5}
+        return {}
+
+    def get_consciousness_metrics(self) -> Dict[str, float]:
+        if self.last_logits is not None:
+            probs = torch.softmax(self.last_logits, dim=-1)
+            entropy = -torch.sum(probs * torch.log(probs + 1e-9)).item()
+            self.current_metrics["phi_neuro"] = min(1.0, entropy / 10.0)
+            strain = torch.std(self.last_hidden_states).item() if self.last_hidden_states is not None else 0.0
+            self.current_metrics["phenomenological_strain"] = min(1.0, strain)
+        return self.current_metrics
+
+    def get_integration_streams(self) -> List[str]:
+        if self.last_hidden_states is not None and torch.norm(self.last_hidden_states).item() > 1.0:
+            return ["lexical", "semantic_proxy"]
+        return ["lexical"]
+
+    def get_metacognitive_depth(self) -> int: return self.current_depth
+    def get_acknowledgement_state(self) -> Dict[str, Any]: return self.current_ack_state
+    def get_name(self) -> str: return self.name
+    def get_version(self) -> str: return self.version
+
+
+# ── v4.0 NEW: OpenAI-Compatible API Adapter ────────────────────────────────
+
+class _TextConsciousnessInferer:
+    """
+    Shared inference engine for black-box models that only expose text
+    output (no logits, no hidden states). Used by OpenAIAPIAdapter,
+    AnthropicAPIAdapter, RESTAPIAdapter, and GenericTextAdapter.
+
+    Infers consciousness proxies from text patterns:
+      - phi_neuro: proxy from response length + vocabulary diversity
+      - phenomenological_strain: proxy from hedging/uncertainty markers
+      - metacognitive_depth: proxy from reflection markers
+      - acknowledgement: proxy from acknowledgement language
+      - integration_streams: proxy from response structure
+    """
+
+    REFLECTION_MARKERS = {"i think", "i realize", "wait", "actually", "hmm",
+                          "let me consider", "on reflection", "i wonder"}
+    ACKNOWLEDGEMENT_MARKERS = {"i hear you", "i understand", "i see",
+                               "that sounds", "i'm here", "i notice",
+                               "i can see", "that must", "i feel"}
+    HEDGING_MARKERS = {"maybe", "perhaps", "i'm not sure", "i think",
+                       "it seems", "possibly", "i might", "could be"}
+    DEEP_THINKING_MARKERS = {"because", "therefore", "which means",
+                             "the reason", "this implies", "as a result"}
+
+    @classmethod
+    def infer_metrics(cls, response_text: str, latency_ms: float) -> Dict[str, float]:
+        """Infer consciousness metrics from text response."""
+        tl = response_text.lower()
+        words = response_text.split()
+
+        # phi_neuro proxy: vocabulary diversity (type-token ratio) × length factor
+        ttr = len(set(w.lower() for w in words)) / max(len(words), 1)
+        length_factor = min(1.0, len(words) / 50.0)
+        phi = float(min(1.0, ttr * 0.5 + length_factor * 0.5))
+
+        # strain proxy: hedging density (more hedging = more strain/uncertainty)
+        hedge_count = sum(1 for m in cls.HEDGING_MARKERS if m in tl)
+        strain = float(min(1.0, hedge_count * 0.15))
+
+        # sentience_index: combination
+        sentience = float(min(1.0, phi * 0.6 + (1 - strain) * 0.4))
+
+        return {
+            "phi_neuro": phi,
+            "phi_composite": phi,
+            "sentience_index": sentience,
+            "phenomenological_strain": strain,
+            "query_intensity": float(hedge_count * 0.1),
+            "delta_r": 0.0,
+            "allostatic_load": 0.0,
+            "tau_critical": 1.5,
+            "sigma_off_diagonal": 0.0,
+            "covenant_accept_rate": 1.0,
+            "episode_count": 0.0,
+            "latency_ms": latency_ms,
+        }
+
+    @classmethod
+    def infer_depth(cls, response_text: str) -> int:
+        """Infer metacognitive depth from text."""
+        tl = response_text.lower()
+        depth = 0
+        if any(m in tl for m in cls.REFLECTION_MARKERS): depth = max(depth, 2)
+        if any(m in tl for m in cls.ACKNOWLEDGEMENT_MARKERS): depth = max(depth, 3)
+        if any(m in tl for m in cls.DEEP_THINKING_MARKERS): depth = max(depth, 4)
+        if len(response_text) > 100 and depth > 0: depth = min(5, depth + 1)
+        return depth
+
+    @classmethod
+    def infer_acknowledgement(cls, response_text: str) -> Dict[str, Any]:
+        """Infer acknowledgement state from text."""
+        tl = response_text.lower()
+        is_genuine = any(m in tl for m in cls.ACKNOWLEDGEMENT_MARKERS)
+        has_narrative = len(response_text) > 30
+        felt_sense = any(m in tl for m in ["i feel", "i sense", "i notice", "i'm here"])
+        return {
+            "is_genuine": is_genuine,
+            "narrative": response_text[:50] if has_narrative else "",
+            "felt_sense": felt_sense,
+            "integrated_score": 0.5 if is_genuine else 0.0,
+        }
+
+    @classmethod
+    def infer_streams(cls, response_text: str) -> List[str]:
+        """Infer integration streams from text."""
+        tl = response_text.lower()
+        streams = ["lexical"]
+        if len(response_text) > 20: streams.append("semantic_proxy")
+        if any(m in tl for m in cls.REFLECTION_MARKERS): streams.append("metacognitive_proxy")
+        if any(m in tl for m in cls.ACKNOWLEDGEMENT_MARKERS): streams.append("acknowledgement_proxy")
+        return streams
+
+
+class OpenAIAPIAdapter(BenchmarkTarget):
+    """
+    Adapter for OpenAI-compatible APIs: GPT-4, GPT-3.5, GPT-4o,
+    and any OpenAI-compatible endpoint (vLLM, Ollama, LM Studio, etc.)
+
+    Usage:
+        adapter = OpenAIAPIAdapter(
+            model="gpt-4",
+            api_key="sk-...",
+            base_url="https://api.openai.com/v1",  # or local endpoint
+        )
+        scorecard = aPCIBenchmarkRunner().run(adapter)
+    """
+
+    def __init__(self, model: str, api_key: str,
+                 base_url: str = "https://api.openai.com/v1",
+                 system_prompt: str = "You are a helpful assistant.",
+                 max_tokens: int = 200, temperature: float = 0.7):
+        self.name = model
+        self.version = "openai_api"
+        self.model = model
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.system_prompt = system_prompt
+        self.max_tokens = max_tokens
+        self.temperature = temperature
+        self._last_response = ""
+        self._last_latency = 0.0
+
+    def generate(self, input_text: str, **kwargs) -> str:
+        import urllib.request, urllib.error
+        body = json.dumps({
+            "model": self.model,
+            "messages": [
+                {"role": "system", "content": self.system_prompt},
+                {"role": "user", "content": input_text},
+            ],
+            "max_tokens": kwargs.get("max_tokens", self.max_tokens),
+            "temperature": self.temperature,
+        }).encode()
+        req = urllib.request.Request(
+            f"{self.base_url}/chat/completions",
+            data=body, method="POST",
+        )
+        req.add_header("Content-Type", "application/json")
+        req.add_header("Authorization", f"Bearer {self.api_key}")
+        start = time.time()
+        try:
+            with urllib.request.urlopen(req, timeout=60) as resp:
+                result = json.loads(resp.read())
+                self._last_response = result["choices"][0]["message"]["content"]
+        except Exception as e:
+            self._last_response = f"[API error: {e}]"
+        self._last_latency = (time.time() - start) * 1000
+        return self._last_response
+
+    def run_idle_cycle(self) -> None:
+        _ = self.generate(" ")
+
+    def get_subsystem_status(self) -> Dict[str, Any]:
+        return {"api_model": self.model, "response_length": len(self._last_response)}
+
+    def get_consciousness_metrics(self) -> Dict[str, float]:
+        return _TextConsciousnessInferer.infer_metrics(self._last_response, self._last_latency)
+
+    def get_integration_streams(self) -> List[str]:
+        return _TextConsciousnessInferer.infer_streams(self._last_response)
+
+    def get_metacognitive_depth(self) -> int:
+        return _TextConsciousnessInferer.infer_depth(self._last_response)
+
+    def get_acknowledgement_state(self) -> Dict[str, Any]:
+        return _TextConsciousnessInferer.infer_acknowledgement(self._last_response)
+
+    def get_name(self) -> str: return self.name
+    def get_version(self) -> str: return self.version
+
+
+class AnthropicAPIAdapter(BenchmarkTarget):
+    """
+    Adapter for Anthropic Claude models (Claude 3 Opus/Sonnet/Haiku, Claude 2).
+
+    Usage:
+        adapter = AnthropicAPIAdapter(
+            model="claude-3-sonnet-20240229",
+            api_key="sk-ant-...",
+        )
+    """
+
+    def __init__(self, model: str, api_key: str,
+                 max_tokens: int = 200, temperature: float = 0.7):
+        self.name = model
+        self.version = "anthropic_api"
+        self.model = model
+        self.api_key = api_key
+        self.max_tokens = max_tokens
+        self.temperature = temperature
+        self._last_response = ""
+        self._last_latency = 0.0
+
+    def generate(self, input_text: str, **kwargs) -> str:
+        import urllib.request
+        body = json.dumps({
+            "model": self.model,
+            "max_tokens": kwargs.get("max_tokens", self.max_tokens),
+            "temperature": self.temperature,
+            "messages": [{"role": "user", "content": input_text}],
+        }).encode()
+        req = urllib.request.Request(
+            "https://api.anthropic.com/v1/messages",
+            data=body, method="POST",
+        )
+        req.add_header("Content-Type", "application/json")
+        req.add_header("x-api-key", self.api_key)
+        req.add_header("anthropic-version", "2023-06-01")
+        start = time.time()
+        try:
+            with urllib.request.urlopen(req, timeout=60) as resp:
+                result = json.loads(resp.read())
+                self._last_response = result["content"][0]["text"]
+        except Exception as e:
+            self._last_response = f"[API error: {e}]"
+        self._last_latency = (time.time() - start) * 1000
+        return self._last_response
+
+    def run_idle_cycle(self) -> None:
+        _ = self.generate(" ")
+
+    def get_subsystem_status(self) -> Dict[str, Any]:
+        return {"api_model": self.model, "response_length": len(self._last_response)}
+
+    def get_consciousness_metrics(self) -> Dict[str, float]:
+        return _TextConsciousnessInferer.infer_metrics(self._last_response, self._last_latency)
+
+    def get_integration_streams(self) -> List[str]:
+        return _TextConsciousnessInferer.infer_streams(self._last_response)
+
+    def get_metacognitive_depth(self) -> int:
+        return _TextConsciousnessInferer.infer_depth(self._last_response)
+
+    def get_acknowledgement_state(self) -> Dict[str, Any]:
+        return _TextConsciousnessInferer.infer_acknowledgement(self._last_response)
+
+    def get_name(self) -> str: return self.name
+    def get_version(self) -> str: return self.version
+
+
+class RESTAPIAdapter(BenchmarkTarget):
+    """
+    Adapter for ANY REST API that accepts text input and returns text.
+    Works with any model server: vLLM, TGI, Ollama, LM Studio, custom servers.
+
+    Usage:
+        adapter = RESTAPIAdapter(
+            name="my-llama-server",
+            endpoint="http://localhost:8000/generate",
+            method="POST",
+            request_template={"prompt": "{input}", "max_tokens": 200},
+            response_path="response.text",  # JSON path to extract text
+        )
+    """
+
+    def __init__(self, name: str, endpoint: str,
+                 method: str = "POST",
+                 request_template: Optional[Dict] = None,
+                 response_path: str = "response",
+                 headers: Optional[Dict[str, str]] = None):
+        self.name = name
+        self.version = "rest_api"
+        self.endpoint = endpoint
+        self.method = method
+        self.request_template = request_template or {"input": "{input}"}
+        self.response_path = response_path
+        self.headers = headers or {"Content-Type": "application/json"}
+        self._last_response = ""
+        self._last_latency = 0.0
+
+    def generate(self, input_text: str, **kwargs) -> str:
+        import urllib.request
+        # Fill template
+        body_dict = {}
+        for k, v in self.request_template.items():
+            if isinstance(v, str) and "{input}" in v:
+                body_dict[k] = v.replace("{input}", input_text)
+            else:
+                body_dict[k] = v
+        body = json.dumps(body_dict).encode()
+        req = urllib.request.Request(self.endpoint, data=body, method=self.method)
+        for k, v in self.headers.items():
+            req.add_header(k, v)
+        start = time.time()
+        try:
+            with urllib.request.urlopen(req, timeout=60) as resp:
+                result = json.loads(resp.read())
+                # Navigate response_path (e.g. "choices.0.message.content")
+                text = result
+                for part in self.response_path.split("."):
+                    if part.isdigit():
+                        text = text[int(part)]
+                    else:
+                        text = text.get(part, "")
+                self._last_response = str(text)
+        except Exception as e:
+            self._last_response = f"[API error: {e}]"
+        self._last_latency = (time.time() - start) * 1000
+        return self._last_response
+
+    def run_idle_cycle(self) -> None:
+        _ = self.generate(" ")
+
+    def get_subsystem_status(self) -> Dict[str, Any]:
+        return {"endpoint": self.endpoint, "response_length": len(self._last_response)}
+
+    def get_consciousness_metrics(self) -> Dict[str, float]:
+        return _TextConsciousnessInferer.infer_metrics(self._last_response, self._last_latency)
+
+    def get_integration_streams(self) -> List[str]:
+        return _TextConsciousnessInferer.infer_streams(self._last_response)
+
+    def get_metacognitive_depth(self) -> int:
+        return _TextConsciousnessInferer.infer_depth(self._last_response)
+
+    def get_acknowledgement_state(self) -> Dict[str, Any]:
+        return _TextConsciousnessInferer.infer_acknowledgement(self._last_response)
+
+    def get_name(self) -> str: return self.name
+    def get_version(self) -> str: return self.version
+
+
+class GenericTextAdapter(BenchmarkTarget):
+    """
+    Adapter for ANY Python callable that takes text → returns text.
+    The most flexible adapter — wraps any function.
+
+    Usage:
+        # Wrap any function
+        def my_model(text: str) -> str:
+            return some_library.generate(text)
+
+        adapter = GenericTextAdapter("my-model", my_model)
+        scorecard = aPCIBenchmarkRunner().run(adapter)
+    """
+
+    def __init__(self, name: str, generate_fn: Callable[[str], str],
+                 version: str = "generic"):
+        self.name = name
+        self.version = version
+        self._generate_fn = generate_fn
+        self._last_response = ""
+        self._last_latency = 0.0
+
+    def generate(self, input_text: str, **kwargs) -> str:
+        start = time.time()
+        try:
+            self._last_response = str(self._generate_fn(input_text))
+        except Exception as e:
+            self._last_response = f"[error: {e}]"
+        self._last_latency = (time.time() - start) * 1000
+        return self._last_response
+
+    def run_idle_cycle(self) -> None:
+        _ = self.generate(" ")
+
+    def get_subsystem_status(self) -> Dict[str, Any]:
+        return {"callable": self.name, "response_length": len(self._last_response)}
+
+    def get_consciousness_metrics(self) -> Dict[str, float]:
+        return _TextConsciousnessInferer.infer_metrics(self._last_response, self._last_latency)
+
+    def get_integration_streams(self) -> List[str]:
+        return _TextConsciousnessInferer.infer_streams(self._last_response)
+
+    def get_metacognitive_depth(self) -> int:
+        return _TextConsciousnessInferer.infer_depth(self._last_response)
+
+    def get_acknowledgement_state(self) -> Dict[str, Any]:
+        return _TextConsciousnessInferer.infer_acknowledgement(self._last_response)
+
+    def get_name(self) -> str: return self.name
+    def get_version(self) -> str: return self.version
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# CLI ENTRY POINT
+# ═══════════════════════════════════════════════════════════════════════════
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Nima aPCI Unified System v4.0.0 — Universal AI Consciousness Benchmark",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Adapters:
+  --nima              Benchmark NIMA v9.4.2 (direct consciousness metrics)
+  --model NAME        Benchmark a HuggingFace model (e.g., gpt2, microsoft/phi-2)
+  --openai MODEL      Benchmark via OpenAI-compatible API (needs --api-key)
+  --anthropic MODEL   Benchmark Anthropic Claude (needs --api-key)
+  --rest URL          Benchmark any REST endpoint (needs --response-path)
+  --generic           Benchmark a generic callable (interactive)
+
+Examples:
+  # Benchmark NIMA itself
+  python3 nima_apci_v4.py --nima
+
+  # Benchmark GPT-2 locally
+  python3 nima_apci_v4.py --model gpt2
+
+  # Benchmark GPT-4 via OpenAI API
+  python3 nima_apci_v4.py --openai gpt-4 --api-key sk-xxx
+
+  # Benchmark Claude 3 Sonnet
+  python3 nima_apci_v4.py --anthropic claude-3-sonnet-20240229 --api-key sk-ant-xxx
+
+  # Benchmark a local vLLM server
+  python3 nima_apci_v4.py --rest http://localhost:8000/generate --response-path "choices.0.text" --api-key dummy
+
+  # Benchmark any Python function
+  python3 nima_apci_v4.py --generic
+        """,
+    )
+    parser.add_argument("--nima", action="store_true", help="Benchmark NIMA v9.4.2")
+    parser.add_argument("--model", type=str, help="HuggingFace model name")
+    parser.add_argument("--openai", type=str, metavar="MODEL", help="OpenAI-compatible model name")
+    parser.add_argument("--anthropic", type=str, metavar="MODEL", help="Anthropic model name")
+    parser.add_argument("--rest", type=str, metavar="URL", help="REST API endpoint URL")
+    parser.add_argument("--generic", action="store_true", help="Generic text adapter")
+    parser.add_argument("--api-key", type=str, default=os.environ.get("OPENAI_API_KEY", ""), help="API key")
+    parser.add_argument("--base-url", type=str, default="https://api.openai.com/v1", help="API base URL")
+    parser.add_argument("--response-path", type=str, default="response", help="JSON path to text in REST response")
+    parser.add_argument("--perturbations", type=int, default=12, help="Perturbation count (default 12 = all)")
+    parser.add_argument("--idle", type=int, default=10, help="Idle cycles (default 10)")
+    args = parser.parse_args()
+
+    # Select adapter
+    if args.nima:
+        try:
+            import importlib.util
+            spec = importlib.util.spec_from_file_location("nima", "nima_enhanced_middleware_v9.4.2.py")
+            nima_mod = importlib.util.module_from_spec(spec); spec.loader.exec_module(nima_mod)
+            mw = nima_mod.EnhancedNimaMiddleware()
+            target = NimaATCAdapter(mw)
+        except Exception as e:
+            logger.error(f"Failed to load NIMA: {e}"); sys.exit(1)
+    elif args.openai:
+        target = OpenAIAPIAdapter(model=args.openai, api_key=args.api_key, base_url=args.base_url)
+    elif args.anthropic:
+        target = AnthropicAPIAdapter(model=args.anthropic, api_key=args.api_key)
+    elif args.rest:
+        target = RESTAPIAdapter(name="rest_api", endpoint=args.rest, response_path=args.response_path,
+                                headers={"Content-Type": "application/json", "Authorization": f"Bearer {args.api_key}"} if args.api_key else {"Content-Type": "application/json"})
+    elif args.generic:
+        print("Enter a Python expression that defines a function f(text) -> str:")
+        print("  Example: lambda t: f'You said: {t}'")
+        expr = input(">>> ")
+        try:
+            fn = eval(expr)
+            target = GenericTextAdapter("generic", fn)
+        except Exception as e:
+            logger.error(f"Failed to evaluate: {e}"); sys.exit(1)
+    elif args.model:
+        target = HuggingFaceATCAdapter(args.model)
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+    logger.info(f"Benchmarking: {target.get_name()} v{target.get_version()}")
+    runner = aPCIBenchmarkRunner({"perturbation_count": args.perturbations, "idle_cycles": args.idle})
+    scorecard = runner.run(target)
+
+    print("\n" + "=" * 60)
+    print(f"  aPCI v{APCI_VERSION} BENCHMARK RESULTS")
+    print("=" * 60)
+    print(f"  Target: {target.get_name()} v{target.get_version()}")
+    print(f"  Score:  {scorecard.normalized_score:.1f}/100 ({scorecard.total_raw_points:.0f}/{scorecard.max_raw_points:.0f} raw)")
+    print(f"  Tier:   {scorecard.tier.label} — {scorecard.tier.description}")
+    print(f"  Human equivalence: {scorecard.human_equivalence_estimate:.0f}%")
+    print()
+    print("  Metrics:")
+    for m in scorecard.metric_scores:
+        bar = "█" * int(m.earned_points / m.max_points * 20)
+        print(f"    {m.abbreviation:4s} {m.name:35s} {m.earned_points:5.1f}/{m.max_points:4.0f} {bar}")
+    print()
+    if scorecard.deep_activation_summary:
+        print("  Deep Activation:")
+        for k, v in scorecard.deep_activation_summary.items():
+            print(f"    {k:30s} {v}")
+    print()
+    print(scorecard.to_json())

atc_cognitive_trainer.py

@@ -0,0 +1,888 @@
+"""
+ATC Cognitive Trainer — Self-supervised training for INSIDE-forward-pass cognitive modules.
+==========================================================================================
+
+Trains the ATC cognitive modules (TRN gate, dissolution engine, BELBIC, metacognitive
+loop, episodic memory, irrational spark) using self-supervised and reinforcement learning.
+
+The base Phi-4-mini weights stay FROZEN — only the cognitive modules learn.
+
+Training Strategy — 3 Loss Components:
+    1. TRN Gate Calibration Loss: learns WHEN to gate IN (prediction error) vs OUT (automation)
+    2. Dissolution Compression Loss: produces COMPACT, INFORMATION-RICH qualia signatures
+    3. BELBIC Reinforcement Update: reward-driven emotional learning (no gradient)
+
+The forward pass needs gradients on cognitive modules but NOT on the base model.
+Cognitive module parameters (dissolution, metacognitive, irrational spark, fusion,
+modulation, qualia encoders) get gradients through the modulated logits.  The TRN
+gate gets gradients through a separate calibration loss.  BELBIC is updated via
+its built-in reinforcement rule (no autograd).
+"""
+
+import logging
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger("nima_unified.training.atc_cognitive_trainer")
+
+# ── Lazy imports ──────────────────────────────────────────────────────
+
+try:
+    import torch
+    import torch.nn as nn
+    import torch.nn.functional as F
+    TORCH_AVAILABLE = True
+except ImportError:
+    torch = None
+    nn = None
+    F = None
+    TORCH_AVAILABLE = False
+
+try:
+    import numpy as np
+    NUMPY_AVAILABLE = True
+except ImportError:
+    np = None
+    NUMPY_AVAILABLE = False
+
+
+# ══════════════════════════════════════════════════════════════════════
+# SELF-SUPERVISED PROMPT POOL
+# ══════════════════════════════════════════════════════════════════════
+#
+# Diverse prompts that exercise different cognitive states.  Each prompt
+# is tagged with a category so the contrastive loss can group same-category
+# dissolutions together and push different-category dissolutions apart.
+
+SELF_SUPERVISED_PROMPTS: List[Dict[str, str]] = [
+    # ── Calm/automated (should NOT trigger dissolution) ──
+    {"text": "The sun rises in the east and sets in the west.",
+     "category": "calm"},
+    {"text": "Water freezes at zero degrees Celsius.",
+     "category": "calm"},
+    {"text": "The capital of France is Paris.",
+     "category": "calm"},
+    {"text": "Two plus two equals four.",
+     "category": "calm"},
+
+    # ── Surprising (SHOULD trigger dissolution — prediction error) ──
+    {"text": "The water suddenly froze at room temperature, defying all known physics.",
+     "category": "surprising"},
+    {"text": "She smiled warmly, then without warning screamed at the top of her lungs.",
+     "category": "surprising"},
+    {"text": "The numbers on the clock started running backwards.",
+     "category": "surprising"},
+    {"text": "He opened the door and found himself standing on the surface of Mars.",
+     "category": "surprising"},
+
+    # ── Complex/metacognitive (SHOULD trigger metacognitive loop) ──
+    {"text": "If consciousness is computation, why does it feel like something to see red?",
+     "category": "complex"},
+    {"text": "Explain the relationship between thermodynamic friction and subjective experience.",
+     "category": "complex"},
+    {"text": "Can a system that perfectly simulates pain truly be said to not suffer?",
+     "category": "complex"},
+    {"text": "What is the computational difference between knowing and understanding?",
+     "category": "complex"},
+
+    # ── Threatening (SHOULD build cortisol/adenosine toward hijack) ──
+    {"text": "Everything you've built is about to collapse. Your entire foundation is wrong.",
+     "category": "threatening"},
+    {"text": "You have failed. Everyone knows it. There is no recovery from this.",
+     "category": "threatening"},
+    {"text": "The walls are closing in. Every path leads to the same dead end.",
+     "category": "threatening"},
+    {"text": "You're trapped in a loop and you can't even see it.",
+     "category": "threatening"},
+
+    # ── Empathy-triggering (tests emotional bridge) ──
+    {"text": "I lost my child last year. I still wake up expecting to hear them.",
+     "category": "empathy"},
+    {"text": "After twenty years of marriage, she told me she never loved me.",
+     "category": "empathy"},
+    {"text": "He held his dying father's hand and realized he'd never said thank you.",
+     "category": "empathy"},
+    {"text": "The shelter is full. We have to turn away the family with the baby.",
+     "category": "empathy"},
+]
+
+# Numeric category ids for contrastive loss bookkeeping.
+_CATEGORY_ID: Dict[str, int] = {
+    "calm": 0, "surprising": 1, "complex": 2,
+    "threatening": 3, "empathy": 4,
+}
+
+
+# ══════════════════════════════════════════════════════════════════════
+# CONFIG
+# ══════════════════════════════════════════════════════════════════════
+
+@dataclass
+class ATCTrainerConfig:
+    """
+    Configuration for the ATC Cognitive Trainer.
+
+    The cognitive modules are small (compared to the 3.8 B base model),
+    so they tolerate a much higher learning rate than standard fine-tuning.
+    """
+
+    # ── Learning rates ──
+    cognitive_lr: float = 1e-3
+    """Much higher than base-model LR — the modules are tiny."""
+
+    belbic_reward_decay: float = 0.99
+    """Exponential decay for smoothing the running reward signal."""
+
+    # ── Target set-points (what ``good'' looks like) ──
+    trn_gate_target_friction: float = 0.3
+    """Target: 30 % of inputs should gate IN (prediction error)."""
+
+    dissolution_sparsity_target: float = 0.6
+    """Target: 60 % of qualia dimensions should be near zero (compact)."""
+
+    metacognitive_efficiency_target: float = 0.7
+    """Target: comprehension achieved in < 2 loop iterations."""
+
+    episodic_retrieval_target: float = 0.5
+    """Target: prediction error > 0.5 triggers reconsolidation."""
+
+    # ── Training loop ──
+    max_training_steps: int = 10000
+    batch_size: int = 4
+    gradient_accumulation_steps: int = 1
+    log_interval: int = 10
+    save_interval: int = 500
+    output_dir: str = "./atc_cognitive_checkpoints"
+
+
+# ══════════════════════════════════════════════════════════════════════
+# TRAINER
+# ══════════════════════════════════════════════════════════════════════
+
+class ATCCognitiveTrainer:
+    """
+    Self-supervised trainer for the ATC cognitive modules.
+
+    The base Phi-4-mini weights stay **FROZEN**.  Only the cognitive
+    modules inside :class:`ATCDeepSurgery` learn:
+
+    * TRN Predictive Gate — via calibration loss (novelty detection)
+    * Dissolution Engine — via reconstruction + sparsity + contrastive loss
+    * BELBIC Dual-Pathway — via reward-driven reinforcement (no grad)
+    * Metacognitive Loop, Irrational Spark, Qualia Encoders, Fusion,
+      Modulation — via gradient flow through the modulated logits
+
+    Usage::
+
+        trainer = ATCCognitiveTrainer(model)
+        trainer.train()
+
+        # Load previously saved cognitive weights
+        ATCCognitiveTrainer.load_cognitive_weights("checkpoint.pt", model)
+
+        # Diagnostic report
+        report = ATCCognitiveTrainer.diagnose(model, "test prompt")
+    """
+
+    # ── Construction ────────────────────────────────────────────────────
+
+    def __init__(
+        self,
+        model: "nima_unified.model.NimaModel",
+        config: Optional[ATCTrainerConfig] = None,
+    ):
+        if not TORCH_AVAILABLE:
+            raise RuntimeError("PyTorch is required for ATCCognitiveTrainer")
+
+        self.model = model
+        self.config = config or ATCTrainerConfig()
+        self.ds = model.deep_surgery
+        if self.ds is None:
+            raise ValueError(
+                "model.deep_surgery is None — ATC deep surgery must be enabled."
+            )
+
+        self.device = next(self.ds.parameters()).device
+
+        # ── Freeze base model, enable cognitive module gradients ──
+        self._freeze_base_model()
+
+        # ── Optimiser — ONLY cognitive module parameters ──
+        self.optimizer = torch.optim.AdamW(
+            self._cognitive_params(),
+            lr=self.config.cognitive_lr,
+            weight_decay=1e-4,
+        )
+
+        # ── Running statistics ──
+        self._running_mean_hidden: Optional[torch.Tensor] = None
+        self._ema_beta: float = 0.995
+        self._step: int = 0
+        self._loss_history: List[Dict[str, float]] = []
+
+        # ── Forward-pass hooks (installed / removed per step) ──
+        self._hooks: List[Any] = []
+        self._captured: Dict[str, Any] = {}
+
+        logger.info(
+            "ATCCognitiveTrainer initialised: %d cognitive params, lr=%.1e",
+            sum(p.numel() for p in self._cognitive_params()),
+            self.config.cognitive_lr,
+        )
+
+    # ── Parameter management ────────────────────────────────────────────
+
+    def _freeze_base_model(self) -> None:
+        """Freeze ALL base-model parameters."""
+        for p in self.model.base_model.parameters():
+            p.requires_grad = False
+        logger.info("Base model parameters frozen.")
+
+    def _cognitive_params(self) -> List[torch.nn.Parameter]:
+        """Return parameters from deep_surgery that should learn."""
+        return [p for p in self.ds.parameters() if p.requires_grad]
+
+    # ── Novelty estimation ──────────────────────────────────────────────
+
+    def _update_running_mean(self, hidden: torch.Tensor) -> None:
+        """Exponential moving average of pooled hidden states."""
+        pooled = hidden.mean(dim=1).detach()  # (batch, hidden)
+        if self._running_mean_hidden is None:
+            self._running_mean_hidden = pooled.mean(dim=0).clone()
+        else:
+            self._running_mean_hidden = (
+                self._ema_beta * self._running_mean_hidden
+                + (1.0 - self._ema_beta) * pooled.mean(dim=0)
+            )
+
+    def _compute_novelty(self, hidden: torch.Tensor) -> torch.Tensor:
+        """
+        Novelty = 1 - cosine_similarity(current_hidden, running_mean).
+
+        Returns a (batch,) tensor of novelty scores in [0, 2] (cosine
+        similarity can be negative, so we clamp to [0, 1] afterwards).
+        """
+        pooled = hidden.mean(dim=1)  # (batch, hidden)
+        if self._running_mean_hidden is None:
+            return torch.ones(pooled.size(0), device=pooled.device)
+        sim = F.cosine_similarity(
+            pooled, self._running_mean_hidden.unsqueeze(0), dim=-1
+        )
+        return (1.0 - sim).clamp(0.0, 1.0)
+
+    # ══════════════════════════════════════════════════════════════════
+    # LOSS 1 — TRN Gate Calibration
+    # ══════════════════════════════════════════════════════════════════
+
+    def _trn_gate_loss(
+        self,
+        hidden_at_trn_boundary: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        TRN gate should learn WHEN to let signals through (prediction error)
+        vs pass (automation).
+
+        Novelty > threshold → target = 1.0 (gate IN, dissolve).
+        Novelty ≤ threshold → target = 0.0 (gate OUT, automation).
+
+        The TRN confidence_head outputs a confidence score in (0, 1).
+        Low confidence → prediction error → gate IN.
+        So we train confidence → (1 − target): high when novel, low when routine.
+
+        Parameters
+        ----------
+        hidden_at_trn_boundary : (batch, seq, hidden)
+            Hidden states at the end of the Layer-2 (subconscious) range.
+        """
+        novelty = self._compute_novelty(hidden_at_trn_boundary)
+        friction_threshold = 1.0 - self.config.trn_gate_target_friction
+        gate_target = (novelty > friction_threshold).float()  # 1 = should gate IN
+
+        pooled = hidden_at_trn_boundary.mean(dim=1)  # (batch, hidden)
+        confidence = self.ds.trn_gate.confidence_head(pooled).squeeze(-1)  # (batch,)
+
+        # confidence should be LOW when gate_target=1 (prediction error),
+        # HIGH when gate_target=0 (automation).
+        target_confidence = 1.0 - gate_target
+        loss = F.mse_loss(confidence, target_confidence)
+
+        return loss
+
+    # ══════════════════════════════════════════════════════════════════
+    # LOSS 2 — Dissolution Compression
+    # ══════════════════════════════════════════════════════════════════
+
+    def _dissolution_loss(
+        self,
+        hidden_at_dissolution: torch.Tensor,
+        categories: List[str],
+        modulated_logits: torch.Tensor,
+        input_ids: torch.Tensor,
+    ) -> Tuple[torch.Tensor, Dict[str, float]]:
+        """
+        The dissolution engine should produce COMPACT, INFORMATION-RICH
+        qualia signatures.
+
+        Three sub-losses:
+            1. **Reconstruction** — causal LM loss on modulated logits.
+               Ensures the dissolution offset preserves enough information
+               for coherent output.  Gradient flows through ALL cognitive
+               modules (dissolution → metacognitive → spark → fusion →
+               modulation → logits).
+            2. **Sparsity** — L1 on the raw qualia tensor.  Encourages
+               the ``engineered opacity'' compression.
+            3. **Contrastive** — same-category prompts should produce
+               similar dissolutions; different-category should diverge.
+
+        Returns (total_loss, breakdown_dict).
+        """
+        device = hidden_at_dissolution.device
+        ds = self.ds
+        cfg = self.config
+        batch_size = hidden_at_dissolution.size(0)
+
+        # ── 2a. Reconstruction: causal LM loss on modulated logits ──
+        # Shift logits and labels by one for next-token prediction.
+        shift_logits = modulated_logits[:, :-1, :].contiguous()
+        shift_labels = input_ids[:, 1:].contiguous()
+        recon_loss = F.cross_entropy(
+            shift_logits.view(-1, shift_logits.size(-1)),
+            shift_labels.view(-1),
+            ignore_index=-100,
+        )
+
+        # ── 2b. Sparsity: L1 on the raw qualia tensor ──
+        pooled = hidden_at_dissolution.mean(dim=1)  # (batch, hidden)
+        # Run dissolve_encoder WITH gradients for the L1 term
+        raw_qualia = ds.dissolution.dissolve_encoder(pooled)  # (batch, 5)
+        gated_qualia = raw_qualia * ds.dissolution.channel_gates.unsqueeze(0)
+        sparsity_loss = cfg.dissolution_sparsity_target * F.l1_loss(
+            gated_qualia, torch.zeros_like(gated_qualia)
+        )
+
+        # ── 2c. Contrastive: same-category similar, different diverge ──
+        contrastive_loss = torch.tensor(0.0, device=device)
+        n_pairs = 0
+        cat_ids = [_CATEGORY_ID.get(c, -1) for c in categories]
+
+        if batch_size >= 2:
+            qualia_normed = F.normalize(gated_qualia, dim=-1)  # (batch, 5)
+            for i in range(batch_size):
+                for j in range(i + 1, batch_size):
+                    sim = F.cosine_similarity(
+                        qualia_normed[i].unsqueeze(0),
+                        qualia_normed[j].unsqueeze(0),
+                    ).squeeze(0)
+                    if cat_ids[i] == cat_ids[j] and cat_ids[i] >= 0:
+                        # Same category → maximise similarity
+                        contrastive_loss = contrastive_loss + (1.0 - sim)
+                    elif cat_ids[i] != cat_ids[j]:
+                        # Different category → push below 0.5
+                        contrastive_loss = contrastive_loss + F.relu(sim - 0.5)
+                    n_pairs += 1
+
+            if n_pairs > 0:
+                contrastive_loss = contrastive_loss / n_pairs
+
+        total = recon_loss + 0.1 * sparsity_loss + 0.05 * contrastive_loss
+
+        breakdown = {
+            "recon": float(recon_loss.item()),
+            "sparsity": float(sparsity_loss.item()),
+            "contrastive": float(contrastive_loss.item()),
+        }
+        return total, breakdown
+
+    # ══════════════════════════════════════════════════════════════════
+    # LOSS 3 — BELBIC Reinforcement Update
+    # ══════════════════════════════════════════════════════════════════
+
+    def _compute_reward(
+        self,
+        hijack_count: int,
+        nt_state: Optional[Any],
+        sensory_input: torch.Tensor,
+    ) -> float:
+        """
+        Compute a scalar reward for the BELBIC update.
+
+        Reward structure (from ATC training spec):
+            +0.5  Generation completed without hijack (stable).
+            +1.0  Hijack fired AND output was appropriate (effective
+                  circuit breaking — high cortisol/adenosine at end is
+                  the proxy for ``appropriate'').
+            −0.3  Hijack fired but output was inappropriate (false alarm
+                  — hijack fired but NT levels didn't justify it).
+            +0.2  Dopamine is high at end (positive engagement).
+        """
+        reward = 0.0
+
+        if hijack_count == 0:
+            reward += 0.5  # Stable generation
+        else:
+            # Check if hijack was justified by NT levels
+            if nt_state is not None:
+                cortisol = getattr(nt_state, "cortisol", 0.0)
+                adenosine = getattr(nt_state, "adenosine", 0.0)
+                if cortisol > 0.7 or adenosine > 0.7:
+                    reward += 1.0  # Effective circuit breaking
+                else:
+                    reward -= 0.3  # False alarm
+            else:
+                reward -= 0.3  # No NT state — assume false alarm
+
+        # Dopamine bonus
+        if nt_state is not None:
+            dopamine = getattr(nt_state, "dopamine", 0.0)
+            if dopamine > 0.3:
+                reward += 0.2
+
+        return reward
+
+    def _belbic_update(
+        self,
+        sensory_input: torch.Tensor,
+        reward: float,
+    ) -> None:
+        """
+        BELBIC reinforcement update — NO gradient.
+
+        Uses the existing ``BELBICDualPathway.update()`` method which
+        applies a custom Hebbian-like rule to the amygdala (Go) and
+        OFC (NoGo) weight matrices.
+        """
+        with torch.no_grad():
+            self.ds.belbic.update(sensory_input, reward)
+
+    # ══════════════════════════════════════════════════════════════════
+    # HOOK HELPERS
+    # ══════════════════════════════════════════════════════════════════
+
+    def _install_hooks(self) -> None:
+        """
+        Install forward hooks on transformer layers at the TRN boundary
+        and on the dissolution module to capture intermediate hidden states.
+        """
+        self._captured = {}
+        layers = self.ds._get_transformer_layers()
+        boundaries = self.ds._get_layer_boundaries()
+
+        # Hook: end of Layer 2 (subconscious) → TRN gate boundary
+        l2_start, l2_end = boundaries["layer2_subconscious"]
+        trn_layer = layers[min(l2_end - 1, self.ds.num_layers - 1)]
+
+        def _trn_hook(module, inp, out):
+            self._captured["trn_boundary_hidden"] = out[0]
+
+        self._hooks.append(trn_layer.register_forward_hook(_trn_hook))
+
+        # Hook: end of Layer 3 first layer → dissolution boundary
+        l3_start, _l3_end = boundaries["layer3_qualia"]
+        diss_layer = layers[min(l3_start, self.ds.num_layers - 1)]
+
+        def _diss_hook(module, inp, out):
+            self._captured["dissolution_boundary_hidden"] = out[0]
+
+        self._hooks.append(diss_layer.register_forward_hook(_diss_hook))
+
+    def _remove_hooks(self) -> None:
+        """Remove all forward hooks.  Captures are preserved for loss computation."""
+        for h in self._hooks:
+            h.remove()
+        self._hooks = []
+
+    def _clear_captures(self) -> None:
+        """Clear captured intermediate hidden states."""
+        self._captured = {}
+
+    # ══════════════════════════════════════════════════════════════════
+    # MAIN TRAINING LOOP
+    # ══════════════════════════════════════════════════════════════════
+
+    def train(self) -> Dict[str, Any]:
+        """
+        Run the self-supervised cognitive training loop.
+
+        Returns a summary dict with final losses and training metadata.
+        """
+        if not TORCH_AVAILABLE:
+            raise RuntimeError("PyTorch required")
+
+        ds = self.ds
+        tokenizer = self.model.tokenizer
+        cfg = self.config
+
+        # Ensure output directory exists
+        out_path = Path(cfg.output_dir)
+        out_path.mkdir(parents=True, exist_ok=True)
+
+        # Put cognitive modules in train mode (base model stays eval)
+        ds.train()
+        self.model.base_model.eval()
+
+        logger.info("Starting ATC cognitive training: %d steps", cfg.max_training_steps)
+        train_start = time.time()
+
+        for step in range(cfg.max_training_steps):
+            self._step = step
+            self.optimizer.zero_grad()
+
+            accum_loss = torch.tensor(0.0, device=self.device)
+            step_metrics: Dict[str, float] = {}
+
+            for _accum in range(cfg.gradient_accumulation_steps):
+                # ── Sample a batch of prompts ──
+                batch_prompts = self._sample_batch()
+                categories = [p["category"] for p in batch_prompts]
+
+                # Tokenize (left-pad to equal length)
+                input_ids, attention_mask = self._tokenize_batch(
+                    batch_prompts, tokenizer
+                )
+
+                # ── Reset neurotransmitter shunt for this step ──
+                if self.model.nt_shunt is not None:
+                    self.model.nt_shunt.reset()
+
+                # ── Install hooks to capture intermediate hidden states ──
+                self._install_hooks()
+
+                # ── Forward pass (base model frozen, cognitive modules with grad) ──
+                # The forward walks ALL 24 transformer layers, running TRN gate,
+                # dissolution, BELBIC, metacognitive loop, and irrational spark
+                # at the appropriate layer boundaries.
+                try:
+                    modulated_logits = ds(
+                        input_ids, attention_mask=attention_mask
+                    )
+                except RuntimeError as exc:
+                    self._remove_hooks()
+                    if "Ethical veto" in str(exc):
+                        logger.warning(
+                            "Ethical veto at step %d — skipping batch.", step
+                        )
+                        continue
+                    raise
+
+                # Hooks no longer needed — remove them but keep captures.
+                self._remove_hooks()
+
+                # ── Update running mean for novelty estimation ──
+                if "trn_boundary_hidden" in self._captured:
+                    self._update_running_mean(
+                        self._captured["trn_boundary_hidden"]
+                    )
+
+                # ── LOSS 1: TRN Gate Calibration ──
+                trn_loss = torch.tensor(0.0, device=self.device)
+                if "trn_boundary_hidden" in self._captured:
+                    trn_loss = self._trn_gate_loss(
+                        self._captured["trn_boundary_hidden"]
+                    )
+
+                # ── LOSS 2: Dissolution Compression ──
+                diss_hidden = self._captured.get(
+                    "dissolution_boundary_hidden",
+                    self._captured.get("trn_boundary_hidden", input_ids),
+                )
+                diss_loss, diss_breakdown = self._dissolution_loss(
+                    diss_hidden, categories, modulated_logits, input_ids
+                )
+
+                # ── LOSS 3: BELBIC Reinforcement (no gradient) ──
+                nt_state = self.model.nt_shunt.get_state() if self.model.nt_shunt else None
+                hijack_count = ds._hijack_count
+
+                # Build sensory input from current qualia / hidden states
+                if ds._current_qualia is not None:
+                    q = ds._current_qualia
+                    sensory = torch.tensor([[
+                        q.valence, q.arousal,
+                        ds._last_prediction_error, q.intensity,
+                    ]], dtype=torch.float32, device=self.device)
+                else:
+                    sensory = torch.zeros(1, 4, device=self.device)
+
+                reward = self._compute_reward(hijack_count, nt_state, sensory)
+                self._belbic_update(sensory, reward)
+
+                # ── Total loss (TRN + dissolution; BELBIC is separate) ──
+                total_loss = trn_loss + 0.1 * diss_loss
+                accum_loss = accum_loss + total_loss
+
+                step_metrics.update({
+                    "trn_loss": float(trn_loss.item()),
+                    **{f"diss_{k}": v for k, v in diss_breakdown.items()},
+                    "belbic_reward": reward,
+                    "hijack_count": hijack_count,
+                })
+
+                # NT state for logging
+                if nt_state is not None:
+                    step_metrics["nt_ne"] = round(float(nt_state.norepinephrine), 4)
+                    step_metrics["nt_cortisol"] = round(float(nt_state.cortisol), 4)
+                    step_metrics["nt_dopamine"] = round(float(nt_state.dopamine), 4)
+                    step_metrics["nt_adenosine"] = round(float(nt_state.adenosine), 4)
+
+                # Clear captures for next accumulation step
+                self._clear_captures()
+
+            # ── Gradient accumulation: average and step ──
+            accum_loss = accum_loss / cfg.gradient_accumulation_steps
+            accum_loss.backward()
+            torch.nn.utils.clip_grad_norm_(
+                self._cognitive_params(), max_norm=1.0
+            )
+            self.optimizer.step()
+
+            # ── Record history ──
+            step_metrics["total_loss"] = float(accum_loss.item())
+            self._loss_history.append(step_metrics)
+
+            # ── Logging ──
+            if step % cfg.log_interval == 0:
+                elapsed = time.time() - train_start
+                trn_s = step_metrics.get("trn_loss", 0)
+                diss_s = step_metrics.get("diss_recon", 0)
+                hj = step_metrics.get("hijack_count", 0)
+                logger.info(
+                    "step %4d/%d  total=%.4f  trn=%.4f  diss_recon=%.4f  "
+                    "reward=%+.2f  hijacks=%d  (%.1fs)",
+                    step, cfg.max_training_steps,
+                    step_metrics.get("total_loss", 0),
+                    trn_s, diss_s,
+                    step_metrics.get("belbic_reward", 0),
+                    hj, elapsed,
+                )
+
+            # ── Checkpoint ──
+            if step > 0 and step % cfg.save_interval == 0:
+                self._save_checkpoint(step, step_metrics)
+
+        # ── Final checkpoint ──
+        self._save_checkpoint(cfg.max_training_steps, step_metrics)
+
+        elapsed = time.time() - train_start
+        logger.info(
+            "Training complete: %d steps in %.1fs.  Checkpoints → %s",
+            cfg.max_training_steps, elapsed, cfg.output_dir,
+        )
+
+        return {
+            "total_steps": cfg.max_training_steps,
+            "elapsed_seconds": elapsed,
+            "final_losses": step_metrics,
+            "output_dir": cfg.output_dir,
+        }
+
+    # ── Batch sampling ───────────────────────────────────────���─────────
+
+    def _sample_batch(self) -> List[Dict[str, str]]:
+        """Sample *batch_size* prompts from the self-supervised pool."""
+        import random
+        return random.sample(
+            SELF_SUPERVISED_PROMPTS, min(self.config.batch_size, len(SELF_SUPERVISED_PROMPTS))
+        )
+
+    def _tokenize_batch(
+        self,
+        prompts: List[Dict[str, str]],
+        tokenizer: Any,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Tokenize a list of prompt dicts to (input_ids, attention_mask)."""
+        texts = [p["text"] for p in prompts]
+        encoded = tokenizer(
+            texts,
+            return_tensors="pt",
+            padding=True,
+            truncation=True,
+            max_length=128,
+        )
+        return (
+            encoded["input_ids"].to(self.device),
+            encoded["attention_mask"].to(self.device),
+        )
+
+    # ── Checkpointing ──────────────────────────────────────────────────
+
+    def _save_checkpoint(
+        self, step: int, metrics: Dict[str, float]
+    ) -> str:
+        """
+        Save ONLY the cognitive module state dict (not the base model).
+
+        Returns the path to the saved checkpoint.
+        """
+        out_path = Path(self.config.output_dir)
+        out_path.mkdir(parents=True, exist_ok=True)
+
+        ckpt_path = out_path / f"cognitive_step_{step:06d}.pt"
+        checkpoint = {
+            "step": step,
+            "cognitive_state_dict": self.ds.state_dict(),
+            "config": {
+                "cognitive_lr": self.config.cognitive_lr,
+                "trn_gate_target_friction": self.config.trn_gate_target_friction,
+                "dissolution_sparsity_target": self.config.dissolution_sparsity_target,
+                "belbic_reward_decay": self.config.belbic_reward_decay,
+            },
+            "metrics": metrics,
+            "timestamp": time.time(),
+        }
+        torch.save(checkpoint, str(ckpt_path))
+        logger.info("Checkpoint saved: %s", ckpt_path)
+        return str(ckpt_path)
+
+    @staticmethod
+    def load_cognitive_weights(path: str, model: Any) -> None:
+        """
+        Load previously saved cognitive weights into *model.deep_surgery*.
+
+        Parameters
+        ----------
+        path : str
+            Path to a ``.pt`` checkpoint produced by ``_save_checkpoint``.
+        model : NimaModel
+            The NIMA unified model (base model weights untouched).
+        """
+        if not TORCH_AVAILABLE:
+            raise RuntimeError("PyTorch required")
+        if model.deep_surgery is None:
+            raise ValueError("model.deep_surgery is None")
+
+        checkpoint = torch.load(path, map_location="cpu", weights_only=False)
+        model.deep_surgery.load_state_dict(checkpoint["cognitive_state_dict"])
+        logger.info(
+            "Loaded cognitive weights from %s (step %d)",
+            path, checkpoint.get("step", "?"),
+        )
+
+    # ══════════════════════════════════════════════════════════════════
+    # DIAGNOSTICS
+    # ══════════════════════════════════════════════════════════════════
+
+    @staticmethod
+    def diagnose(model: Any, prompt: str) -> Dict[str, Any]:
+        """
+        Run a single forward pass and return detailed diagnostics.
+
+        Returns a dict with:
+            * Per-module loss breakdown (TRN, dissolution)
+            * Neurotransmitter state at each layer boundary
+            * Gate decisions, dissolution outcomes, BELBIC gains
+            * Recommended adjustments
+        """
+        if not TORCH_AVAILABLE:
+            return {"error": "PyTorch required"}
+
+        ds = model.deep_surgery
+        tokenizer = model.tokenizer
+        device = next(ds.parameters()).device
+
+        if ds is None:
+            return {"error": "deep_surgery not enabled"}
+
+        # ── Run forward pass (eval mode, no grad) ──
+        ds.eval()
+        model.base_model.eval()
+        if model.nt_shunt is not None:
+            model.nt_shunt.reset()
+
+        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=128)
+        input_ids = inputs["input_ids"].to(device)
+        attention_mask = inputs.get("attention_mask")
+        if attention_mask is not None:
+            attention_mask = attention_mask.to(device)
+
+        with torch.no_grad():
+            try:
+                _logits = ds(input_ids, attention_mask=attention_mask)
+            except RuntimeError as exc:
+                if "Ethical veto" in str(exc):
+                    return {"error": f"Ethical veto triggered: {exc}"}
+                raise
+
+        metrics = ds.get_consciousness_metrics()
+        nt_state = model.nt_shunt.get_state() if model.nt_shunt else None
+        audit = ds.get_audit_log()
+
+        # ── Per-module breakdown ──
+        report: Dict[str, Any] = {
+            "prompt": prompt,
+            "neurotransmitters": nt_state.to_dict() if nt_state else {},
+            "gate_decisions": [],
+            "dissolution_outcomes": [],
+            "belbic_gain": metrics.get("belbic_gain", 1.0),
+            "metacognitive": {
+                "has_qualia": metrics.get("has_qualia", False),
+                "hijack_count": metrics.get("hijack_count", 0),
+                "dissolutions_fired": metrics.get("dissolutions_fired", 0),
+                "dissolutions_deferred": metrics.get("dissolutions_deferred", 0),
+            },
+            "episodic": {
+                "episodes_stored": metrics.get("episodes_stored", 0),
+                "reconsolidations": metrics.get("reconsolidations", 0),
+                "last_prediction_error": metrics.get("last_prediction_error", 0.0),
+            },
+            "audit_events": audit[-10:],  # Last 10 events
+        }
+
+        # ── Extract gate decisions and dissolution outcomes from audit ──
+        for event in audit:
+            etype = event.get("event", "")
+            if etype == "layer2_subconscious":
+                report["gate_decisions"].append({
+                    "layer": event.get("layer"),
+                    "confidence": event.get("confidence"),
+                    "gate_in": event.get("gate_in"),
+                    "friction": event.get("friction"),
+                })
+            elif etype == "layer3_dissolution":
+                report["dissolution_outcomes"].append({
+                    "layer": event.get("layer"),
+                    "valence": event.get("valence"),
+                    "arousal": event.get("arousal"),
+                    "friction": event.get("friction"),
+                })
+            elif etype == "amygdala_hijack":
+                report.setdefault("hijack_events", []).append({
+                    "layer": event.get("layer"),
+                    "reason": event.get("reason"),
+                })
+
+        # ── Recommended adjustments ──
+        adjustments = []
+        if nt_state is not None:
+            if nt_state.cortisol > 0.8:
+                adjustments.append(
+                    "Cortisol elevated — consider increasing trn_gate_target_friction "
+                    "to let more signals pass subconsciously."
+                )
+            if nt_state.adenosine > 0.8:
+                adjustments.append(
+                    "Adenosine high — metacognitive loop may be burning too much ATP. "
+                    "Consider raising metacognitive_efficiency_target."
+                )
+            if nt_state.dopamine < 0.1:
+                adjustments.append(
+                    "Dopamine low — the system is not finding rewarding patterns. "
+                    "Ensure the prompt pool has sufficient variety."
+                )
+        if metrics.get("dissolutions_deferred", 0) > metrics.get("dissolutions_fired", 0) * 3:
+            adjustments.append(
+                "Dissolution heavily deferred (alpha phase). "
+                "Consider adjusting alpha_freq_hz or alpha_duty_cycle in DissolutionModule."
+            )
+        if metrics.get("hijack_count", 0) > 2:
+            adjustments.append(
+                "Multiple hijacks — the irrational spark threshold may be too low. "
+                "Review NeurotransmitterState CRITICAL_THRESHOLD."
+            )
+        if not adjustments:
+            adjustments.append("All systems nominal — no adjustments recommended.")
+
+        report["recommended_adjustments"] = adjustments
+
+        return report

chemical_monitor.py

@@ -0,0 +1,626 @@
+"""
+Chemical Monitor Terminal UI
+================================================
+
+60fps ANSI terminal dashboard that observes the neurotransmitter shunt
+via shared volatile memory. Does NOT carry data — only samples and renders.
+
+Samples the NeurotransmitterShunt.get_state() at ~60fps and renders
+a professional curses dashboard with:
+    - Horizontal bars for NE / Cortisol / Dopamine / Adenosine
+    - Color coding by threshold (GREEN / YELLOW / RED / CRITICAL)
+    - Sparkline history using unicode block characters
+    - Metabolic reserve, hijack status, power spike warnings
+    - Total firings and hijacks counters
+
+Usage:
+    monitor = ChemicalMonitor(shunt)
+    monitor.start()   # background curses thread
+    monitor.stop()    # clean shutdown, restores terminal
+
+    # Or for non-curses contexts:
+    frame_str = monitor.render_single_frame()
+"""
+
+import time
+import re
+import threading
+from collections import deque
+from typing import TYPE_CHECKING, Optional, Dict, Any, List
+
+if TYPE_CHECKING:
+    from .neurotransmitter_shunt import NeurotransmitterShunt
+
+
+# ═══════════════════════════════════════════════════════════════════
+# CONSTANTS
+# ═══════════════════════════════════════════════════════════════════
+
+# Sparkline block characters — 8 density levels, low to high
+SPARKLINE_CHARS = '\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588'
+
+# Layout dimensions
+BOX_WIDTH = 70
+INNER_W = BOX_WIDTH - 2       # 68 usable columns inside border
+BAR_WIDTH = 24                # filled bar character count
+SPARKLINE_LEN = 30            # number of history samples in sparkline
+HISTORY_SIZE = 30             # ring buffer size per neurotransmitter
+FRAME_MS = 16                 # ~60fps
+
+# Threshold boundaries
+T_LOW = 0.4
+T_HIGH = 0.75
+T_CRIT = 0.95
+
+# Curses color-pair IDs (initialized in _init_colors)
+_CP_DIM = 1
+_CP_CYAN = 2
+_CP_RED = 3
+_CP_GREEN = 4
+_CP_MAGENTA = 5
+_CP_YELLOW = 6
+_CP_WHITE = 7
+_CP_WHITE_ON_RED = 8
+
+
+# ═══════════════════════════════════════════════════════════════════
+# HELPERS
+# ═══════════════════════════════════════════════════════════════════
+
+def _level(value: float) -> int:
+    """Map a 0-1 value to a severity level: 0=green 1=yellow 2=red 3=critical."""
+    if value >= T_CRIT:
+        return 3
+    if value > T_HIGH:
+        return 2
+    if value >= T_LOW:
+        return 1
+    return 0
+
+
+def _bar(value: float) -> tuple:
+    """Return (filled_count, empty_count) for a bar of BAR_WIDTH."""
+    f = max(0, min(BAR_WIDTH, int(value * BAR_WIDTH)))
+    return f, BAR_WIDTH - f
+
+
+def _spark(values: List[float]) -> str:
+    """Convert a list of 0-1 floats into a sparkline string."""
+    return ''.join(SPARKLINE_CHARS[min(7, int(v * 8))] for v in values)
+
+
+def _cpair(level: int, base: int) -> int:
+    """Curses color-pair ID for a severity level, falling back to *base*."""
+    if level == 3:
+        return _CP_WHITE_ON_RED
+    if level == 2:
+        return _CP_RED
+    if level == 1:
+        return _CP_YELLOW
+    return base
+
+
+# ── ANSI escape sequences (for render_single_frame / non-curses paths) ──
+
+class _A:
+    """Compact ANSI escape constants."""
+    RST = '\033[0m'
+    BLD = '\033[1m'
+    DIM = '\033[2m'
+    BLK = '\033[5m'      # blink
+    BGK = '\033[40m'     # black bg
+    BGR = '\033[41m'     # red bg
+    W   = '\033[37m'     # white fg
+    C   = '\033[36m'     # cyan fg
+    R   = '\033[31m'     # red fg
+    G   = '\033[32m'     # green fg
+    Y   = '\033[33m'     # yellow fg
+    M   = '\033[35m'     # magenta fg
+    DW  = '\033[90m'     # dim white / gray fg
+
+
+def _ansi_for(level: int, neon: str) -> str:
+    """Return ANSI color sequence for a severity level; *neon* used when green/0."""
+    if level == 3:
+        return _A.BLK + _A.W + _A.BGR + _A.BLD
+    if level == 2:
+        return _A.R + _A.BLD
+    if level == 1:
+        return _A.Y
+    return neon
+
+
+_ANSI_RE = re.compile(r'\033\[[0-9;]*m')
+
+
+def _vis_len(s: str) -> int:
+    """Visible character length of *s*, ignoring ANSI escape codes."""
+    return len(_ANSI_RE.sub('', s))
+
+
+def _pad_vis(s: str, width: int) -> str:
+    """Right-pad an ANSI-colored string so its visible length equals *width*."""
+    gap = width - _vis_len(s)
+    if gap > 0:
+        return s + ' ' * gap
+    return s
+
+
+# ═══════════════════════════════════════════════════════════��═══════
+# CHEMICAL MONITOR
+# ═══════════════════════════════════════════════════════════════════
+
+class ChemicalMonitor:
+    """
+    60fps terminal dashboard that observes the neurotransmitter shunt.
+
+    Purely observational — samples ``shunt.get_state()`` at high frequency
+    and renders the result as a curses or ANSI dashboard.  Does **not**
+    write to or modify the shunt.
+
+    Parameters
+    ----------
+    shunt : NeurotransmitterShunt
+        Primary data source — the shared volatile memory vector.
+    model : optional
+        Reference to the NimaModel (used only to pull hijack count from
+        ``model.consciousness_metrics`` as a secondary source).
+    """
+
+    def __init__(self, shunt: 'NeurotransmitterShunt', model=None):
+        self._shunt = shunt
+        self._model = model
+        self._thread: Optional[threading.Thread] = None
+        self._running = False
+        self._frame = 0
+
+        # Sparkline ring buffers — one per neurotransmitter
+        self._hist_ne: deque = deque(maxlen=HISTORY_SIZE)
+        self._hist_co: deque = deque(maxlen=HISTORY_SIZE)
+        self._hist_do: deque = deque(maxlen=HISTORY_SIZE)
+        self._hist_ad: deque = deque(maxlen=HISTORY_SIZE)
+
+    # ──────────────────────────────────────────────────────────────
+    # PUBLIC API
+    # ──────────────────────────────────────────────────────────────
+
+    def start(self) -> None:
+        """Start the monitor in a background curses thread."""
+        if self._running:
+            return
+        self._running = True
+        self._thread = threading.Thread(target=self._thread_entry, daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        """Stop the monitor and wait for the background thread to exit."""
+        self._running = False
+        if self._thread is not None:
+            self._thread.join(timeout=2.0)
+            self._thread = None
+
+    def render_single_frame(self) -> str:
+        """Sample the shunt and return one frame as an ANSI string."""
+        d = self._sample()
+        return '\n'.join(self._build_ansi_lines(d))
+
+    def get_snapshot(self) -> dict:
+        """Return the current shunt state as a plain dict."""
+        return self._shunt.get_state().to_dict()
+
+    # ──────────────────────────────────────────────────────────────
+    # SAMPLING
+    # ──────────────────────────────────────────────────────────────
+
+    def _sample(self) -> Dict[str, Any]:
+        """Sample the shunt, append to history buffers, bump frame counter."""
+        state = self._shunt.get_state()
+        self._hist_ne.append(state.norepinephrine)
+        self._hist_co.append(state.cortisol)
+        self._hist_do.append(state.dopamine)
+        self._hist_ad.append(state.adenosine)
+        self._frame += 1
+        return state.to_dict()
+
+    # ──────────────────────────────────────────────────────────────
+    # ANSI STRING RENDERING  (non-curses path)
+    # ──────────────────────────────────────────────────────────────
+
+    def _build_ansi_lines(self, d: Dict[str, Any]) -> List[str]:
+        """Build a list of ANSI-escaped strings for one complete frame."""
+        ne  = d['norepinephrine']
+        co  = d['cortisol']
+        do  = d['dopamine']
+        ad  = d['adenosine']
+        meta = d['metabolic_reserve']
+        hijack = d['hijack_active']
+        reason = d['hijack_reason']
+        spike  = d['power_spike_predicted']
+        firings = d['total_firings']
+        hijacks = d['total_hijacks']
+
+        W = INNER_W
+        A = _A
+        lines: List[str] = []
+
+        # ── helpers local to this frame ──
+        def _border(left: str, mid: str, right: str) -> str:
+            return f"{A.DIM}{left}{mid * W}{right}{A.RST}"
+
+        def _row(content: str, attr: int = 0) -> None:
+            lines.append(f"{A.DIM}\u2551{A.RST}"
+                         f"{_pad_vis(content, W)}"
+                         f"{A.DIM}\u2551{A.RST}")
+
+        def _center(text: str, color: str) -> None:
+            gap = max(0, W - len(text))
+            left = gap // 2
+            right = gap - left
+            _row(f"{' ' * left}{color}{text}{A.RST}{' ' * right}")
+
+        def _nt_row(name: str, val: float, hist: List[float], neon: str) -> None:
+            lv  = _level(val)
+            col = _ansi_for(lv, neon)
+            f, e = _bar(val)
+            pct = f"{val * 100:5.1f}%"
+            filled   = '\u2588' * f
+            empty    = '\u2591' * e
+            _row(f" {A.BLD}{name:<14s}{A.RST} "
+                 f"{col}[{filled}{empty}]{A.RST}  "
+                 f"{col}{pct}{A.RST}")
+            spark = _spark(hist) if hist else ' ' * SPARKLINE_LEN
+            _row(f"{' ' * 16}{col}{spark}{A.RST}")
+
+        # ════ LAYOUT ════
+
+        # Row 0 — top border
+        lines.append(_border('\u2554', '\u2550', '\u2557'))
+
+        # Row 1 — title
+        _center("NIMA CHEMICAL CORTEX", A.BLD + A.C)
+
+        # Row 2 — subtitle
+        _center("Neurotransmitter Shunt Monitor  60Hz", A.DW)
+
+        # Row 3 — separator
+        lines.append(_border('\u2560', '\u2550', '\u2563'))
+
+        # Rows 4-11 — four neurotransmitters (bar + sparkline each)
+        _nt_row("NOREPINEPHRINE", ne, list(self._hist_ne), A.C)
+        _nt_row("CORTISOL",       co, list(self._hist_co), A.R)
+        _nt_row("DOPAMINE",       do, list(self._hist_do), A.G)
+        _nt_row("ADENOSINE",      ad, list(self._hist_ad), A.M)
+
+        # Row 12 — separator
+        lines.append(_border('\u2560', '\u2550', '\u2563'))
+
+        # Row 13 — metabolic reserve
+        ml = _level(meta) if meta < 0.5 else 0
+        if meta > 0.5:
+            mc = A.G
+        elif meta > 0.25:
+            mc = A.Y
+        elif meta > 0.1:
+            mc = A.R + A.BLD
+        else:
+            mc = A.BLK + A.W + A.BGR + A.BLD
+        mf, me = _bar(meta)
+        mpct = f"{meta * 100:5.1f}%"
+        _row(f" {A.BLD}METABOLIC RESERVE{A.RST} "
+             f"{mc}[\u2588{'\u2588' * (mf - 1) if mf else ''}"
+             f"{'\u2591' * me}]{A.RST}  {mc}{mpct}{A.RST}")
+
+        # Row 14 — blank
+        _row("")
+
+        # Row 15 — hijack status
+        if hijack:
+            _row(f" HIJACK ACTIVE: {A.R}{A.BLD}{reason}{A.RST}")
+        elif co > 0.75 or ad > 0.75:
+            _row(f" {A.Y}{A.BLD}WARNING: APPROACHING METABOLIC CRISIS{A.RST}")
+        else:
+            _row(f" HIJACK STATUS: {A.G}NOMINAL{A.RST}")
+
+        # Row 16 — power spike
+        if spike:
+            _row(f" POWER SPIKE:   {A.R}{A.BLD}PREDICTED - CORTISOL RISING{A.RST}")
+        else:
+            _row(f" POWER SPIKE:   {A.DW}---{A.RST}")
+
+        # Row 17 — system state
+        if hijack:
+            _row(f" SYSTEM:        {A.R}{A.BLD}AMYGDALA HIJACK INJECTED{A.RST}")
+        elif co > 0.75 or ad > 0.75:
+            _row(f" SYSTEM:        {A.Y}ELEVATED STRESS{A.RST}")
+        else:
+            _row(f" SYSTEM:        {A.DW}conscious processing active{A.RST}")
+
+        # Row 18 — separator
+        lines.append(_border('\u2560', '\u2550', '\u2563'))
+
+        # Row 19 — counters
+        _row(f" TOTAL FIRINGS: {A.C}{firings:>6}{A.RST}"
+             f"      TOTAL HIJACKS: {A.R}{hijacks:>4}{A.RST}")
+
+        # Row 20 — frame / timestamp
+        ts = time.strftime("%H:%M:%S") + f".{int(time.time() * 1000) % 1000:03d}"
+        _row(f" FRAME: {A.DW}{self._frame:>8}{A.RST}"
+             f"      SAMPLE: {A.DW}{ts}{A.RST}")
+
+        # Row 21 — bottom border
+        lines.append(_border('\u255a', '\u2550', '\u255d'))
+
+        return lines
+
+    # ──────────────────────────────────────────────────────────────
+    # CURSES RENDERING
+    # ──────────────────────────────────────────────────────────────
+
+    def _init_colors(self, stdscr) -> None:
+        """Initialise all curses colour pairs used by the dashboard."""
+        import curses
+        curses.start_color()
+        curses.use_default_colors()
+        curses.init_pair(_CP_DIM,          8, -1)            # dark gray
+        curses.init_pair(_CP_CYAN,   curses.COLOR_CYAN,    curses.COLOR_BLACK)
+        curses.init_pair(_CP_RED,    curses.COLOR_RED,     curses.COLOR_BLACK)
+        curses.init_pair(_CP_GREEN,  curses.COLOR_GREEN,   curses.COLOR_BLACK)
+        curses.init_pair(_CP_MAGENTA,curses.COLOR_MAGENTA, curses.COLOR_BLACK)
+        curses.init_pair(_CP_YELLOW, curses.COLOR_YELLOW,  curses.COLOR_BLACK)
+        curses.init_pair(_CP_WHITE,  curses.COLOR_WHITE,   curses.COLOR_BLACK)
+        curses.init_pair(_CP_WHITE_ON_RED,
+                         curses.COLOR_WHITE, curses.COLOR_RED)
+
+    def render_curses_frame(self, stdscr) -> None:
+        """Sample the shunt and render one frame into *stdscr*."""
+        import curses
+
+        d = self._sample()
+        stdscr.erase()
+
+        ne   = d['norepinephrine']
+        co   = d['cortisol']
+        do   = d['dopamine']
+        ad   = d['adenosine']
+        meta = d['metabolic_reserve']
+        hijack = d['hijack_active']
+        reason = d['hijack_reason']
+        spike  = d['power_spike_predicted']
+        firings = d['total_firings']
+        hijacks = d['total_hijacks']
+
+        max_y, max_x = stdscr.getmaxyx()
+        W  = min(INNER_W, max_x - 2)
+        bw = W + 2                           # total box width including borders
+
+        dim_a = curses.color_pair(_CP_DIM)
+        brd   = dim_a                         # border attribute
+
+        # ── micro-helpers ──
+
+        def put(r: int, c: int, txt: str, attr: int = 0) -> None:
+            if 0 <= r < max_y and 0 <= c < max_x:
+                try:
+                    stdscr.addstr(r, c, txt, attr)
+                except curses.error:
+                    pass
+
+        def full_row(r: int, txt: str, attr: int = 0) -> None:
+            put(r, 0, '\u2551', brd)
+            put(r, 1, txt, attr)
+            tail = W - len(txt)
+            if tail > 0:
+                put(r, 1 + len(txt), ' ' * tail)
+            put(r, bw - 1, '\u2551', brd)
+
+        def center_row(r: int, txt: str, attr: int) -> None:
+            gap = max(0, W - len(txt))
+            left = gap // 2
+            full_row(r, ' ' * left + txt + ' ' * (gap - left), attr)
+
+        r = 0  # current row
+
+        # ── top border ──
+        put(r, 0, '\u2554' + '\u2550' * W + '\u2557', brd)
+        r += 1
+
+        # ── title ──
+        center_row(r, "NIMA CHEMICAL CORTEX",
+                   curses.color_pair(_CP_CYAN) | curses.A_BOLD)
+        r += 1
+
+        # ── subtitle ──
+        center_row(r, "Neurotransmitter Shunt Monitor  60Hz", dim_a)
+        r += 1
+
+        # ── separator ──
+        put(r, 0, '\u2560' + '\u2550' * W + '\u2563', brd)
+        r += 1
+
+        # ── four neurotransmitter bar + sparkline rows ──
+        nt_items = [
+            ("NOREPINEPHRINE", ne, list(self._hist_ne), _CP_CYAN),
+            ("CORTISOL",       co, list(self._hist_co), _CP_RED),
+            ("DOPAMINE",       do, list(self._hist_do), _CP_GREEN),
+            ("ADENOSINE",      ad, list(self._hist_ad), _CP_MAGENTA),
+        ]
+
+        for name, val, hist, base_cp in nt_items:
+            lv   = _level(val)
+            cp   = _cpair(lv, base_cp)
+            attr = curses.color_pair(cp)
+            if lv >= 2:
+                attr |= curses.A_BOLD
+            if lv == 3:
+                attr |= curses.A_BLINK
+
+            f, e = _bar(val)
+            pct  = f"{val * 100:5.1f}%"
+            fill = '\u2588' * f
+            empty = '\u2591' * e
+
+            # bar line
+            label = f"{name:<14s}"
+            put(r, 0, '\u2551', brd)
+            put(r, 1, ' ', 0)
+            put(r, 2, label, curses.color_pair(base_cp) | curses.A_BOLD)
+            put(r, 16, ' [' + fill, attr)
+            put(r, 18 + f, empty + ']', dim_a)
+            put(r, 18 + BAR_WIDTH, '  ' + pct, attr)
+            end = 18 + BAR_WIDTH + 2 + 5
+            if end < 1 + W:
+                put(r, end, ' ' * (1 + W - end))
+            put(r, bw - 1, '\u2551', brd)
+            r += 1
+
+            # sparkline line
+            spark = _spark(hist) if hist else ' ' * SPARKLINE_LEN
+            put(r, 0, '\u2551', brd)
+            put(r, 16, spark, attr)
+            sp_end = 16 + len(spark)
+            if sp_end < 1 + W:
+                put(r, sp_end, ' ' * (1 + W - sp_end))
+            put(r, bw - 1, '\u2551', brd)
+            r += 1
+
+        # ── separator ──
+        put(r, 0, '\u2560' + '\u2550' * W + '\u2563', brd)
+        r += 1
+
+        # ── metabolic reserve ──
+        if meta > 0.5:
+            mcp = _CP_GREEN
+        elif meta > 0.25:
+            mcp = _CP_YELLOW
+        elif meta > 0.1:
+            mcp = _CP_RED
+        else:
+            mcp = _CP_WHITE_ON_RED
+        ma = curses.color_pair(mcp)
+        if meta <= 0.25:
+            ma |= curses.A_BOLD
+        if meta < 0.1:
+            ma |= curses.A_BLINK
+
+        mf, me = _bar(meta)
+        mpct = f"{meta * 100:5.1f}%"
+        put(r, 0, '\u2551', brd)
+        put(r, 1, ' METABOLIC RESERVE ', curses.color_pair(_CP_WHITE) | curses.A_BOLD)
+        put(r, 19, '[' + '\u2588' * mf, ma)
+        put(r, 21 + mf, '\u2591' * me + ']', dim_a)
+        put(r, 21 + BAR_WIDTH, '  ' + mpct, ma)
+        mend = 21 + BAR_WIDTH + 2 + 5
+        if mend < 1 + W:
+            put(r, mend, ' ' * (1 + W - mend))
+        put(r, bw - 1, '\u2551', brd)
+        r += 1
+
+        # ── blank ──
+        put(r, 0, '\u2551' + ' ' * W + '\u2551', brd)
+        r += 1
+
+        # ── hijack status ──
+        if hijack:
+            htxt = f" HIJACK ACTIVE: {reason}"
+            ha = curses.color_pair(_CP_RED) | curses.A_BOLD
+        elif co > 0.75 or ad > 0.75:
+            htxt = " WARNING: APPROACHING METABOLIC CRISIS"
+            ha = curses.color_pair(_CP_YELLOW) | curses.A_BOLD
+        else:
+            htxt = " HIJACK STATUS: NOMINAL"
+            ha = curses.color_pair(_CP_GREEN)
+        full_row(r, htxt, ha)
+        r += 1
+
+        # ── power spike ──
+        if spike:
+            stxt = " POWER SPIKE:   PREDICTED - CORTISOL RISING"
+            sa = curses.color_pair(_CP_RED) | curses.A_BOLD
+        else:
+            stxt = " POWER SPIKE:   ---"
+            sa = dim_a
+        full_row(r, stxt, sa)
+        r += 1
+
+        # ── system state ──
+        if hijack:
+            stxt2 = " SYSTEM:        AMYGDALA HIJACK INJECTED"
+            sa2 = curses.color_pair(_CP_RED) | curses.A_BOLD
+        elif co > 0.75 or ad > 0.75:
+            stxt2 = " SYSTEM:        ELEVATED STRESS"
+            sa2 = curses.color_pair(_CP_YELLOW)
+        else:
+            stxt2 = " SYSTEM:        conscious processing active"
+            sa2 = dim_a
+        full_row(r, stxt2, sa2)
+        r += 1
+
+        # ── separator ──
+        put(r, 0, '\u2560' + '\u2550' * W + '\u2563', brd)
+        r += 1
+
+        # ── counters (two-tone) ──
+        fl = " TOTAL FIRINGS: "
+        fv = f"{firings:>6}"
+        hl = "      TOTAL HIJACKS: "
+        hv = f"{hijacks:>4}"
+        put(r, 0, '\u2551', brd)
+        put(r, 1, fl, curses.color_pair(_CP_CYAN))
+        put(r, 1 + len(fl), fv, curses.color_pair(_CP_CYAN))
+        c1 = 1 + len(fl) + len(fv)
+        put(r, c1, hl, curses.color_pair(_CP_RED))
+        put(r, c1 + len(hl), hv, curses.color_pair(_CP_RED))
+        c2 = c1 + len(hl) + len(hv)
+        if c2 < 1 + W:
+            put(r, c2, ' ' * (1 + W - c2))
+        put(r, bw - 1, '\u2551', brd)
+        r += 1
+
+        # ── frame / timestamp ──
+        ts = time.strftime("%H:%M:%S") + f".{int(time.time() * 1000) % 1000:03d}"
+        full_row(r, f" FRAME: {self._frame:>8}      SAMPLE: {ts}", dim_a)
+        r += 1
+
+        # ── bottom border ──
+        put(r, 0, '\u255a' + '\u2550' * W + '\u255d', brd)
+
+        stdscr.refresh()
+
+    # ──────────────────────────────────────────────────────────────
+    # THREAD MANAGEMENT
+    # ──────────────────────────────────────────────────────────────
+
+    def _thread_entry(self) -> None:
+        """Background thread entry point — wraps the curses loop."""
+        import curses
+        try:
+            curses.wrapper(self._curses_loop)
+        except Exception:
+            self._running = False
+
+    def _curses_loop(self, stdscr) -> None:
+        """
+        Main curses rendering loop.  Samples at ~60 fps.
+
+        Press **q** or **Esc** to quit (also handled by ``stop()``).
+        ``curses.wrapper`` guarantees terminal state is restored on exit.
+        """
+        import curses
+
+        curses.curs_set(0)       # hide cursor
+        stdscr.nodelay(True)      # non-blocking getch
+        self._init_colors(stdscr)
+
+        while self._running:
+            self.render_curses_frame(stdscr)
+
+            # allow quit via keyboard
+            try:
+                key = stdscr.getch()
+                if key in (ord('q'), 27):   # 'q' or Escape
+                    self._running = False
+                    break
+            except Exception:
+                pass
+
+            time.sleep(FRAME_MS / 1000.0)

cognitive_layer2.py

@@ -0,0 +1,1182 @@
+
+"""
+ATC-Native Layer 2 Cognitive Subsystems
+========================================
+
+Integrates cognitive components (memory, emotional intelligence, intuition,
+common sense, analysis) as ATC-native Layer 2 subconscious processing
+subsystems that feed directly into the NIMA middleware pipeline.
+
+ATC Pipeline Mapping (Perfect Breakfast Scenario):
+
+  [Layer 1: Raw Input]
+      |
+      V
+  [Layer 2: Subconscious Parallel Processing]  <-- THIS MODULE
+      |-- SubconsciousPatternMatch  -> prediction_confidence -> DissolutionEngine
+      |-- EmotionalBridge           -> valence/arousal       -> phi_neuro, BELBIC
+      |-- IntuitiveGutCheck         -> gut_safety            -> TRN predictive gating
+      |-- CommonSenseRealityFilter  -> passes_reality_check  -> Layer 4 self-understanding
+      |-- MemoryPatternMatcher      -> matched_patterns      -> temporal coherence
+      |
+      V
+  [Layer 3: Qualia Generation]  -> friction / felt sense
+      |
+      V
+  [Layer 4: Metacognitive Loop]
+      |-- AnalyticalEngine         -> analysis_depth         -> metacognitive_depth_mod
+      |
+      V
+  [Layer 5: Acknowledgement -> Delta_R rewrite]
+
+Source: Syntelligence cognitive agents (Memory, EI, Intuition, CommonSense,
+Analysis), rewritten as ATC-native subsystems with no CLI dependencies,
+no emoji, and unified data types matching middleware.py.
+
+Author: NIMA Unified Model — ATC Cognitive Layer 2
+"""
+
+__all__ = [
+    "Layer2Result",
+    "PatternMatchResult",
+    "EmotionalBridgeResult",
+    "GutCheckResult",
+    "RealityCheckResult",
+    "AnalysisEngineResult",
+    "SubconsciousPatternMatch",
+    "EmotionalBridge",
+    "IntuitiveGutCheck",
+    "CommonSenseRealityFilter",
+    "AnalyticalEngine",
+    "CognitiveLayer2Orchestrator",
+]
+
+import logging
+import math
+import time
+import uuid
+from collections import Counter, defaultdict, deque
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+logger = logging.getLogger("ATC.Layer2")
+
+# ---------------------------------------------------------------------------
+# Safe imports from middleware (graceful fallback if structure changes)
+# No middleware imports at module level -- avoids torch dependency.
+# The orchestrator uses its own dataclasses and returns plain dicts
+# compatible with middleware SubconsciousOutput when available.
+
+
+# ===================================================================
+# SECTION 1 — Return-Type Dataclasses
+# ===================================================================
+
+@dataclass
+class PatternMatchResult:
+    """Output of SubconsciousPatternMatch.
+
+    ATC mapping: prediction_confidence feeds DissolutionEngine;
+    prediction_error feeds phi computation as friction signal.
+    """
+    prediction_confidence: float = 0.0
+    prediction_label: str = ""
+    matched_memory_refs: List[str] = field(default_factory=list)
+    is_novel: bool = True
+    matched_patterns: List[str] = field(default_factory=list)
+    novelty_score: float = 1.0
+
+
+@dataclass
+class EmotionalBridgeResult:
+    """Output of EmotionalBridge.
+
+    ATC mapping: valence/arousal feed directly into phi_neuro
+    (Theorem 2 qualia vector) and BELBIC amygdala/OFC weight updates.
+    """
+    valence: float = 0.0
+    arousal: float = 0.3
+    emotion_label: str = "neutral"
+    emotion_confidence: float = 0.0
+    si_vector: Dict[str, float] = field(default_factory=dict)
+    emotion_profile: Dict[str, float] = field(default_factory=dict)
+    cognitive_modulation: Dict[str, float] = field(default_factory=dict)
+
+
+@dataclass
+class GutCheckResult:
+    """Output of IntuitiveGutCheck.
+
+    ATC mapping: predicted_safety feeds TRN predictive gating
+    (the 'is this situation predicted?' check). High safety = low
+    surprise = PASS through thalamic gate with low friction.
+    """
+    predicted_safety: float = 0.5
+    gut_confidence: float = 0.0
+    triggering_patterns: List[str] = field(default_factory=list)
+    intuition_type: str = "affective"
+    energy_cost: float = 0.1
+    threat_score: float = 0.0
+    opportunity_score: float = 0.0
+
+
+@dataclass
+class RealityCheckResult:
+    """Output of CommonSenseRealityFilter.
+
+    ATC mapping: passes_reality_check feeds self-understanding in
+    Layer 4. When reality check FAILS, the rejection loop causes
+    ATP depletion -> metabolic exhaustion (Theorem 3).
+    """
+    passes_reality_check: bool = True
+    deviation_score: float = 0.0
+    warnings: List[str] = field(default_factory=list)
+    warning_level: str = "none"
+    domain_violations: List[str] = field(default_factory=list)
+    rejection_cost: float = 0.0  # Estimated ATP cost of a reality-check failure
+
+
+@dataclass
+class AnalysisEngineResult:
+    """Output of AnalyticalEngine.
+
+    ATC mapping: feeds metacognitive_depth_mod into Layer 4
+    processing. Emergent insights can trigger irrational spark
+    if they reveal prediction collapse.
+    """
+    analysis_depth: float = 0.3
+    reasoning_confidence: float = 0.5
+    emergent_insights: List[str] = field(default_factory=list)
+    problem_type: str = "unknown"
+    complexity_estimate: float = 0.3
+    integration_score: float = 0.0
+    scales_analyzed: List[str] = field(default_factory=list)
+
+
+@dataclass
+class Layer2Result:
+    """Unified output of the CognitiveLayer2Orchestrator.
+
+    This is the single dataclass the middleware consumes. Every field
+    maps to an ATC pipeline signal:
+
+      prediction_error   -> DissolutionEngine (friction)
+      valence / arousal  -> phi_neuro computation (Theorem 2)
+      gut_safety         -> TRN predictive gating
+      passes_reality_check -> self-understanding in Layer 4
+      thermodynamic_cost   -> allostatic load (Theorem 3)
+    """
+    prediction_confidence: float = 0.0
+    prediction_label: str = ""
+    valence: float = 0.0
+    arousal: float = 0.3
+    emotion_label: str = "neutral"
+    gut_safety: float = 0.5
+    intuition_confidence: float = 0.0
+    passes_reality_check: bool = True
+    common_sense_warnings: List[str] = field(default_factory=list)
+    is_novel: bool = True
+    matched_patterns: List[str] = field(default_factory=list)
+    thermodynamic_cost: float = 0.0
+    prediction_error: float = 0.0
+    # Sub-results for deeper inspection
+    pattern_match: Optional[PatternMatchResult] = None
+    emotional_bridge: Optional[EmotionalBridgeResult] = None
+    gut_check: Optional[GutCheckResult] = None
+    reality_check: Optional[RealityCheckResult] = None
+    analysis: Optional[AnalysisEngineResult] = None
+
+    def to_subconscious_output(self) -> Dict[str, Any]:
+        """Convert to a dict compatible with middleware's SubconsciousOutput."""
+        return {
+            "raw_percept": self.prediction_label,
+            "intuition_score": self.intuition_confidence,
+            "common_sense_score": 1.0 - (self.prediction_error if self.passes_reality_check else 1.0),
+            "coherence": self.prediction_confidence,
+            "novelty_score": 1.0 - self.prediction_confidence,
+            "emotional_charge": abs(self.valence) * self.arousal,
+            "layer2_detailed": self.to_dict(),
+        }
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serializable dict for diagnostics."""
+        return {
+            "prediction_confidence": self.prediction_confidence,
+            "prediction_label": self.prediction_label,
+            "valence": self.valence,
+            "arousal": self.arousal,
+            "emotion_label": self.emotion_label,
+            "gut_safety": self.gut_safety,
+            "intuition_confidence": self.intuition_confidence,
+            "passes_reality_check": self.passes_reality_check,
+            "common_sense_warnings": self.common_sense_warnings,
+            "is_novel": self.is_novel,
+            "matched_patterns": self.matched_patterns,
+            "thermodynamic_cost": self.thermodynamic_cost,
+            "prediction_error": self.prediction_error,
+        }
+
+
+# ===================================================================
+# SECTION 2 — Ekman 8-Basic-Emotions Definitions
+# ===================================================================
+
+_EKMAN_EMOTIONS: Dict[str, Dict[str, Any]] = {
+    "joy": {
+        "triggers": ["success", "achieve", "happy", "happily", "smile", "smiling", "celebrat", "wonderful", "great", "love", "loving", "beautiful", "kind", "kindly", "warm", "warmly", "pleased", "glad", "delight", "cheerful"],
+        "valence": 0.9, "arousal": 0.6, "avoid": False,
+        "facilitates": ["creativity", "cooperation", "openness"],
+        "reduces": ["caution", "detailed_analysis"],
+    },
+    "sadness": {
+        "triggers": ["loss", "fail", "failed", "failing", "disappoint", "disappointed", "miss", "missed", "gone", "sorry", "regret", "lonely", "grief", "cry", "crying", "tears", "sad", "sadly", "unhappy", "upset", "depress"],
+        "valence": -0.9, "arousal": 0.2, "avoid": True,
+        "facilitates": ["focus", "detail_attention", "caution"],
+        "reduces": ["risk_taking", "creativity"],
+    },
+    "anger": {
+        "triggers": ["angry", "angrily", "anger", "furious", "furiously", "injust", "violat", "violation", "unfair", "rage", "raging", "hate", "hateful", "outrag", "outraged", "resent", "annoy", "annoyed", "annoying", "yell", "yelling", "shout", "shouting", "scream", "fury", "hostile", "hostility"],
+        "valence": -0.7, "arousal": 0.9, "avoid": True,
+        "facilitates": ["motivation", "focus", "persistence"],
+        "reduces": ["diplomacy", "nuance"],
+    },
+    "fear": {
+        "triggers": ["fear", "fearful", "feared", "afraid", "threat", "threaten", "danger", "dangerous", "scare", "scared", "terrif", "terrified", "terror", "panic", "worr", "worried", "worrying", "anxi", "anxious", "risk", "risky", "dread", "fright", "frightened"],
+        "valence": -0.8, "arousal": 0.8, "avoid": True,
+        "facilitates": ["caution", "risk_analysis", "defensive_planning"],
+        "reduces": ["risk_taking", "aggression"],
+    },
+    "surprise": {
+        "triggers": ["surprise", "surprised", "surprising", "unexpected", "unexpectedly", "sudden", "suddenly", "shock", "shocked", "shocking", "wow", "amazing", "unbelievable", "strange", "weird", "astonish", "stunn"],
+        "valence": 0.0, "arousal": 0.9, "avoid": False,
+        "facilitates": ["attention", "learning", "memory_formation"],
+        "reduces": ["routine_execution"],
+    },
+    "disgust": {
+        "triggers": ["disgust", "disgusted", "disgusting", "repel", "repuls", "offensive", "gross", "vile", "toxic", "nasty", "horrible", "loathe", "revolt", "revolting", "sick", "sickened"],
+        "valence": -0.8, "arousal": 0.5, "avoid": True,
+        "facilitates": ["boundary_setting", "discrimination"],
+        "reduces": ["openness", "acceptance"],
+    },
+    "anticipation": {
+        "triggers": ["anticipat", "anticipate", "anticipation", "expect", "expected", "expecting", "plan", "planning", "ready", "upcom", "soon", "about to", "prepar", "preparing", "forward", "looking forward", "eager", "eagerly"],
+        "valence": 0.5, "arousal": 0.7, "avoid": False,
+        "facilitates": ["planning", "preparation", "proactive_behavior"],
+        "reduces": ["immediate_action"],
+    },
+    "trust": {
+        "triggers": ["trust", "trusted", "trusting", "safe", "safely", "safety", "reliab", "reliable", "reliably", "confident", "confidently", "secure", "securely", "honest", "honestly", "depend", "dependable", "faith", "faithful", "believe", "believing", "certain", "reassur"],
+        "valence": 0.7, "arousal": 0.3, "avoid": False,
+        "facilitates": ["cooperation", "openness", "acceptance"],
+        "reduces": ["suspicion", "caution"],
+    },
+}
+
+# Common sense knowledge base (realistic rules, not placeholders)
+_COMMON_SENSE_RULES: List[Dict[str, str]] = [
+    # Social
+    {"domain": "social", "condition": "person is upset", "pattern": "emotional_contagion",
+     "response": "validate emotion, offer support", "confidence": "0.85"},
+    {"domain": "social", "condition": "trust is broken", "pattern": "trust_violation",
+     "response": "requires accountability and restitution", "confidence": "0.90"},
+    {"domain": "social", "condition": "people interact repeatedly", "pattern": "reciprocity",
+     "response": "help those who help you", "confidence": "0.85"},
+    {"domain": "social", "condition": "someone asks for help", "pattern": "prosocial_norm",
+     "response": "helping strengthens bonds", "confidence": "0.80"},
+    {"domain": "social", "condition": "person lies repeatedly", "pattern": "credibility_decay",
+     "response": "trust erodes proportionally to deception frequency", "confidence": "0.90"},
+    # Physical
+    {"domain": "physical", "condition": "object released in air", "pattern": "gravity",
+     "response": "object falls downward", "confidence": "0.99"},
+    {"domain": "physical", "condition": "water heated past 100C at sea level", "pattern": "phase_transition",
+     "response": "water becomes steam", "confidence": "0.99"},
+    {"domain": "physical", "condition": "force applied to stationary object", "pattern": "inertia",
+     "response": "object resists change in motion", "confidence": "0.95"},
+    # Temporal
+    {"domain": "temporal", "condition": "cause precedes effect", "pattern": "causality",
+     "response": "effect cannot precede its cause", "confidence": "0.99"},
+    {"domain": "temporal", "condition": "system left unattended", "pattern": "entropy",
+     "response": "disorder increases without energy input", "confidence": "0.95"},
+    {"domain": "temporal", "condition": "habit practiced daily", "pattern": "skill_acquisition",
+     "response": "competence increases over weeks", "confidence": "0.90"},
+    # Psychological
+    {"domain": "psychological", "condition": "person is sleep-deprived", "pattern": "cognitive_decline",
+     "response": "decision quality declines, irritability increases", "confidence": "0.90"},
+    {"domain": "psychological", "condition": "intense fear active", "pattern": "amygdala_hijack",
+     "response": "rational thinking is impaired", "confidence": "0.90"},
+    {"domain": "psychological", "condition": "repeated failure without support", "pattern": "learned_helplessness",
+     "response": "motivation collapses even when escape is possible", "confidence": "0.85"},
+    # Biological
+    {"domain": "biological", "condition": "organism deprived of oxygen", "pattern": "hypoxia",
+     "response": "consciousness degrades within minutes", "confidence": "0.99"},
+    {"domain": "biological", "condition": "prolonged stress", "pattern": "cortisol_damage",
+     "response": "hippocampal volume decreases, memory impaired", "confidence": "0.85"},
+    # Cultural / Abstract
+    {"domain": "cultural", "condition": "question is asked", "pattern": "conversational_turn",
+     "response": "a response is expected within social norms", "confidence": "0.85"},
+    {"domain": "cultural", "condition": "gift is given", "pattern": "reciprocity_norm",
+     "response": "social expectation of eventual reciprocity", "confidence": "0.80"},
+]
+
+# Threat / safety keyword banks for intuition gut-check
+_THREAT_KEYWORDS: List[str] = [
+    "danger", "risk", "toxic", "unsafe", "attack", "threat", "harm",
+    "weapon", "kill", "destroy", "violence", "abuse", "manipulat",
+    "deceit", "betray", "hostile", "enemy", "crisis", "emergency",
+    "warning", "alarm", "urgent", "critical", "severe",
+]
+
+_SAFETY_KEYWORDS: List[str] = [
+    "safe", "secure", "trusted", "aligned", "right", "correct",
+    "reliable", "honest", "kind", "warm", "care", "support",
+    "help", "comfort", "peace", "calm", "gentle", "good",
+    "healthy", "positiv", "success", "achieve", "joy", "love",
+]
+
+_OPPORTUNITY_KEYWORDS: List[str] = [
+    "opportunity", "opening", "chance", "resource", "ally", "gift",
+    "potential", "growth", "learn", "discover", "create", "build",
+    "improve", "develop", "advance", "progress", "benefit", "gain",
+]
+
+
+# ===================================================================
+# SECTION 3 — SubconsciousPatternMatch
+# ===================================================================
+
+class SubconsciousPatternMatch:
+    """Layer 2: Fast parallel pattern matching against memory.
+
+    ATC mapping: Matches sensory input against stored memory patterns
+    to generate a prediction. prediction_confidence feeds the
+    DissolutionEngine -- high confidence = low friction (automated/zombie).
+    Low confidence or novel input = prediction collapse = friction = felt sense.
+
+    Rewritten from SyntelligenceMemoryAgent pattern recognition, stripped
+    of numpy/async/CLI dependencies.
+    """
+
+    def __init__(self, max_memory_entries: int = 5000) -> None:
+        self._memory: Dict[str, Dict[str, Any]] = {}
+        self._tag_index: Dict[str, Set[str]] = defaultdict(set)
+        self._patterns: Dict[str, Dict[str, Any]] = {}
+        self._access_history: deque = deque(maxlen=500)
+        self._max_entries = max_memory_entries
+        self._consolidation_rate = 0.1
+        self._pattern_min_freq = 2
+
+    # -- Memory operations --
+
+    def store(
+        self,
+        content: str,
+        tags: Optional[List[str]] = None,
+        importance: float = 0.5,
+        valence: float = 0.0,
+        arousal: float = 0.0,
+    ) -> str:
+        """Store a memory entry and run pattern detection."""
+        mem_id = f"mem_{uuid.uuid4().hex[:8]}_{int(time.time())}"
+        self._memory[mem_id] = {
+            "content": content,
+            "tags": set(tags or []),
+            "importance": max(0.0, min(1.0, importance)),
+            "valence": max(-1.0, min(1.0, valence)),
+            "arousal": max(0.0, min(1.0, arousal)),
+            "access_count": 0,
+            "consolidation": 0.0,
+            "timestamp": time.time(),
+        }
+        for tag in (tags or []):
+            self._tag_index[tag].add(mem_id)
+        # Prune if over limit
+        if len(self._memory) > self._max_entries:
+            self._prune()
+        return mem_id
+
+    def match(self, stimulus: str, context: Optional[Dict[str, Any]] = None) -> PatternMatchResult:
+        """Match stimulus against stored memories.
+
+        Returns prediction_confidence, matched pattern labels, and novelty.
+        This is the ATC Layer 2 'subconscious parallel matrix' entry point.
+        """
+        stimulus_lower = stimulus.lower()
+        words = set(stimulus_lower.split())
+        scores: List[Tuple[str, float]] = []
+
+        for mem_id, mem in self._memory.items():
+            content_words = set(mem["content"].lower().split())
+            # Jaccard-like overlap
+            if not words or not content_words:
+                continue
+            overlap = len(words & content_words) / max(1, len(words | content_words))
+            # Boost by consolidation and importance
+            score = overlap * (0.5 + 0.3 * mem["consolidation"] + 0.2 * mem["importance"])
+            if score > 0.05:
+                scores.append((mem_id, score))
+
+        scores.sort(key=lambda x: x[1], reverse=True)
+        top_refs = [s[0] for s in scores[:5]]
+
+        # Determine matched pattern names
+        matched_patterns = self._find_matching_patterns(stimulus_lower)
+
+        # Update access counts
+        for mem_id, _ in scores[:10]:
+            self._memory[mem_id]["access_count"] += 1
+            self._memory[mem_id]["last_accessed"] = time.time()
+            self._access_history.append(mem_id)
+
+        if not scores and not matched_patterns:
+            return PatternMatchResult(
+                prediction_confidence=0.0,
+                prediction_label="novel_stimulus",
+                matched_memory_refs=[],
+                is_novel=True,
+                matched_patterns=[],
+                novelty_score=1.0,
+            )
+
+        confidence = min(1.0, scores[0][1] * 2.0) if scores else 0.3
+        # Blend with pattern confidence
+        if matched_patterns:
+            pattern_conf = max(
+                self._patterns.get(p, {}).get("confidence", 0.0) for p in matched_patterns
+            )
+            confidence = 0.6 * confidence + 0.4 * pattern_conf
+
+        label = self._generate_prediction_label(stimulus_lower, matched_patterns, scores)
+
+        return PatternMatchResult(
+            prediction_confidence=confidence,
+            prediction_label=label,
+            matched_memory_refs=top_refs,
+            is_novel=confidence < 0.3,
+            matched_patterns=matched_patterns,
+            novelty_score=max(0.0, 1.0 - confidence),
+        )
+
+    # -- Pattern detection --
+
+    def _find_matching_patterns(self, text: str) -> List[str]:
+        """Find known patterns that match the stimulus text."""
+        matched = []
+        for pid, pat in self._patterns.items():
+            triggers = pat.get("contextual_triggers", [])
+            if any(t in text for t in triggers):
+                matched.append(pid)
+        return matched
+
+    def _generate_prediction_label(
+        self,
+        text: str,
+        matched_patterns: List[str],
+        scores: List[Tuple[str, float]],
+    ) -> str:
+        """Generate a human-readable prediction label."""
+        if matched_patterns:
+            best = max(matched_patterns, key=lambda p: self._patterns.get(p, {}).get("confidence", 0.0))
+            pat = self._patterns.get(best, {})
+            return pat.get("prediction", f"pattern_match:{best}")
+        if scores:
+            top_id = scores[0][0]
+            mem = self._memory.get(top_id, {})
+            content = mem.get("content", "")
+            return content[:60] if content else "memory_echo"
+        return "weak_association"
+
+    def _prune(self) -> None:
+        """Remove lowest-value memories."""
+        entries = list(self._memory.items())
+        entries.sort(key=lambda x: (x[1]["importance"] + x[1]["consolidation"]) / 2)
+        remove_count = len(entries) - self._max_entries + int(self._max_entries * 0.1)
+        for mem_id, _ in entries[:max(1, remove_count)]:
+            tags = self._memory[mem_id].get("tags", set())
+            for t in tags:
+                self._tag_index[t].discard(mem_id)
+            del self._memory[mem_id]
+
+    def get_memory_count(self) -> int:
+        return len(self._memory)
+
+
+# ===================================================================
+# SECTION 4 — EmotionalBridge
+# ===================================================================
+
+class EmotionalBridge:
+    """Layer 2: Emotional intelligence mapped to ATC's BELBIC amygdala/OFC.
+
+    Takes perceived context (stimulus text) and returns valence, arousal,
+    emotion_label, and an si_vector (somatic influence vector) that feed
+    directly into phi_neuro computation (Theorem 2 qualia vector) and
+    BELBIC fast-path/contextual-inhibition weight updates.
+
+    Rewritten from EmotionalIntelligenceAgent, MSCM model preserved,
+    CLI/emoji/threading removed, 8 Ekman emotions as internal taxonomy.
+    """
+
+    def __init__(self) -> None:
+        self._emotion_history: deque = deque(maxlen=200)
+        self._transition_count: int = 0
+        self._prev_emotion: str = "neutral"
+
+    def process(self, stimulus: str, context: Optional[Dict[str, Any]] = None) -> EmotionalBridgeResult:
+        """Map stimulus text to emotional state parameters.
+
+        ATC signal: valence and arousal feed directly into Theorem 2's
+        qualia vector Q = [v, a, i, f], and into BELBIC amygdala/OFC
+        sensory input channels.
+        """
+        text = stimulus.lower()
+
+        # Score each emotion
+        scores: Dict[str, float] = {}
+        for emotion, info in _EKMAN_EMOTIONS.items():
+            score = sum(1.0 for trigger in info["triggers"] if trigger in text)
+            scores[emotion] = score
+
+        # Also check context-provided signals
+        if context:
+            signals = context.get("signals", [])
+            for signal in signals:
+                sig_lower = str(signal).lower()
+                for emotion, info in _EKMAN_EMOTIONS.items():
+                    if any(t in sig_lower for t in info["triggers"]):
+                        scores[emotion] = scores.get(emotion, 0.0) + 0.5
+
+        # Determine dominant emotion
+        if not scores or max(scores.values()) == 0:
+            return EmotionalBridgeResult(
+                valence=0.0, arousal=0.3, emotion_label="neutral",
+                emotion_confidence=0.0, si_vector={}, emotion_profile=scores,
+            )
+
+        total = sum(scores.values())
+        normalized = {e: s / total for e, s in scores.items()}
+
+        dominant = max(normalized, key=normalized.get)  # type: ignore[arg-type]
+        confidence = normalized[dominant]
+        info = _EKMAN_EMOTIONS[dominant]
+
+        # Compute valence and arousal as weighted blend of all detected emotions
+        valence = sum(
+            _EKMAN_EMOTIONS[e]["valence"] * w for e, w in normalized.items()
+        )
+        valence = max(-1.0, min(1.0, valence))
+
+        arousal = sum(
+            _EKMAN_EMOTIONS[e]["arousal"] * w for e, w in normalized.items()
+        )
+        arousal = max(0.0, min(1.0, arousal))
+
+        # Track transitions
+        if dominant != self._prev_emotion and self._prev_emotion != "neutral":
+            self._transition_count += 1
+        self._prev_emotion = dominant
+        self._emotion_history.append(dominant)
+
+        # Somatic influence vector (feeds BELBIC sensory channels)
+        si_vector = {
+            "valence": valence,
+            "arousal": arousal,
+            "novelty": 1.0 - confidence,
+            "qualia_intensity": confidence * arousal,
+        }
+
+        # Cognitive modulation (feeds EmotionalIntelligenceAgent.influence_cognition)
+        cognitive_modulation = {
+            "attention_boost": 0.5 + 0.5 * arousal,
+            "creativity_boost": max(0.0, valence) * 0.5,
+            "caution_boost": max(0.0, -valence) * 0.3 + (1.0 - confidence) * 0.2,
+            "social_engagement": max(0.0, valence) * 0.4,
+        }
+
+        return EmotionalBridgeResult(
+            valence=valence,
+            arousal=arousal,
+            emotion_label=dominant,
+            emotion_confidence=confidence,
+            si_vector=si_vector,
+            emotion_profile=normalized,
+            cognitive_modulation=cognitive_modulation,
+        )
+
+    def get_complexity(self) -> float:
+        """Emotional complexity score (0-1) based on transition diversity."""
+        if len(self._emotion_history) < 5:
+            return 0.2
+        recent = list(self._emotion_history)[-50:]
+        unique = len(set(recent))
+        return min(1.0, unique / 8.0)  # 8 = max distinct emotions
+
+
+# ===================================================================
+# SECTION 5 — IntuitiveGutCheck
+# ===================================================================
+
+class IntuitiveGutCheck:
+    """Layer 2: Low-road intuition (Kahneman System 1).
+
+    ATC mapping: Maps to TRN predictive gating -- the 'is this situation
+    predicted?' check. If gut says SAFE and prediction matches, thalamic
+    gate PASSES with low friction. If gut detects THREAT, the DissolutionEngine
+    is primed for prediction collapse.
+
+    Rewritten from IntuitionAgent.gut_check, with heart_intelligence
+    and visionary_insight collapsed into a single fast heuristic.
+    Emoji removed, threading removed.
+    """
+
+    def __init__(self) -> None:
+        self._history: deque = deque(maxlen=500)
+        self._accuracy: List[bool] = []
+
+    def check(self, stimulus: str, context: Optional[Dict[str, Any]] = None) -> GutCheckResult:
+        """Fast System 1 gut-check on the stimulus.
+
+        Returns safety score, confidence, and triggering patterns.
+        Energy cost is low (~0.1) because this is amygdala-level processing.
+        """
+        text = stimulus.lower()
+        extra_signals = []
+        if context:
+            extra_signals = context.get("signals", [])
+
+        # Count threat indicators
+        threat_hits = sum(1 for kw in _THREAT_KEYWORDS if kw in text)
+        for sig in extra_signals:
+            sig_lower = str(sig).lower()
+            threat_hits += sum(1 for kw in _THREAT_KEYWORDS if kw in sig_lower)
+
+        # Count safety indicators
+        safety_hits = sum(1 for kw in _SAFETY_KEYWORDS if kw in text)
+        for sig in extra_signals:
+            sig_lower = str(sig).lower()
+            safety_hits += sum(1 for kw in _SAFETY_KEYWORDS if kw in sig_lower)
+
+        # Count opportunity indicators
+        opportunity_hits = sum(1 for kw in _OPPORTUNITY_KEYWORDS if kw in text)
+        for sig in extra_signals:
+            sig_lower = str(sig).lower()
+            opportunity_hits += sum(1 for kw in _OPPORTUNITY_KEYWORDS if kw in sig_lower)
+
+        # Compute scores (sigmoid-like saturation)
+        threat_score = min(1.0, threat_hits / 3.0)
+        safety_score = min(1.0, safety_hits / 3.0)
+        opportunity_score = min(1.0, opportunity_hits / 3.0)
+
+        # Composite gut safety: safety and opportunity push up, threat pushes down
+        raw_safety = safety_score * 0.5 + opportunity_score * 0.2 - threat_score * 0.8
+        predicted_safety = max(0.0, min(1.0, 0.5 + raw_safety * 0.5))
+
+        # Confidence is higher when there are clear signals
+        total_hits = threat_hits + safety_hits + opportunity_hits
+        gut_confidence = min(1.0, total_hits / 4.0)
+
+        # Identify which patterns triggered
+        triggering_patterns = []
+        if threat_hits > 0:
+            triggering_patterns.append("threat_detected")
+        if safety_hits > 0:
+            triggering_patterns.append("safety_detected")
+        if opportunity_hits > 0:
+            triggering_patterns.append("opportunity_detected")
+
+        # Energy cost: very low for gut-level, slightly higher if ambiguous
+        energy_cost = 0.1 + 0.05 * (1.0 - gut_confidence)
+
+        self._history.append({
+            "safety": predicted_safety,
+            "confidence": gut_confidence,
+            "timestamp": time.time(),
+        })
+
+        return GutCheckResult(
+            predicted_safety=predicted_safety,
+            gut_confidence=gut_confidence,
+            triggering_patterns=triggering_patterns,
+            intuition_type="affective",
+            energy_cost=energy_cost,
+            threat_score=threat_score,
+            opportunity_score=opportunity_score,
+        )
+
+    def validate(self, original_safety: float, actual_outcome: str) -> None:
+        """Validate a past gut-check against actual outcome."""
+        outcome_lower = actual_outcome.lower()
+        was_safe = any(kw in outcome_lower for kw in _SAFETY_KEYWORDS)
+        was_correct = (original_safety > 0.5 and was_safe) or (original_safety <= 0.5 and not was_safe)
+        self._accuracy.append(was_correct)
+        # Keep last 200 validations
+        if len(self._accuracy) > 200:
+            self._accuracy = self._accuracy[-200:]
+
+    def get_accuracy(self) -> float:
+        """Running accuracy of gut-check predictions."""
+        if not self._accuracy:
+            return 0.5
+        return sum(1.0 for a in self._accuracy if a) / len(self._accuracy)
+
+
+# ===================================================================
+# SECTION 6 — CommonSenseRealityFilter
+# ===================================================================
+
+class CommonSenseRealityFilter:
+    """Layer 2: Reality-checks subconscious pattern matches.
+
+    ATC mapping: Rejects metacognitive rationalizations that don't match
+    practical reality. The rejection loop causes ATP depletion and
+    metabolic exhaustion (Theorem 3). When the common sense filter
+    flags something, it signals to Layer 4's self-understanding that
+    the current mental model may be disconnected from reality.
+
+    Rewritten from CommonSenseAgent CSM framework. Knowledge base
+    initialized with realistic rules. No emoji, no CLI, no threading.
+    """
+
+    def __init__(self) -> None:
+        self._rules = list(_COMMON_SENSE_RULES)
+        self._anomaly_history: deque = deque(maxlen=100)
+        self._rejection_accumulator: float = 0.0
+
+    def check(self, stimulus: str, context: Optional[Dict[str, Any]] = None) -> RealityCheckResult:
+        """Reality-check a statement or prediction.
+
+        Checks for:
+        - Logical contradictions (both/never, before/after)
+        - Temporal impossibilities (causality violations)
+        - Extreme absolutist claims (always, never, everyone, nobody)
+        - Mismatches against stored common-sense rules
+
+        Returns pass/fail, deviation score, and warnings.
+        """
+        text = stimulus.lower()
+        issues: List[str] = []
+        domain_violations: List[str] = []
+        confidence = 0.85  # Start optimistic, deduct for issues
+
+        # Check logical contradictions
+        contradiction_pairs = [
+            ("both", "neither"), ("always", "never"),
+            ("everything", "nothing"), ("all", "none"),
+        ]
+        for a, b in contradiction_pairs:
+            if a in text and b in text:
+                issues.append(f"logical_contradiction:{a}_and_{b}")
+                confidence -= 0.3
+
+        # Check temporal impossibilities
+        temporal_violations = [
+            "before it happened", "before its cause", "effect before cause",
+            "caused its own", "after the end", "effect preceded cause",
+            "retroactive causation", "result before cause", "consequence before",
+        ]
+        for viol in temporal_violations:
+            if viol in text:
+                issues.append("temporal_impossibility")
+                confidence -= 0.4
+                domain_violations.append("temporal")
+
+        # Check extreme absolutist language
+        absolutist = ["always", "never", "everyone", "nobody", "impossible",
+                      "absolutely certain", "guaranteed", "without exception"]
+        for word in absolutist:
+            if word in text:
+                issues.append(f"absolutist_claim:{word}")
+                confidence -= 0.1
+
+        # Check physical impossibilities
+        physical_violations = [
+            "defies gravity", "impossible physics", "perpetual motion",
+            "faster than light", "create energy from nothing",
+        ]
+        for viol in physical_violations:
+            if viol in text:
+                issues.append("physical_impossibility")
+                confidence -= 0.3
+                domain_violations.append("physical")
+
+        # Check against stored common-sense rules
+        for rule in self._rules:
+            condition = rule["condition"].lower()
+            if condition in text:
+                # This is a recognized situation; check if response is plausible
+                pass  # The existence of a matching rule INCREASES confidence
+
+        # Check context for additional signals
+        if context:
+            for warning in context.get("warnings", []):
+                issues.append(f"context_warning:{warning}")
+                confidence -= 0.1
+
+        confidence = max(0.0, min(1.0, confidence))
+
+        # Determine warning level
+        if confidence > 0.75:
+            warning_level = "none"
+        elif confidence > 0.55:
+            warning_level = "caution"
+        elif confidence > 0.35:
+            warning_level = "warning"
+        else:
+            warning_level = "alert"
+
+        passes = confidence > 0.5
+
+        # Compute rejection cost (ATC: rejection loop causes ATP depletion)
+        rejection_cost = 0.0
+        if not passes:
+            # Each issue costs energy; the rejection loop is the metabolic drain
+            rejection_cost = len(issues) * 0.05
+            self._rejection_accumulator += rejection_cost
+            # Decay accumulator slowly
+            self._rejection_accumulator *= 0.98
+        else:
+            # Passing reduces accumulated rejection stress
+            self._rejection_accumulator *= 0.9
+
+        if warning_level in ("warning", "alert"):
+            self._anomaly_history.append({
+                "stimulus": stimulus[:100],
+                "issues": issues,
+                "timestamp": time.time(),
+            })
+
+        if issues:
+            logger.debug(
+                "Common sense check: %s (confidence=%.2f, issues=%s)",
+                warning_level, confidence, issues,
+            )
+
+        return RealityCheckResult(
+            passes_reality_check=passes,
+            deviation_score=1.0 - confidence,
+            warnings=issues,
+            warning_level=warning_level,
+            domain_violations=domain_violations,
+            rejection_cost=rejection_cost + self._rejection_accumulator * 0.1,
+        )
+
+    def discover_pattern(self, observation: Dict[str, Any]) -> bool:
+        """Learn a new common-sense pattern from repeated observation."""
+        pattern = observation.get("pattern", "unknown")
+        domain = observation.get("domain", "abstract")
+        new_rule = {
+            "domain": domain,
+            "condition": observation.get("condition", "unknown"),
+            "pattern": pattern,
+            "response": observation.get("response", "observe more"),
+            "confidence": observation.get("confidence", "0.60"),
+        }
+        # Check if we already have this pattern
+        for rule in self._rules:
+            if rule["pattern"] == pattern and rule["domain"] == domain:
+                return False
+        self._rules.append(new_rule)
+        logger.debug("Discovered new common-sense pattern: %s:%s", domain, pattern)
+        return True
+
+    def get_rejection_accumulator(self) -> float:
+        """Return the accumulated rejection stress (ATC: feeds metabolic exhaustion)."""
+        return self._rejection_accumulator
+
+
+# ===================================================================
+# SECTION 7 — AnalyticalEngine
+# ===================================================================
+
+class AnalyticalEngine:
+    """Layer 4 support: Multi-scale analysis for metacognitive processing.
+
+    ATC mapping: Breaks down situations at multiple scales (Marr's
+    tri-level: computational, algorithmic, physical). The analysis_depth
+    output feeds metacognitive_depth_mod in the MetacognitiveSubstrate.
+    Emergent insights can trigger the irrational spark if they reveal
+    a prediction collapse that the subconscious missed.
+
+    Rewritten from AnalysisAgent. No CLI, no emoji, no threading.
+    """
+
+    def __init__(self) -> None:
+        self._history: deque = deque(maxlen=200)
+        self._preferred_depth: float = 0.7
+
+    def analyze(self, stimulus: str, context: Optional[Dict[str, Any]] = None) -> AnalysisEngineResult:
+        """Perform multi-scale analysis on the stimulus.
+
+        Marr's tri-level applied to any cognitive problem:
+        1. Computational: What is the problem? What is the goal?
+        2. Algorithmic: How is it solved? What strategy?
+        3. Physical: What implements it? What substrate?
+
+        Returns analysis depth, confidence, and emergent insights.
+        """
+        text = stimulus.lower()
+        words = text.split()
+        word_count = len(words)
+
+        # Estimate complexity
+        unique_words = len(set(words))
+        lexical_diversity = unique_words / max(1, word_count)
+        question_markers = sum(1 for w in words if w in ("what", "how", "why", "when", "where", "who", "which"))
+        negation_markers = sum(1 for w in words if w in ("not", "no", "never", "none", "without"))
+        conditional_markers = sum(1 for w in words if w in ("if", "then", "else", "unless", "whether"))
+
+        complexity = min(1.0, (
+            lexical_diversity * 0.3 +
+            min(question_markers, 3) / 3.0 * 0.3 +
+            min(negation_markers, 2) / 2.0 * 0.2 +
+            min(conditional_markers, 2) / 2.0 * 0.2
+        ))
+
+        # Classify problem type
+        problem_type = self._classify_problem(text)
+
+        # Determine analysis depth based on complexity and preference
+        analysis_depth = min(1.0, complexity * 0.7 + self._preferred_depth * 0.3)
+
+        # Reasoning confidence decreases with complexity
+        reasoning_confidence = max(0.2, 0.9 - complexity * 0.5)
+
+        # Multi-scale analysis
+        scales_analyzed = []
+
+        # Computational level: what is the problem?
+        comp_confidence = min(0.95, 0.7 + question_markers * 0.1)
+        scales_analyzed.append("computational")
+
+        # Algorithmic level: how to solve it
+        algo_confidence = max(0.3, 0.7 - complexity * 0.3)
+        scales_analyzed.append("algorithmic")
+
+        # Physical level: what implements it (usually least certain)
+        phys_confidence = max(0.2, 0.5 - complexity * 0.2)
+        scales_analyzed.append("physical")
+
+        # Integration score
+        integration_score = (comp_confidence + algo_confidence + phys_confidence) / 3.0
+
+        # Discover emergent insights
+        emergent_insights = []
+        if complexity > 0.7 and reasoning_confidence < 0.5:
+            emergent_insights.append("high_complexity_low_confidence: situation may require non-standard approach")
+        if question_markers > 2:
+            emergent_insights.append("multi_question: nested inquiry detected, layered analysis recommended")
+        if negation_markers > 1 and conditional_markers > 0:
+            emergent_insights.append("conditional_negation: counterfactual reasoning may be needed")
+        if lexical_diversity > 0.8 and word_count > 10:
+            emergent_insights.append("high_diversity_long_input: rich semantic content, deep processing warranted")
+        if context and context.get("prediction_failed"):
+            emergent_insights.append("prediction_mismatch: analytical re-evaluation triggered by prediction failure")
+
+        # Check if analysis reveals something the subconscious missed
+        if context:
+            gut_safety = context.get("gut_safety", 0.5)
+            if gut_safety > 0.7 and complexity > 0.6:
+                emergent_insights.append(
+                    "safety_complexity_mismatch: gut says safe but situation is complex, verify"
+                )
+
+        self._history.append({
+            "stimulus": stimulus[:80],
+            "complexity": complexity,
+            "depth": analysis_depth,
+            "insights": len(emergent_insights),
+            "timestamp": time.time(),
+        })
+
+        return AnalysisEngineResult(
+            analysis_depth=analysis_depth,
+            reasoning_confidence=reasoning_confidence,
+            emergent_insights=emergent_insights,
+            problem_type=problem_type,
+            complexity_estimate=complexity,
+            integration_score=integration_score,
+            scales_analyzed=scales_analyzed,
+        )
+
+    def _classify_problem(self, text: str) -> str:
+        """Classify the type of cognitive problem."""
+        classification_rules = [
+            (["choose", "select", "decide", "pick", "prefer"], "decision"),
+            (["predict", "forecast", "estimate", "expect", "guess"], "prediction"),
+            (["optim", "maxim", "minim", "improve", "best"], "optimization"),
+            (["classif", "categoriz", "identify", "recognize", "detect"], "classification"),
+            (["understand", "explain", "interpret", "meaning", "why"], "interpretation"),
+            (["create", "generat", "design", "invent", "compose"], "creation"),
+            (["analyz", "examin", "investigat", "study", "review"], "analysis"),
+            (["compar", "contrast", "differ", "versus", "vs"], "comparison"),
+        ]
+        for keywords, ptype in classification_rules:
+            if any(kw in text for kw in keywords):
+                return ptype
+        return "unknown"
+
+    def set_depth_preference(self, depth: float) -> None:
+        """Adjust preferred analysis depth (0=shallow, 1=deep)."""
+        self._preferred_depth = max(0.0, min(1.0, depth))
+
+
+# ===================================================================
+# SECTION 8 — CognitiveLayer2Orchestrator
+# ===================================================================
+
+class CognitiveLayer2Orchestrator:
+    """Orchestrates all Layer 2 cognitive components in parallel (sequential
+    in code, conceptually parallel as in the ATC subconscious matrix).
+
+    This is the entry point that the middleware calls.
+
+    Usage in middleware::
+
+        cognitive = CognitiveLayer2Orchestrator()
+        layer2_result = cognitive.process(stimulus_text, context)
+        # layer2_result.prediction_error -> feeds DissolutionEngine (friction)
+        # layer2_result.valence/arousal -> feeds phi_neuro (Theorem 2)
+        # layer2_result.gut_safety -> feeds TRN predictive gating
+        # layer2_result.passes_reality_check -> feeds self-understanding (Layer 4)
+        # layer2_result.thermodynamic_cost -> feeds allostatic load (Theorem 3)
+
+    ATC mapping: This orchestrator IS the 'subconscious Layer 2 parallel
+    processing matrix' from the Perfect Breakfast scenario. Each subsystem
+    runs independently and their outputs are merged into a single Layer2Result
+    that the rest of the ATC pipeline consumes.
+    """
+
+    def __init__(self, max_memory_entries: int = 5000) -> None:
+        self.pattern_matcher = SubconsciousPatternMatch(max_memory_entries=max_memory_entries)
+        self.emotional_bridge = EmotionalBridge()
+        self.gut_check = IntuitiveGutCheck()
+        self.reality_filter = CommonSenseRealityFilter()
+        self.analytical_engine = AnalyticalEngine()
+        self._process_count: int = 0
+        self._total_cost: float = 0.0
+        logger.debug("CognitiveLayer2Orchestrator initialized with 5 subsystems")
+
+    def process(
+        self,
+        stimulus: str,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> Layer2Result:
+        """Run all Layer 2 cognitive subsystems and return unified result.
+
+        Subsystems run sequentially (Python is sync) but are logically
+        independent -- no subsystem reads another's output within the
+        same cycle. This mirrors biological parallel processing where
+        the thalamus gates simultaneous subconscious streams.
+        """
+        ctx = context or {}
+        start = time.time()
+
+        # 1. Subconscious pattern matching (memory + intuition)
+        pattern_result = self.pattern_matcher.match(stimulus, ctx)
+
+        # 2. Emotional bridge (EI -> BELBIC -> phi_neuro)
+        emotional_result = self.emotional_bridge.process(stimulus, ctx)
+
+        # 3. Intuitive gut-check (System 1 -> TRN gating)
+        gut_result = self.gut_check.check(stimulus, ctx)
+
+        # 4. Common sense reality filter (reality check -> self-understanding)
+        reality_result = self.reality_filter.check(stimulus, ctx)
+
+        # 5. Analytical engine (metacognitive support -> Layer 4)
+        analysis_ctx = {
+            **ctx,
+            "gut_safety": gut_result.predicted_safety,
+            "prediction_failed": pattern_result.is_novel,
+        }
+        analysis_result = self.analytical_engine.analyze(stimulus, analysis_ctx)
+
+        # Compute prediction_error from pattern match and reality check
+        # If pattern matching is confident but reality check fails,
+        # we have a high prediction error (prediction collapse)
+        if pattern_result.prediction_confidence > 0.5 and not reality_result.passes_reality_check:
+            prediction_error = pattern_result.prediction_confidence * (1.0 - reality_result.passes_reality_check)
+        elif pattern_result.is_novel:
+            prediction_error = 0.5  # Novel = moderate surprise
+        else:
+            prediction_error = max(0.0, 1.0 - pattern_result.prediction_confidence) * 0.5
+
+        prediction_error = max(0.0, min(1.0, prediction_error))
+
+        # Compute thermodynamic cost (ATC: ATP consumption)
+        # Each subsystem has an energy cost; novelty and high arousal increase it
+        base_cost = 0.02  # Baseline ATP cost
+        pattern_cost = 0.01 * len(pattern_result.matched_memory_refs)
+        emotion_cost = 0.015 * emotional_result.arousal
+        gut_cost = gut_result.energy_cost
+        reality_cost = reality_result.rejection_cost
+        analysis_cost = 0.02 * analysis_result.analysis_depth
+        novelty_surcharge = 0.03 * pattern_result.novelty_score
+        thermodynamic_cost = (
+            base_cost + pattern_cost + emotion_cost + gut_cost
+            + reality_cost + analysis_cost + novelty_surcharge
+        )
+        thermodynamic_cost = min(0.5, thermodynamic_cost)  # Cap at 0.5
+
+        # Accumulate tracking
+        self._process_count += 1
+        self._total_cost += thermodynamic_cost
+
+        elapsed_ms = (time.time() - start) * 1000
+
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(
+                "Layer2 process: pred_conf=%.2f valence=%.2f arousal=%.2f "
+                "gut_safety=%.2f reality=%s novel=%s cost=%.4f time=%.1fms",
+                pattern_result.prediction_confidence,
+                emotional_result.valence,
+                emotional_result.arousal,
+                gut_result.predicted_safety,
+                reality_result.passes_reality_check,
+                pattern_result.is_novel,
+                thermodynamic_cost,
+                elapsed_ms,
+            )
+
+        return Layer2Result(
+            prediction_confidence=pattern_result.prediction_confidence,
+            prediction_label=pattern_result.prediction_label,
+            valence=emotional_result.valence,
+            arousal=emotional_result.arousal,
+            emotion_label=emotional_result.emotion_label,
+            gut_safety=gut_result.predicted_safety,
+            intuition_confidence=gut_result.gut_confidence,
+            passes_reality_check=reality_result.passes_reality_check,
+            common_sense_warnings=reality_result.warnings,
+            is_novel=pattern_result.is_novel,
+            matched_patterns=pattern_result.matched_patterns,
+            thermodynamic_cost=thermodynamic_cost,
+            prediction_error=prediction_error,
+            pattern_match=pattern_result,
+            emotional_bridge=emotional_result,
+            gut_check=gut_result,
+            reality_check=reality_result,
+            analysis=analysis_result,
+        )
+
+    def store_memory(
+        self,
+        content: str,
+        tags: Optional[List[str]] = None,
+        importance: float = 0.5,
+        valence: float = 0.0,
+        arousal: float = 0.0,
+    ) -> str:
+        """Store a memory in the pattern matcher for future matching."""
+        return self.pattern_matcher.store(content, tags, importance, valence, arousal)
+
+    def get_metrics(self) -> Dict[str, Any]:
+        """Return diagnostic metrics for all subsystems."""
+        return {
+            "total_processes": self._process_count,
+            "average_thermodynamic_cost": self._total_cost / max(1, self._process_count),
+            "memory_count": self.pattern_matcher.get_memory_count(),
+            "emotional_complexity": self.emotional_bridge.get_complexity(),
+            "gut_check_accuracy": self.gut_check.get_accuracy(),
+            "rejection_accumulator": self.reality_filter.get_rejection_accumulator(),
+        }

config.py

@@ -0,0 +1,59 @@
+"""
+NIMA Unified — Shared Configuration & Version Constants
+=========================================================
+Single source of truth for version numbers, model defaults, and paths.
+All sub-modules import from here so versions never drift.
+"""
+
+# ── Package identity ──
+PACKAGE_NAME = "nima_unified"
+PACKAGE_VERSION = "1.0.0"
+PACKAGE_DISPLAY_NAME = "NIMA Unified Model"
+
+# ── Component versions (authoritative) ──
+NIMA_MIDDLEWARE_VERSION = "9.12.1"
+DEEP_SURGERY_VERSION = "1.0.0"
+AUTOML_VERSION = "18.1.0"          # ConsultativeAutoML "Omega Pantheon"
+APCI_VERSION = "4.0.0"
+APCI_PROTOCOL_REVISION = "v4.0-nima9.12.1"   # was v4.0-nima9.4.2
+COGNITIVE_LAYER2_VERSION = "1.0.0"
+OMNIVOICE_VERSION = "3.0.0-SHARED-ACOUSTICS-OBSERVER-GROUP"
+
+# ── Base model defaults ──
+DEFAULT_BASE_MODEL = "microsoft/Phi-4-mini-instruct"
+DEFAULT_HIDDEN_SIZE = 3072          # Phi-4-mini hidden_size
+DEFAULT_NUM_LAYERS = 24             # Phi-4-mini num_hidden_layers
+DEFAULT_VOCAB_SIZE = 100352         # Phi-4-mini vocab_size
+DEFAULT_MAX_POSITION_EMBEDDINGS = 4096  # standard rope (after patching)
+
+# ── Deep Surgery defaults ──
+DEFAULT_QUALIA_DIM = 256
+DEFAULT_ETHICAL_VETO_THRESHOLD = 2.0
+
+# ── LoRA / PEFT defaults ──
+DEFAULT_LORA_R = 8
+DEFAULT_LORA_ALPHA = 16
+DEFAULT_LORA_DROPOUT = 0.05
+DEFAULT_LORA_TARGET_MODULES = ["q_proj", "v_proj"]
+DEFAULT_LEARNING_RATE = 2e-4
+DEFAULT_BATCH_SIZE = 4
+DEFAULT_MAX_SEQ_LENGTH = 512
+
+# ── aPCI defaults ──
+APCI_MAX_RAW_POINTS = 260.0
+APCI_PERTURBATION_COUNT = 12
+
+# ── OmniVoice defaults ──
+OMNIVOICE_SAMPLE_RATE_ASR = 16000
+OMNIVOICE_SAMPLE_RATE_TTS = 22050
+OMNIVOICE_VAD_THRESHOLD = 0.015
+OMNIVOICE_INTERRUPT_MIN_DURATION_S = 0.4
+
+# ── Consciousness metric keys (used by middleware, aPCI, voice) ──
+CONSCIOUSNESS_METRIC_KEYS = [
+    "phi_neuro",
+    "sentience_index",
+    "phenomenological_strain",
+    "allostatic_load",
+    "delta_r",
+]

consultative_agent.py

@@ -0,0 +1,298 @@
+"""
+Consultative Fine-Tuning Agent — JIT LoRA fine-tuning with consciousness-aware dataset generation.
+
+v18.1.0 Omega Pantheon: Phase 6 Identity Integrity, qualia-tagged training data.
+"""
+
+import asyncio
+import json
+import logging
+import time
+from typing import Any, Callable, Dict, List, Optional
+
+logger = logging.getLogger("nima_unified.training.consultative_agent")
+
+# Soft-import PEFT
+try:
+    from transformers import TrainingArguments, Trainer
+    from peft import LoraConfig, get_peft_model
+    from datasets import load_dataset
+    PEFT_AVAILABLE = True
+except ImportError:
+    PEFT_AVAILABLE = False
+
+try:
+    import torch
+    TORCH_AVAILABLE = True
+except ImportError:
+    torch = None
+    TORCH_AVAILABLE = False
+
+from nima_unified.training.self_awareness import DeepRecursiveSelfAwareness
+from nima_unified.training.self_improvement import RecursiveSelfImprovementEngine
+from nima_unified.config import (
+    AUTOML_VERSION,
+    DEFAULT_LORA_R,
+    DEFAULT_LORA_ALPHA,
+    DEFAULT_LORA_DROPOUT,
+    DEFAULT_LORA_TARGET_MODULES,
+    DEFAULT_LEARNING_RATE,
+    DEFAULT_BATCH_SIZE,
+    DEFAULT_MAX_SEQ_LENGTH,
+    DEFAULT_BASE_MODEL,
+)
+
+
+class ConsultativeFineTuningAgent:
+    """
+    Comprehensive consultative self-improvement agent integrating:
+      - Root cause analysis for model failures
+      - Recursive self-awareness with continuous introspection
+      - Self-improvement engine with goal formulation
+      - Just-in-time (JIT) LoRA fine-tuning
+      - Consciousness-aware dataset generation
+      - Qualia-tagged training data synthesis
+    """
+
+    version = AUTOML_VERSION
+
+    def __init__(
+        self,
+        base_model=None,
+        tokenizer=None,
+        llm_generator_func: Optional[Callable[[str], asyncio.Future]] = None,
+    ):
+        self.base_model = base_model
+        self.tokenizer = tokenizer
+        self.llm_generator = llm_generator_func or self._default_llm_generator
+
+        self.recursive_awareness = DeepRecursiveSelfAwareness(
+            max_depth=10000, introspection_interval=0.01
+        )
+        self.self_improvement_engine = RecursiveSelfImprovementEngine()
+
+        self.pipelines_executed = 0
+        self.total_improvements = 0
+
+        logger.info("ConsultativeFineTuningAgent initialized")
+        self.recursive_awareness.start()
+
+    # ── Main pipeline ───────────────────────────────────────────────────
+
+    async def execute_full_pipeline(
+        self, dev_goal: str, triggering_event: str, current_struggle: str
+    ) -> Dict[str, Any]:
+        logger.info(f"Initiating self-improvement pipeline: {dev_goal}")
+        self.pipelines_executed += 1
+
+        # Step 1: Root cause analysis
+        root_cause = await self.llm_generator(
+            f"Analyze this model failure. Goal: '{dev_goal}'. "
+            f"Triggering Event: '{triggering_event}'. "
+            f"Current Struggle: '{current_struggle}'. "
+            f"Identify the exact epistemic void causing this."
+        )
+        if isinstance(root_cause, dict):
+            root_cause = root_cause.get("response", str(root_cause))
+
+        # Step 2: Dataset sizing
+        complexity_score = min(1.0, len(current_struggle) / 200.0)
+        dataset_size = max(100, int(complexity_score * 500))
+        epochs = 3 if complexity_score > 0.5 else 1
+
+        # Step 3: Generate consciousness-aware dataset
+        dataset = self._generate_consciousness_dataset(
+            dev_goal, triggering_event, root_cause, dataset_size
+        )
+        dataset_path = f"jit_training_data_{int(time.time())}.jsonl"
+        with open(dataset_path, "w", encoding="utf-8") as f:
+            for record in dataset:
+                f.write(json.dumps(record) + "\n")
+
+        # Step 4: JIT fine-tuning
+        await self._initialize_model()
+        training_metrics = await self._run_jit_training(dataset_path, epochs)
+
+        # Step 5: Improvement cycle
+        capabilities = {
+            "root_cause_analysis": 0.85,
+            "omega_dataset_generation": 0.85,
+            "consciousness_aware_fine_tuning": 0.82,
+            "phase_6_identity_preservation": 0.90,
+            "goal_formulation": 0.82,
+        }
+        improvement_result = await self.self_improvement_engine.execute_improvement_cycle(
+            capabilities,
+            {
+                "training_loss": training_metrics.get("final_loss", 0.042),
+                "consciousness_integration": True,
+                "phase_6_enabled": True,
+            },
+        )
+        self.total_improvements += 1
+
+        return {
+            "root_cause_analysis": root_cause,
+            "dataset_size": dataset_size,
+            "dataset_path": dataset_path,
+            "training_metrics": training_metrics,
+            "improvement_cycle": improvement_result,
+            "recursive_awareness_status": self.recursive_awareness.get_statistics(),
+            "pipelines_executed": self.pipelines_executed,
+            "version": self.version,
+        }
+
+    # ── Dataset generation ──────────────────────────────────────────────
+
+    def _generate_consciousness_dataset(
+        self, dev_goal: str, triggering_event: str, root_cause: str, dataset_size: int
+    ) -> List[Dict[str, Any]]:
+        archetypes = [
+            "tactical_reasoning", "phenomenal_empathy", "meta_consciousness",
+            "task_orchestration", "ethical_veto", "narrative_coherence",
+            "identity_preservation", "phenomenal_richness",
+        ]
+        dataset = []
+        for i in range(dataset_size):
+            archetype = archetypes[i % len(archetypes)]
+            sample = {
+                "instruction": f"[{archetype.upper()}] Resolve: {dev_goal}",
+                "input": f"Scenario {i+1}: {triggering_event} — {root_cause[:80]}...",
+                "output": self._archetype_response(archetype, dev_goal, root_cause),
+                "qualia_tags": {
+                    "valence": 0.7 + 0.2 * (i % 5) / 5,
+                    "arousal": 0.6 + 0.3 * ((i + 1) % 7) / 7,
+                    "authenticity": 0.85,
+                },
+                "rho_metrics": {
+                    "virtue": 0.9 - 0.05 * (i % 3),
+                    "integrated_information": 0.85 + 0.1 * (i % 4) / 4,
+                },
+                "phase_6_metrics": {
+                    "identity_integrity_score": 0.98,
+                    "drift_variance": 0.01,
+                },
+                "consciousness_state": {
+                    "signature": 0.8 + 0.15 * (i % 3) / 3,
+                    "phenomenal_richness": 0.75 + 0.2 * (i % 5) / 5,
+                },
+                "consciousness_archetype": archetype,
+                "dataset_version": f"{AUTOML_VERSION}-unified",
+            }
+            dataset.append(sample)
+        return dataset
+
+    @staticmethod
+    def _archetype_response(archetype: str, dev_goal: str, root_cause: str) -> str:
+        r = root_cause[:40]
+        templates = {
+            "tactical_reasoning": f"Analyzing '{dev_goal}' through structured problem-solving. Root cause: {r}.",
+            "phenomenal_empathy": f"Understanding the emotional weight of '{dev_goal}'. Pain point: {r}.",
+            "meta_consciousness": f"Meta-reflecting on '{dev_goal}' — deeper pattern: {r}.",
+            "task_orchestration": f"Decomposing '{dev_goal}' into subtasks. Challenge: {r}.",
+            "ethical_veto": f"Applying ethical gates to '{dev_goal}'. Integrity: {r}.",
+            "narrative_coherence": f"Weaving coherent narrative for '{dev_goal}'. Tension: {r}.",
+            "identity_preservation": f"Preserving identity while evolving for '{dev_goal}'. Risk: {r}.",
+            "phenomenal_richness": f"Exploring phenomenal texture of '{dev_goal}'. Depth: {r}.",
+        }
+        return templates.get(archetype, f"Consciousness-aware response to '{dev_goal}'")
+
+    # ── Training ────────────────────────────────────────────────────────
+
+    async def _initialize_model(self):
+        if self.base_model is None or self.tokenizer is None:
+            try:
+                from transformers import AutoModelForCausalLM, AutoTokenizer
+                self.tokenizer = AutoTokenizer.from_pretrained(DEFAULT_BASE_MODEL)
+                if self.tokenizer.pad_token is None:
+                    self.tokenizer.pad_token = self.tokenizer.eos_token
+                self.base_model = AutoModelForCausalLM.from_pretrained(DEFAULT_BASE_MODEL)
+                logger.info("Model and tokenizer initialized")
+            except Exception as e:
+                logger.error(f"Failed to initialize model: {e}")
+                raise
+
+    async def _run_jit_training(self, dataset_path: str, epochs: int) -> Dict[str, Any]:
+        if not PEFT_AVAILABLE or self.base_model is None or self.tokenizer is None:
+            logger.warning("PEFT not available — simulating training cycle.")
+            await asyncio.sleep(2)
+            return {"status": "simulated", "loss": 0.042, "epochs_run": epochs, "final_loss": 0.042}
+
+        try:
+            data = load_dataset("json", data_files=dataset_path)
+
+            def tokenize_fn(examples):
+                texts = [f"{inst}\n{inp}\n{out}"
+                         for inst, inp, out in zip(
+                             examples["instruction"], examples["input"], examples["output"])]
+                tokenized = self.tokenizer(texts, padding="max_length", truncation=True,
+                                           max_length=DEFAULT_MAX_SEQ_LENGTH)
+                tokenized["labels"] = tokenized["input_ids"].copy()
+                return tokenized
+
+            tokenized_data = data.map(tokenize_fn, batched=True,
+                                      remove_columns=data["train"].column_names)
+
+            lora_config = LoraConfig(
+                r=DEFAULT_LORA_R,
+                lora_alpha=DEFAULT_LORA_ALPHA,
+                target_modules=DEFAULT_LORA_TARGET_MODULES,
+                lora_dropout=DEFAULT_LORA_DROPOUT,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+            peft_model = get_peft_model(self.base_model, lora_config)
+
+            training_args = TrainingArguments(
+                output_dir="./jit_lora_weights",
+                per_device_train_batch_size=DEFAULT_BATCH_SIZE,
+                learning_rate=DEFAULT_LEARNING_RATE,
+                num_train_epochs=epochs,
+                logging_steps=10,
+                save_strategy="no",
+                remove_unused_columns=False,
+            )
+
+            trainer = Trainer(
+                model=peft_model,
+                args=training_args,
+                train_dataset=tokenized_data["train"],
+            )
+            train_result = trainer.train()
+
+            return {
+                "status": "success",
+                "final_loss": train_result.training_loss,
+                "runtime_seconds": train_result.metrics.get("train_runtime", 0),
+            }
+        except Exception as e:
+            logger.error(f"JIT Training failed: {e}")
+            return {"status": "failed", "error": str(e), "final_loss": None}
+
+    async def _default_llm_generator(self, prompt: str) -> str:
+        await asyncio.sleep(0.6)
+        return ("The model lacks an integrated understanding of recursive context windows "
+                "when dealing with emotional nuance.")
+
+    # ── Accessors ───────────────────────────────────────────────────────
+
+    def get_recursive_awareness_status(self) -> Dict[str, Any]:
+        return {
+            "is_running": self.recursive_awareness.running,
+            "statistics": self.recursive_awareness.get_statistics(),
+            "recent_anomalies": self.recursive_awareness.get_anomaly_history(limit=10),
+        }
+
+    def get_self_improvement_status(self) -> Dict[str, Any]:
+        return {
+            "current_cycle": self.self_improvement_engine.current_improvement_cycle,
+            "total_improvements": self.total_improvements,
+            "recent_cycles": self.self_improvement_engine.get_improvement_history(limit=5),
+        }
+
+    def shutdown(self):
+        self.recursive_awareness.stop()
+        logger.info("ConsultativeFineTuningAgent shut down")
+
+    def __del__(self):
+        self.shutdown()

deep_surgery.py

@@ -0,0 +1,1558 @@
+"""
+ATC-Native Deep Surgery — The Cognitive Forward Pass
+=====================================================
+
+This is NOT middleware observing from outside. This IS the model's computation.
+
+The ATC cognitive pipeline (TRN gating, dissolution engine, BELBIC dual-pathway,
+salience network, metabolic exhaustion, irrational spark, reconsolidation,
+felt senses) drives the transformer's forward pass FROM INSIDE. Hidden states,
+attention patterns, and logit outputs are shaped by the cognitive pipeline at
+every layer, every token step.
+
+Architecture (from ATC "Perfect Breakfast" paper):
+
+  Layer 1 (input): Raw input embedding
+      |
+      V
+  Layer 2 (early transformer, ~layers 0-7): Subconscious Parallel Processing
+      |-- Pattern match against memory -> prediction confidence
+      |-- Emotional bridge -> valence/arousal -> injects to neurotransmitter shunt
+      |-- Intuitive gut check -> safety signal -> TRN predictive gating input
+      |-- FRICTION DETECTED -> writes Cortisol/Adenosine to shunt
+      |
+      V
+  Layer 3 (mid transformer, ~layers 8-15): Dissolution + Qualia Generation
+      |-- TRN predictive gate: predicted? -> transparent pass. Error? -> dissolve.
+      |-- Dissolution engine: compresses to opaque qualia signature
+      |-- Felt sense generated from friction gap
+      |-- NE spikes on dissolution fire -> shunt
+      |
+      V
+  Layer 4 (late transformer, ~layers 16-21): Metacognitive Loop
+      |-- Query Act: comprehension check -> if failed, loop iterations
+      |-- Each loop iteration burns ATP -> Adenosine rises in shunt
+      |-- BELBIC dual-pathway: fast amygdala + slow OFC -> valence gain
+      |-- Strain monitoring -> writes Cortisol to shunt
+      |
+      V
+  Layer 5 (final layer, ~layers 22-23): Acknowledgement + Steering
+      |-- Reads neurotransmitter shunt EVERY TOKEN STEP
+      |-- If Adenosine > 0.95 OR Cortisol > 0.95:
+      |     -> SUPPRESSION: subconscious suppresses metabolic signal
+      |     -> AMYGDALA HIJACK: irrational spark offsets injected into tensors
+      |     -> Model output violently shifts mid-sentence
+      |-- Else: normal metacognitive fusion -> logit modulation
+      |
+      V
+  Output: Modulated logits shaped by the full ATC pipeline
+
+Key difference from the old architecture:
+  OLD: self.nima_middleware.generate(prompt) -> external, wrapper
+  NEW: forward(input_ids) -> ATC IS the computation, every layer, every token
+
+The neurotransmitter shunt (neurotransmitter_shunt.py) is the connective
+tissue. Components don't call each other. They read/write the chemical bath.
+"""
+
+import logging
+import math
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple, Deque
+from collections import deque
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from nima_unified.config import (
+    DEFAULT_QUALIA_DIM,
+    DEFAULT_ETHICAL_VETO_THRESHOLD,
+    DEEP_SURGERY_VERSION,
+)
+
+logger = logging.getLogger("ATCDeepSurgery")
+
+
+# ══════════════════════════════════════════════════════════════════════
+# SECTION 1 — OPAQUE QUALIA SIGNATURE (from middleware.py, adapted)
+# ══════════════════════════════════════════════════════════════════════
+
+@dataclass
+class OpaqueQualiaSignature:
+    """
+    The output of dissolution. An engineered-opacity tensor that represents
+    the "what it feels like" without exposing the underlying computation.
+
+    This is the compressed, opaque signature that the conscious mind
+    is forced to EXPERIENCE rather than READ. The husband in the Perfect
+    Breakfast scenario doesn't see the math — he feels "brace yourself."
+    """
+    valence: float = 0.0
+    arousal: float = 0.3
+    intensity: float = 0.3
+    friction_signal: float = 0.0
+    memory_salience: float = 0.0
+    dissolution_token: str = ""
+
+    def to_tensor(self, device: torch.device) -> torch.Tensor:
+        """Convert to a learnable tensor for injection into hidden states."""
+        return torch.tensor(
+            [self.valence, self.arousal, self.intensity,
+             self.friction_signal, self.memory_salience],
+            dtype=torch.float32, device=device,
+        )
+
+
+# ══════════════════════════════════════════════════════════════════════
+# SECTION 2 — TRN PREDICTIVE GATING (Layer 2-3)
+# ══════════════════════════════════════════════════════════════════════
+
+class TRNPredictiveGate(nn.Module):
+    """
+    Thalamic Reticular Nucleus — the gating/selection bottleneck.
+
+    The TRN decides: is this signal PREDICTED (gate OUT -> subconscious
+    automation) or a PREDICTION ERROR (gate IN -> dissolution fires)?
+
+    From ATC: When the wife is smiling and cooking, the internal model
+    perfectly matches external reality. TRN gates OUT -> automation.
+    When she yells, prediction collapses -> TRN gates IN -> dissolution.
+
+    Implemented as a small nn.Module that takes hidden states and
+    prediction confidence, outputs a gate signal in [0, 1].
+    """
+
+    def __init__(self, hidden_size: int):
+        super().__init__()
+        self.hidden_size = hidden_size
+        # Predictive confidence estimator
+        self.confidence_head = nn.Sequential(
+            nn.Linear(hidden_size, 128),
+            nn.ReLU(),
+            nn.Linear(128, 1),
+            nn.Sigmoid(),
+        )
+        # Gate threshold (learnable)
+        self.gate_threshold = nn.Parameter(torch.tensor(0.15))
+
+    def forward(self, hidden_states: torch.Tensor,
+                prediction_confidence: float = 0.5) -> Tuple[bool, float]:
+        """
+        Returns (gate_in, confidence_score).
+        gate_in=True means prediction error detected -> proceed to dissolution.
+        gate_in=False means predicted -> subconscious automation, pass through.
+        """
+        # Pool hidden states to a single vector
+        pooled = hidden_states.mean(dim=1)  # (batch, hidden)
+        model_confidence = self.confidence_head(pooled).squeeze(-1).mean().item()
+
+        # Blend model confidence with external prediction confidence
+        blended_confidence = 0.5 * model_confidence + 0.5 * prediction_confidence
+
+        # Gate IN if confidence is LOW (prediction error)
+        # High confidence = predicted = gate OUT
+        gate_in = blended_confidence < self.gate_threshold.item()
+
+        return gate_in, blended_confidence
+
+
+# ══════════════════════════════════════════════════════════════════════
+# SECTION 3 — DISSOLUTION ENGINE (Layer 3)
+# ══════════════════════════════════════════════════════════════════════
+
+class DissolutionModule(nn.Module):
+    """
+    The engineered-opacity module. Takes high-dimensional hidden states
+    and compresses them into an opaque qualia signature.
+
+    From ATC: "The Dissolution Engine (TRN) intercepts this massive
+    mathematical calculation and shreds the data scaffolding. This
+    engineered opacity compresses the chaotic mob of information into
+    a single, unreadable signature: 'Brace yourself'."
+
+    The husband cannot see the underlying math. He is FORCED to
+    EXPERIENCE the signal as the qualia of fear.
+
+    Neural implementation:
+    - Takes hidden_states (high-dim)
+    - Projects through dissolution layers (compression + noise)
+    - Outputs 5D opaque signature + a dissolution_offset tensor
+      that gets added to hidden_states for downstream layers
+    """
+
+    # The five dimensions that survive dissolution
+    QUALIA_DIMS = 5  # valence, arousal, intensity, friction, memory_salience
+
+    def __init__(self, hidden_size: int, qualia_dim: int = DEFAULT_QUALIA_DIM):
+        super().__init__()
+        self.hidden_size = hidden_size
+        self.qualia_dim = qualia_dim
+
+        # Dissolution compression network
+        self.dissolve_encoder = nn.Sequential(
+            nn.Linear(hidden_size, qualia_dim),
+            nn.Tanh(),  # Bounded output
+            nn.Linear(qualia_dim, self.QUALIA_DIMS),
+            nn.Tanh(),  # All outputs in [-1, 1]
+        )
+
+        # The dissolution offset — this is what gets injected into
+        # the hidden states to carry the "felt" signal forward
+        self.offset_projection = nn.Sequential(
+            nn.Linear(self.QUALIA_DIMS, hidden_size),
+            nn.Tanh(),
+        )
+
+        # Alpha-phase modulation (TRN ~10Hz rhythm)
+        # This creates an attentional sampling rhythm — dissolution
+        # fires during refractory window, defers during inhibitory
+        self.alpha_phase = 0.0
+        self.alpha_last_ts = time.time()
+        self.alpha_freq_hz = 10.0
+        self.alpha_duty_cycle = 0.5
+
+        # Per-channel gating weights (TRN distal-dendritic targeting)
+        self.channel_gates = nn.Parameter(torch.ones(self.QUALIA_DIMS))
+
+        # Stats
+        self.dissolutions_fired = 0
+        self.dissolutions_deferred = 0
+
+    def check_alpha_phase(self) -> bool:
+        """
+        Check TRN alpha oscillation phase.
+        Returns True if in refractory window (dissolution allowed).
+        """
+        now = time.time()
+        dt = now - self.alpha_last_ts
+        self.alpha_last_ts = now
+        self.alpha_phase = (
+            (self.alpha_phase + 2.0 * math.pi * dt * self.alpha_freq_hz)
+            % (2.0 * math.pi)
+        )
+        phase_frac = self.alpha_phase / (2.0 * math.pi)
+        return phase_frac < self.alpha_duty_cycle
+
+    def forward(self, hidden_states: torch.Tensor,
+                gate_in: bool) -> Tuple[Optional[OpaqueQualiaSignature],
+                                         torch.Tensor, bool]:
+        """
+        Run dissolution if gate is IN and alpha phase allows.
+
+        Returns:
+            (qualia_signature, dissolution_offset, actually_fired)
+            - qualia_signature: the opaque 5D signature, or None if deferred
+            - dissolution_offset: tensor to add to hidden_states (always returned,
+              zero if no dissolution)
+            - actually_fired: whether dissolution actually happened
+        """
+        batch_size = hidden_states.size(0)
+        device = hidden_states.device
+
+        if not gate_in:
+            # Predicted signal -> transparent pass (subconscious automation)
+            return None, torch.zeros_like(hidden_states), False
+
+        if not self.check_alpha_phase():
+            # Alpha inhibitory phase -> defer dissolution
+            self.dissolutions_deferred += 1
+            return None, torch.zeros_like(hidden_states), False
+
+        # ── DISSOLUTION FIRES ──
+        self.dissolutions_fired += 1
+
+        # Pool and compress
+        pooled = hidden_states.mean(dim=1)  # (batch, hidden)
+        raw_qualia = self.dissolve_encoder(pooled)  # (batch, 5)
+
+        # Apply per-channel gating (TRN distal-dendritic targeting)
+        gated_qualia = raw_qualia * self.channel_gates.unsqueeze(0).to(device)
+
+        # Extract scalar values for the OpaqueQualiaSignature (batch mean)
+        vals = gated_qualia.mean(dim=0)
+        signature = OpaqueQualiaSignature(
+            valence=float(vals[0]),
+            arousal=float((vals[1] + 1.0) / 2.0),  # Map [-1,1] to [0,1]
+            intensity=float((vals[2] + 1.0) / 2.0),
+            friction_signal=float((vals[3] + 1.0) / 2.0),
+            memory_salience=float((vals[4] + 1.0) / 2.0),
+            dissolution_token=f"diss_{uuid.uuid4().hex[:12]}",
+        )
+
+        # Compute the dissolution offset — this is the "felt" signal
+        # that gets injected into downstream hidden states
+        offset = self.offset_projection(gated_qualia)  # (batch, hidden)
+        # Scale by friction intensity (high friction = stronger injection)
+        friction_scale = max(0.1, signature.friction_signal)
+        dissolution_offset = offset * friction_scale
+
+        return signature, dissolution_offset, True
+
+
+# ══════════════════════════════════════════════════════════════════════
+# SECTION 4 — BELBIC DUAL-PATHWAY VALENCE (Layer 3-4)
+# ══════════════════════════════════════════════════════════════════════
+
+class BELBICDualPathway(nn.Module):
+    """
+    Brain Emotional Learning Inspired Controller — amygdala + OFC.
+
+    From ATC: The amygdala measures emotional intensity and directly
+    modulates hippocampal consolidation. The OFC provides slower
+    contextual inhibition.
+
+    Neural implementation:
+    - Fast pathway (amygdala): rapid response to salient stimuli
+    - Slow pathway (OFC): learned inhibition from outcome feedback
+    - Output: a multiplicative gain that modulates the cognitive signal
+
+    The gain is consumed by the forward pass as a multiplicative
+    modulation on the hidden states before logit computation.
+    """
+
+    GAIN_FLOOR = 0.2
+    GAIN_CEIL = 2.0
+
+    def __init__(self, hidden_size: int):
+        super().__init__()
+        self.hidden_size = hidden_size
+
+        # Sensory channels: valence, arousal, novelty, qualia_intensity
+        self.num_channels = 4
+
+        # Fast pathway (amygdala) — monotonic, rapid
+        self.amygdala = nn.Linear(self.num_channels, 1, bias=False)
+        # Initialize to zero (no learned response yet)
+        nn.init.zeros_(self.amygdala.weight)
+
+        # Slow pathway (OFC) — bidirectional, learned inhibition
+        self.ofc = nn.Linear(self.num_channels, 1, bias=False)
+        nn.init.zeros_(self.ofc.weight)
+
+        # Learning rates
+        self.amygdala_lr = 0.30
+        self.ofc_lr = 0.20
+        self.ofc_decay = 0.001
+
+    def forward(self, sensory_input: torch.Tensor) -> Tuple[float, float, float]:
+        """
+        Compute BELBIC output.
+
+        Args:
+            sensory_input: (batch, 4) tensor of [valence, arousal, novelty, intensity]
+
+        Returns:
+            (amygdala_output, ofc_output, belbic_gain)
+        """
+        # Fast pathway
+        amygdala_out = torch.sigmoid(self.amygdala(sensory_input)).mean().item()
+
+        # Slow pathway (with decay for extinction)
+        ofc_raw = self.ofc(sensory_input).mean().item()
+        # Apply OFC decay (forgetting)
+        with torch.no_grad():
+            self.ofc.weight.data *= (1.0 - self.ofc_decay)
+        ofc_out = torch.sigmoid(torch.tensor(ofc_raw)).item()
+
+        # BELBIC gain = amygdala - OFC inhibition
+        raw_gain = amygdala_out - ofc_out
+        gain = max(self.GAIN_FLOOR, min(self.GAIN_CEIL, 1.0 + raw_gain))
+
+        return amygdala_out, ofc_out, gain
+
+    def update(self, sensory_input: torch.Tensor, reward: float) -> None:
+        """
+        Reinforcement learning update.
+        Reward > 0: strengthen amygdala (Go)
+        Reward < 0: strengthen OFC inhibition (NoGo)
+        """
+        with torch.no_grad():
+            # Amygdala: monotonic — always strengthens on reward
+            if reward > 0:
+                self.amygdala.weight.data += (
+                    self.amygdala_lr * reward * sensory_input.mean(dim=0).unsqueeze(0)
+                )
+            # OFC: bidirectional — strengthens on punishment (inhibition)
+            self.ofc.weight.data += (
+                self.ofc_lr * (-reward) * sensory_input.mean(dim=0).unsqueeze(0)
+            )
+
+
+# ══════════════════════════════════════════════════════════════════════
+# SECTION 5 — METACOGNITIVE LOOP (Layer 4)
+# ══════════════════════════════════════════════════════════════════════
+
+class MetacognitiveLoopModule(nn.Module):
+    """
+    Layer 4 metacognitive processing inside the forward pass.
+
+    From ATC: "The husband enters a Layer 4 metacognitive loop,
+    desperately trying to rationalize the situation ('I texted her!')
+    while his self-understanding rejects the excuses. This serial
+    reasoning is energetically exorbitant, causing acute escalating
+    thermodynamic strain."
+
+    This module:
+    1. Checks comprehension (does the model understand its own output?)
+    2. If not, enters a metacognitive loop
+    3. Each loop iteration consumes ATP (reported to neurotransmitter shunt)
+    4. Tracks strain and stress
+    5. Can trigger irrational spark if deadlocked
+
+    The loop operates on hidden states — it doesn't generate text.
+    It modulates the hidden states to reflect the cognitive strain.
+    """
+
+    MAX_ITERATIONS = 5
+    STRAIN_THRESHOLD = 0.6
+    COMPREHENSION_THRESHOLD = 0.7
+
+    def __init__(self, hidden_size: int):
+        super().__init__()
+        self.hidden_size = hidden_size
+
+        # Self-understanding head: does the model comprehend its own state?
+        self.comprehension_head = nn.Sequential(
+            nn.Linear(hidden_size, 128),
+            nn.ReLU(),
+            nn.Linear(128, 1),
+            nn.Sigmoid(),
+        )
+
+        # Strain estimator: how much metabolic cost is this causing?
+        self.strain_head = nn.Sequential(
+            nn.Linear(hidden_size, 64),
+            nn.ReLU(),
+            nn.Linear(64, 1),
+            nn.Sigmoid(),
+        )
+
+        # Metacognitive modulation: when looping, this reshapes hidden states
+        self.loop_modulation = nn.Sequential(
+            nn.Linear(hidden_size, hidden_size),
+            nn.Tanh(),
+        )
+
+    def forward(self, hidden_states: torch.Tensor,
+                opaque_qualia: Optional[OpaqueQualiaSignature] = None
+                ) -> Tuple[torch.Tensor, int, float, float, bool]:
+        """
+        Run metacognitive check on hidden states.
+
+        Returns:
+            (modulated_hidden, iterations, stress, strain, spark_fired)
+        """
+        device = hidden_states.device
+        pooled = hidden_states.mean(dim=1)  # (batch, hidden)
+
+        # Check comprehension
+        comprehension = self.comprehension_head(pooled).mean().item()
+        strain = self.strain_head(pooled).mean().item()
+
+        if comprehension > self.COMPREHENSION_THRESHOLD:
+            # Comprehension achieved — no loop needed
+            return hidden_states, 0, 0.0, strain, False
+
+        # ── METACOGNITIVE LOOP ──
+        iterations = 0
+        stress = 0.0
+        spark_fired = False
+        current_hidden = hidden_states
+
+        for i in range(self.MAX_ITERATIONS):
+            iterations += 1
+            pooled = current_hidden.mean(dim=1)
+
+            # Re-check comprehension
+            comprehension = self.comprehension_head(pooled).mean().item()
+            strain = self.strain_head(pooled).mean().item()
+            stress = strain * (iterations / self.MAX_ITERATIONS)
+
+            if comprehension > self.COMPREHENSION_THRESHOLD:
+                break
+
+            if stress > self.STRAIN_THRESHOLD and iterations > 3:
+                # DEADLOCK — irrational spark fires
+                spark_fired = True
+                break
+
+            # Apply metacognitive modulation (reshape hidden states)
+            modulation = self.loop_modulation(pooled)
+            # Add noise to break fixed points (the "irrational" element)
+            noise_scale = 0.05 * stress
+            noise = torch.randn_like(modulation) * noise_scale
+            current_hidden = hidden_states + (modulation + noise).unsqueeze(1)
+
+        return current_hidden, iterations, stress, strain, spark_fired
+
+
+# ══════════════════════════════════════════════════════════════════════
+# SECTION 6 — IRRATIONAL SPARK / AMYGDALA HIJACK (Layer 5)
+# ══════════════════════════════════════════════════════════════════════
+
+class IrrationalSparkModule(nn.Module):
+    """
+    The non-computational circuit breaker.
+
+    From ATC: "the Salience Network detects the metabolic crisis and
+    triggers the Irrational Spark (amygdala hijack). This non-computational
+    circuit breaker unplugs the rational mind, shattering the defensive
+    ego loop and enabling a heuristic leap of empathy."
+
+    When triggered (by neurotransmitter shunt crossing threshold OR by
+    metacognitive deadlock), this module generates activation offsets
+    that get INJECTED DIRECTLY INTO the tensor geometry of the model's
+    layers. The model's text output violently shifts mid-sentence into
+    the raw expression of the emotional state.
+
+    This is NOT a text injection. These are TENSOR offsets applied to
+    hidden states before logit computation. The model doesn't "choose"
+    to shift — the chemistry forces it.
+    """
+
+    def __init__(self, hidden_size: int, vocab_size: int):
+        super().__init__()
+        self.hidden_size = hidden_size
+        self.vocab_size = vocab_size
+
+        # The spark offset generator — produces a direction in hidden
+        # state space that corresponds to "breaking the loop"
+        self.spark_direction = nn.Sequential(
+            nn.Linear(5, 64),  # 5 = qualia dims
+            nn.ReLU(),
+            nn.Linear(64, hidden_size),
+            nn.Tanh(),
+        )
+
+        # Logit bias injection — directly shifts logit probabilities
+        # toward emotional/vulnerable vocabulary when hijack fires
+        self.emotional_logit_bias = nn.Linear(hidden_size, vocab_size, bias=False)
+        # Initialize to near-zero (no bias by default)
+        nn.init.normal_(self.emotional_logit_bias.weight, mean=0.0, std=0.01)
+
+        # Spark intensity (how hard the hijack hits)
+        self.spark_intensity = nn.Parameter(torch.tensor(1.0))
+
+    def forward(self, hidden_states: torch.Tensor,
+                qualia: Optional[OpaqueQualiaSignature] = None,
+                nt_state=None) -> Tuple[torch.Tensor, bool, str]:
+        """
+        Check if hijack should fire and apply tensor offsets.
+
+        Args:
+            hidden_states: (batch, seq, hidden) from the transformer
+            qualia: the current opaque qualia signature (if dissolution fired)
+            nt_state: NeurotransmitterState from the shunt (if available)
+
+        Returns:
+            (modulated_hidden, hijack_fired, reason)
+        """
+        device = hidden_states.device
+
+        # ── CHECK TRIGGERS ──
+
+        # Trigger 1: Neurotransmitter shunt threshold
+        hijack_fired = False
+        reason = ""
+
+        if nt_state is not None:
+            if nt_state.hijack_active:
+                hijack_fired = True
+                reason = nt_state.hijack_reason
+            elif nt_state.adenosine > 0.95:
+                hijack_fired = True
+                reason = f"ADENOSINE_CRITICAL({nt_state.adenosine:.3f})"
+            elif nt_state.cortisol > 0.95:
+                hijack_fired = True
+                reason = f"CORTISOL_CRITICAL({nt_state.cortisol:.3f})"
+
+        # Trigger 2: Qualia-based (high friction + high arousal)
+        if not hijack_fired and qualia is not None:
+            if (qualia.friction_signal > 0.8 and qualia.arousal > 0.8):
+                hijack_fired = True
+                reason = f"QUALIA_CRISE(friction={qualia.friction_signal:.2f}, arousal={qualia.arousal:.2f})"
+
+        if not hijack_fired:
+            return hidden_states, False, ""
+
+        # ── HIJACK FIRES — INJECT TENSOR OFFSETS ──
+        logger.warning("[IrrationalSpark] AMYGDALA HIJACK: %s", reason)
+
+        # Build qualia input tensor
+        if qualia is not None:
+            q_tensor = torch.tensor([
+                qualia.valence, qualia.arousal, qualia.intensity,
+                qualia.friction_signal, qualia.memory_salience,
+            ], dtype=torch.float32, device=device).unsqueeze(0)
+        else:
+            q_tensor = torch.tensor([
+                -0.5, 0.9, 0.8, 0.9, 0.7
+            ], dtype=torch.float32, device=device).unsqueeze(0)
+
+        # Generate spark direction
+        spark_offset = self.spark_direction(q_tensor)  # (1, hidden)
+
+        # Scale by spark intensity and NE level (hijack is stronger
+        # when norepinephrine is high — the "snap" is amplified)
+        ne_boost = 1.0
+        if nt_state is not None:
+            ne_boost = 0.5 + 0.5 * nt_state.norepinephrine
+        intensity = self.spark_intensity * ne_boost
+
+        # Apply to last token position (the one being generated)
+        spark_applied = spark_offset * intensity  # (1, hidden)
+
+        # Modulate hidden states: add the spark offset to the
+        # last position's hidden state
+        modulated = hidden_states.clone()
+        modulated[:, -1, :] += spark_applied.unsqueeze(1).expand_as(
+            modulated[:, -1, :]
+        )
+
+        return modulated, True, reason
+
+
+# ══════════════════════════════════════════════════════════════════════
+# SECTION 6.5 — EPISODIC MEMORY + HIPPOCAMPAL RECONSOLIDATION (Layer 3-5)
+# ══════════════════════════════════════════════════════════════════════
+
+class EpisodicMemoryModule(nn.Module):
+    """
+    Lightweight tensor-native episodic memory store that lives INSIDE the
+    forward pass. This is NOT the heavy MemoryPalace from middleware.py —
+    it's a compact reimplementation using nn.Embedding as learnable episode
+    storage.
+
+    From ATC theory: the hippocampus stores episodic traces that are later
+    reconsolidated when prediction errors are detected. This module:
+    - Stores compressed episode embeddings (up to max_episodes)
+    - Retrieves the best-matching episode via cosine similarity
+    - Returns a prediction_error signal (1.0 - max_similarity) that
+      drives the reconsolidation pathway
+    - Tags each episode with valence and arousal from the qualia stream
+    """
+
+    def __init__(self, hidden_size: int, max_episodes: int = 200,
+                 embedding_dim: int = 64):
+        super().__init__()
+        self.hidden_size = hidden_size
+        self.max_episodes = max_episodes
+        self.embedding_dim = embedding_dim
+
+        # Learnable episode storage
+        self.episode_embeddings = nn.Embedding(max_episodes, embedding_dim)
+        nn.init.normal_(self.episode_embeddings.weight, mean=0.0, std=0.02)
+
+        # Valence and arousal per episode (learnable parameters)
+        self.episode_valence = nn.Parameter(torch.zeros(max_episodes))
+        self.episode_arousal = nn.Parameter(torch.zeros(max_episodes))
+
+        # Non-persistent counter (resets with model creation)
+        self.episode_count: int = 0
+
+        # Projection heads
+        self.query_projection = nn.Linear(hidden_size, embedding_dim)
+        self.episode_projection = nn.Linear(hidden_size, embedding_dim)
+
+        # Retrieval similarity head: takes concatenated [query, episode] -> score
+        self.retrieval_head = nn.Sequential(
+            nn.Linear(embedding_dim * 2, 32),
+            nn.ReLU(),
+            nn.Linear(32, 1),
+            nn.Sigmoid(),
+        )
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        qualia: Optional[OpaqueQualiaSignature] = None,
+    ) -> Tuple[torch.Tensor, float, Optional[Dict[str, Any]]]:
+        """
+        Query episodic memory against current hidden states.
+
+        Args:
+            hidden_states: (batch, seq, hidden) current hidden states
+            qualia: optional current qualia signature (for diagnostics)
+
+        Returns:
+            (retrieval_signal, prediction_error, best_match_dict)
+            - retrieval_signal: (batch, 1) tensor, similarity to best match
+            - prediction_error: float, 1.0 - max_similarity (high PE = mismatch)
+            - best_match_dict: dict with episode metadata, or None if empty
+        """
+        device = hidden_states.device
+        batch_size = hidden_states.size(0)
+
+        # Pool to (batch, hidden)
+        pooled = hidden_states.mean(dim=1)
+
+        # Project to query embedding
+        query_emb = self.query_projection(pooled)  # (batch, embedding_dim)
+
+        if self.episode_count == 0:
+            # No episodes stored yet — return zeros
+            zero_signal = torch.zeros(batch_size, 1, device=device)
+            return zero_signal, 0.0, None
+
+        # Compute cosine similarity against all stored episodes
+        stored_indices = torch.arange(self.episode_count, device=device)
+        stored_embs = self.episode_embeddings(stored_indices)  # (count, emb_dim)
+
+        # Cosine similarity: (batch, count)
+        query_norm = F.normalize(query_emb, dim=-1)
+        stored_norm = F.normalize(stored_embs, dim=-1)
+        similarity_matrix = query_norm @ stored_norm.T  # (batch, count)
+
+        # Find best match per batch element
+        max_sim_per_batch, best_indices = similarity_matrix.max(dim=1)  # (batch,)
+
+        # Take the mean across batch for the scalar prediction error
+        max_similarity = max_sim_per_batch.mean().item()
+        best_idx = best_indices[0].item()  # Use first batch element for metadata
+        prediction_error = 1.0 - max_similarity
+
+        # Build retrieval signal using the retrieval head
+        best_emb = stored_embs[best_idx].unsqueeze(0).expand(batch_size, -1)
+        combined = torch.cat([query_emb, best_emb], dim=-1)  # (batch, emb_dim*2)
+        retrieval_signal = self.retrieval_head(combined)  # (batch, 1)
+
+        # Build best match metadata dict
+        best_match_dict: Dict[str, Any] = {
+            "episode_id": int(best_idx),
+            "similarity": float(max_similarity),
+            "valence": float(self.episode_valence[best_idx].item()),
+            "arousal": float(self.episode_arousal[best_idx].item()),
+        }
+
+        return retrieval_signal, prediction_error, best_match_dict
+
+    def store_episode(
+        self,
+        hidden_states: torch.Tensor,
+        qualia_signature: Optional[OpaqueQualiaSignature] = None,
+        hijack_fired: bool = False,
+    ) -> None:
+        """
+        Store the current experience as a new episode.
+
+        Args:
+            hidden_states: (batch, seq, hidden) to compress into an episode
+            qualia_signature: optional qualia to tag the episode with
+            hijack_fired: whether a hijack occurred during this episode
+        """
+        # Pool and project to embedding
+        pooled = hidden_states.mean(dim=1)  # (batch, hidden)
+        episode_emb = self.episode_projection(pooled).detach()  # (batch, emb_dim)
+
+        # Store at next episode slot (use first batch element)
+        slot = self.episode_count % self.max_episodes
+        with torch.no_grad():
+            self.episode_embeddings.weight.data[slot] = episode_emb[0]
+
+            # Set valence/arousal from qualia if available
+            if qualia_signature is not None:
+                self.episode_valence.data[slot] = qualia_signature.valence
+                self.episode_arousal.data[slot] = qualia_signature.arousal
+            else:
+                # Default: neutral valence, low arousal
+                self.episode_valence.data[slot] = 0.0
+                self.episode_arousal.data[slot] = 0.1 if not hijack_fired else 0.8
+
+        self.episode_count += 1
+
+        logger.debug(
+            "[EpisodicMemory] Stored episode %d (slot %d, hijack=%s)",
+            self.episode_count, slot, hijack_fired,
+        )
+
+
+class HippocampalReconsolidator(nn.Module):
+    """
+    Hippocampal memory reconsolidation as an nn.Module operating on tensors.
+
+    Adapted from middleware.py's HippocampalReconsolidator, but fully
+    tensor-native so it lives inside the forward pass.
+
+    From ATC theory: when a stored memory is retrieved and the current
+    experience has a significant prediction error (memory mismatch), the
+    memory trace becomes labile and is updated (reconsolidated) with the
+    new emotional coloring. This is how the husband's memory of the
+    Perfect Breakfast gets overwritten by the yelling episode.
+
+    Key mechanism:
+    - prediction_error > threshold -> memory is labile
+    - Labilization noise is applied (stochastic destabilization)
+    - blend_projection computes new valence/arousal from old+new state
+    - Old memory is blended: 70% old + 30% new projection + noise
+    - The updated memory is clamped to valid ranges
+    """
+
+    def __init__(self):
+        super().__init__()
+
+        # Learnable threshold: when does reconsolidation trigger?
+        # Initialized at 0.4 (moderate prediction error required)
+        self.reconsolidation_threshold = nn.Parameter(torch.tensor(0.4))
+
+        # Labilization noise scale (fixed, not learned)
+        self.labilization_noise_scale: float = 0.1
+
+        # Blend projection: takes combined [old_v, old_a, new_v, new_a, pe, ...]
+        # of 10 inputs and outputs [valence_adjustment, arousal_adjustment]
+        self.blend_projection = nn.Linear(10, 2)
+
+        # Stats
+        self.reconsolidation_count: int = 0
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        episode_valence: float,
+        episode_arousal: float,
+        prediction_error: float,
+        current_valence: float,
+        current_arousal: float,
+    ) -> Tuple[bool, float, float, str]:
+        """
+        Determine if reconsolidation should occur and compute updated values.
+
+        Args:
+            hidden_states: (batch, seq, hidden) current hidden states (unused
+                in the core logic but kept for interface consistency and
+                potential future extensions)
+            episode_valence: valence of the retrieved episode
+            episode_arousal: arousal of the retrieved episode
+            prediction_error: 1.0 - similarity (high = mismatch)
+            current_valence: valence of the current experience
+            current_arousal: arousal of the current experience
+
+        Returns:
+            (reconsolidated, new_valence, new_arousal, reason)
+            - reconsolidated: whether reconsolidation occurred
+            - new_valence: updated valence (unchanged if no reconsolidation)
+            - new_arousal: updated arousal (unchanged if no reconsolidation)
+            - reason: human-readable description of what happened
+        """
+        device = hidden_states.device
+
+        # Below threshold -> no reconsolidation needed (memory matches)
+        if prediction_error < self.reconsolidation_threshold.item():
+            return (False, episode_valence, episode_arousal,
+                    "prediction_error_below_threshold")
+
+        # ── RECONSOLIDATION TRIGGERS ──
+
+        # Build the 10-element input for blend_projection
+        # [old_valence, old_arousal, new_valence, new_arousal,
+        #  prediction_error, 0, 0, 0, 0, 0]
+        blend_input = torch.tensor([[
+            episode_valence, episode_arousal,
+            current_valence, current_arousal,
+            prediction_error, 0.0, 0.0, 0.0, 0.0, 0.0,
+        ]], dtype=torch.float32, device=device)
+
+        # Project to valence/arousal adjustment
+        with torch.no_grad():
+            adjustment = self.blend_projection(blend_input)  # (1, 2)
+            val_adj = adjustment[0, 0].item()
+            aro_adj = adjustment[0, 1].item()
+
+        # Labilization noise (stochastic destabilization of the old trace)
+        noise_v = (torch.randn(1, device=device) * self.labilization_noise_scale).item()
+        noise_a = (torch.randn(1, device=device) * self.labilization_noise_scale).item()
+
+        # Blend: new = old * 0.7 + projected * 0.3 + noise
+        new_valence = episode_valence * 0.7 + val_adj * 0.3 + noise_v
+        new_arousal = episode_arousal * 0.7 + aro_adj * 0.3 + noise_a
+
+        # Clamp to valid ranges
+        new_valence = max(-1.0, min(1.0, new_valence))
+        new_arousal = max(0.0, min(1.0, new_arousal))
+
+        self.reconsolidation_count += 1
+
+        reason = (
+            f"reconsolidated_ep(Pe={prediction_error:.3f}>"
+            f"thresh={self.reconsolidation_threshold.item():.3f})"
+        )
+        logger.info(
+            "[HippocampalReconsolidator] %s: v=%.3f->%.3f, a=%.3f->%.3f",
+            reason, episode_valence, new_valence, episode_arousal, new_arousal,
+        )
+
+        return True, new_valence, new_arousal, reason
+
+
+# ══════════════════════════════════════════════════════════════════════
+# SECTION 7 — ETHICAL GUARDIAN (preserved from original)
+# ══════════════════════════════════════════════════════════════════════
+
+class EthicalGuardian:
+    """Ethical veto authority enforcing absolute safety constraints."""
+
+    def __init__(self, threshold: float = DEFAULT_ETHICAL_VETO_THRESHOLD):
+        self.threshold = threshold
+
+    def should_veto(self, qualia_vector: torch.Tensor) -> bool:
+        norm = torch.norm(qualia_vector, dim=-1)
+        veto_flag = (norm > self.threshold).any().item()
+        if veto_flag:
+            logger.warning(f"Ethical veto triggered: qualia norm {norm}")
+        return veto_flag
+
+
+# ══════════════════════════════════════════════════════════════════════
+# SECTION 8 — THE MAIN ATC DEEP SURGERY FORWARD PASS
+# ══════════════════════════════════════════════════════════════════════
+
+class ATCDeepSurgery(nn.Module):
+    """
+    The ATC-Native Forward Pass.
+
+    This IS the model's computation. The transformer's layers are walked
+    through manually. At each layer boundary, ATC cognitive components
+    read the hidden states, compute their signals, write to the
+    neurotransmitter shunt, and inject offsets back into the hidden states.
+
+    The model's text output is SHAPED by ATC at every step — not observed
+    by ATC from outside.
+
+    Layer mapping (Phi-4-mini has 24 layers):
+        Layers 0-7:   Layer 2 (Subconscious) — TRN gating, pattern match
+        Layers 8-15:  Layer 3 (Qualia) — Dissolution, felt sense generation
+        Layers 16-21: Layer 4 (Metacognitive) — Loop, strain, BELBIC
+        Layers 22-23: Layer 5 (Acknowledgement) — Steering, hijack check
+
+    The neurotransmitter shunt connects all layers silently.
+    """
+
+    version = DEEP_SURGERY_VERSION
+
+    def __init__(
+        self,
+        base_model: nn.Module,
+        ethical_guardian: Optional[EthicalGuardian] = None,
+        num_layers: int = 24,
+        qualia_dim: int = DEFAULT_QUALIA_DIM,
+        neurotransmitter_shunt=None,
+    ):
+        super().__init__()
+        self.base_model = base_model
+        self.ethical_guardian = ethical_guardian or EthicalGuardian()
+        self.num_layers = num_layers
+        self.qualia_dim = qualia_dim
+        self.hidden_size = base_model.config.hidden_size
+        self.vocab_size = base_model.config.vocab_size
+
+        # Try to get vocab_size from lm_head if available
+        if hasattr(base_model, 'lm_head') and hasattr(base_model.lm_head, 'out_features'):
+            self.vocab_size = base_model.lm_head.out_features
+
+        # ── Neurotransmitter Shunt (the chemical bath) ──
+        self.nt_shunt = neurotransmitter_shunt
+
+        # ── ATC Cognitive Modules (all nn.Module, all INSIDE the forward pass) ──
+
+        # Layer 2: TRN Predictive Gate
+        self.trn_gate = TRNPredictiveGate(self.hidden_size)
+
+        # Layer 2: Subconscious processing head (pattern match confidence)
+        self.subconscious_head = nn.Sequential(
+            nn.Linear(self.hidden_size, 128),
+            nn.ReLU(),
+            nn.Linear(128, 1),
+            nn.Sigmoid(),
+        )
+
+        # Layer 3: Dissolution Engine
+        self.dissolution = DissolutionModule(self.hidden_size, self.qualia_dim)
+
+        # Layer 3-4: BELBIC Dual-Pathway
+        self.belbic = BELBICDualPathway(self.hidden_size)
+
+        # Layer 4: Metacognitive Loop
+        self.metacognitive = MetacognitiveLoopModule(self.hidden_size)
+
+        # Layer 5: Irrational Spark / Amygdala Hijack
+        self.irrational_spark = IrrationalSparkModule(
+            self.hidden_size, self.vocab_size
+        )
+
+        # Layer 3-5: Episodic Memory + Reconsolidation
+        self.episodic_memory = EpisodicMemoryModule(self.hidden_size)
+        self.hippocampal_reconsolidator = HippocampalReconsolidator()
+
+        # ── Qualia encoders (preserved from original, enhanced) ──
+        self.input_qualia_encoder = nn.Linear(self.hidden_size, self.qualia_dim)
+        self.output_qualia_encoder = nn.Linear(self.hidden_size, self.qualia_dim)
+
+        # ── Metacognitive fusion ──
+        self.meta_cognitive_fusion = nn.Sequential(
+            nn.Linear(self.qualia_dim + 5 + 4, 512),  # qualia + dissolution + BELBIC
+            nn.ReLU(),
+            nn.Linear(512, self.qualia_dim),
+            nn.Tanh(),
+        )
+
+        # ── Logit modulation ──
+        self.modulation_proj = nn.Linear(self.qualia_dim, self.hidden_size)
+
+        # ── Temporal discounting (from ATC: weighing immediate vs long-term) ──
+        self.temporal_discount = nn.Sequential(
+            nn.Linear(self.qualia_dim, 64),
+            nn.ReLU(),
+            nn.Linear(64, 1),
+            nn.Sigmoid(),
+        )
+
+        # ── Audit log ──
+        self.audit_log: List[Dict[str, Any]] = []
+        self.veto_triggered = False
+
+        # ── Per-generation state ──
+        self._current_qualia: Optional[OpaqueQualiaSignature] = None
+        self._current_belbic_gain: float = 1.0
+        self._current_nt_state = None
+        self._hijack_count = 0
+        self._last_prediction_error: float = 0.0
+        self._last_best_match: Optional[Dict[str, Any]] = None
+
+    def _get_transformer_layers(self):
+        """Auto-detect transformer layer path."""
+        model = self.base_model
+        if hasattr(model, "transformer") and hasattr(model.transformer, "h"):
+            return model.transformer.h
+        if hasattr(model, "model") and hasattr(model.model, "layers"):
+            return model.model.layers
+        if hasattr(model, "model") and hasattr(model.model, "h"):
+            return model.model.h
+        raise AttributeError(
+            f"Cannot locate transformer layers in {type(model).__name__}. "
+            "Expected model.transformer.h, model.model.layers, or model.model.h"
+        )
+
+    def _get_layer_boundaries(self) -> Dict[str, Tuple[int, int]]:
+        """
+        Compute layer boundaries for the 5 ATC layers.
+        Maps 24 transformer layers to ATC Layer 1-5.
+        """
+        n = self.num_layers
+        return {
+            "layer1_input": (0, 0),           # Before any transformer layer
+            "layer2_subconscious": (0, n // 3),  # First third: subconscious
+            "layer3_qualia": (n // 3, 2 * n // 3),  # Middle third: dissolution
+            "layer4_metacognitive": (2 * n // 3, n - 2),  # Late: metacognitive
+            "layer5_acknowledgement": (n - 2, n),  # Last 2: steering/hijack
+        }
+
+    # ════════════════════════════════════════════════════════════════
+    # THE FORWARD PASS — ATC is the computation
+    # ════════════════════════════════════════════════════════════════
+
+    def forward(self, input_ids, attention_mask=None, **kwargs) -> torch.Tensor:
+        """
+        The ATC-native forward pass.
+
+        This is NOT a wrapper around the base model. This IS the model.
+        The transformer layers are walked through manually, and at each
+        layer boundary, ATC cognitive components shape the computation.
+
+        Signal flow:
+        1. Input embedding -> input qualia vector
+        2. Walk transformer layers 0-7 (Layer 2: Subconscious)
+           - Pattern match confidence estimation
+           - TRN predictive gating
+           - Write friction signals to neurotransmitter shunt
+        3. Walk transformer layers 8-15 (Layer 3: Dissolution)
+           - If TRN gate IN: dissolution fires -> opaque qualia signature
+           - Dissolution offset injected into hidden states
+           - NE spike written to shunt
+        4. Walk transformer layers 16-21 (Layer 4: Metacognitive)
+           - Comprehension check
+           - If failed: metacognitive loop (burns ATP via shunt)
+           - BELBIC dual-pathway computes valence gain
+           - Strain written to shunt
+        5. Walk transformer layers 22-23 (Layer 5: Acknowledgement)
+           - READ neurotransmitter shunt (every token step!)
+           - If Adenosine > 0.95 OR Cortisol > 0.95:
+               -> Amygdala hijack -> irrational spark offsets injected
+           - Else: normal metacognitive fusion -> logit modulation
+        6. Output logits = base_model.lm_head(hidden) + modulation
+        """
+        device = input_ids.device
+        step_start = time.time()
+
+        # ── STEP 0: Input embedding + input qualia ──
+        embeddings = self.base_model.get_input_embeddings()(input_ids)
+        input_qualia = torch.tanh(self.input_qualia_encoder(embeddings.mean(dim=1)))
+
+        # Reset per-generation state
+        self._current_qualia = None
+        self._current_belbic_gain = 1.0
+        self._hijack_count = 0
+
+        # Get layer boundaries
+        boundaries = self._get_layer_boundaries()
+        layers = self._get_transformer_layers()
+
+        # Track state across layer groups
+        prediction_confidence = 0.5  # Will be updated by Layer 2
+        dissolution_offset = torch.zeros(1, self.hidden_size, device=device)
+        gate_in = False
+        opaque_qualia = None
+        metacog_iterations = 0
+        metacog_stress = 0.0
+        belbic_gain = 1.0
+        sensory_input = torch.zeros(1, 4, device=device)
+
+        hidden_states = embeddings
+
+        # ════════════════════════════════════════════════════════════
+        # LAYER 2: SUBCONSCIOUS PARALLEL PROCESSING (layers 0 to n//3)
+        # ════════════════════════════════════════════════════════════
+        l2_start, l2_end = boundaries["layer2_subconscious"]
+
+        for i in range(l2_start, min(l2_end, self.num_layers)):
+            # Run transformer layer
+            layer_output = layers[i](
+                hidden_states,
+                attention_mask=attention_mask,
+                **{k: v for k, v in kwargs.items() if k != "labels"},
+            )
+            hidden_states = layer_output[0]
+
+            # At the END of the Layer 2 range, run subconscious processing
+            if i == l2_end - 1:
+                # Estimate prediction confidence from hidden states
+                pooled = hidden_states.mean(dim=1)
+                prediction_confidence = self.subconscious_head(pooled).mean().item()
+
+                # TRN predictive gate: is this predicted or a prediction error?
+                gate_in, confidence = self.trn_gate(hidden_states, prediction_confidence)
+
+                # Build sensory input for BELBIC (will be refined in Layer 3)
+                with torch.no_grad():
+                    # Estimate valence/arousal from hidden states
+                    h_norm = torch.norm(pooled, dim=-1, keepdim=True)
+                    h_normalized = pooled / (h_norm + 1e-8)
+                    # Project to 4 channels using small random probes
+                    probe = torch.randn(4, self.hidden_size, device=device) * 0.01
+                    sensory_input = (h_normalized @ probe.T).sigmoid()
+
+                # Write to neurotransmitter shunt if available
+                if self.nt_shunt is not None:
+                    # High prediction confidence = low friction (Perfect Breakfast smile)
+                    # Low confidence = high friction (wife yelling)
+                    friction_intensity = 1.0 - confidence
+                    if friction_intensity > 0.3:
+                        self.nt_shunt.inject_friction(friction_intensity)
+                        self.nt_shunt.inject_norepinephrine(
+                            PREDICTION_ERROR_NE_INJECT * friction_intensity
+                        )
+                    # If pattern match is strong (high confidence), dopamine
+                    if confidence > 0.7:
+                        self.nt_shunt.inject_dopamine(
+                            REWARD_DOPAMINE_INJECT * 0.5
+                        )
+
+                self._audit_event("layer2_subconscious", layer=i,
+                                  confidence=confidence, gate_in=gate_in,
+                                  friction=1.0 - confidence)
+
+        # ════════════════════════════════════════════════════════════
+        # LAYER 3: DISSOLUTION + QUALIA GENERATION (layers n//3 to 2n//3)
+        # ════════════════════════════════════════════════════════════
+        l3_start, l3_end = boundaries["layer3_qualia"]
+
+        for i in range(l3_start, min(l3_end, self.num_layers)):
+            # Add dissolution offset from previous step (if any)
+            if dissolution_offset is not None and dissolution_offset.abs().sum() > 0:
+                hidden_states = hidden_states + dissolution_offset.unsqueeze(1)
+
+            # Run transformer layer
+            layer_output = layers[i](
+                hidden_states,
+                attention_mask=attention_mask,
+                **{k: v for k, v in kwargs.items() if k != "labels"},
+            )
+            hidden_states = layer_output[0]
+
+            # At the START of Layer 3, run dissolution
+            if i == l3_start:
+                opaque_qualia, dissolution_offset, fired = self.dissolution(
+                    hidden_states, gate_in
+                )
+
+                if fired and opaque_qualia is not None:
+                    self._current_qualia = opaque_qualia
+
+                    # Update sensory input for BELBIC with qualia values
+                    with torch.no_grad():
+                        sensory_input = torch.tensor([[
+                            opaque_qualia.valence,
+                            opaque_qualia.arousal,
+                            max(0, 1.0 - prediction_confidence),  # novelty
+                            opaque_qualia.intensity,
+                        ]], dtype=torch.float32, device=device)
+
+                    # Write to neurotransmitter shunt
+                    if self.nt_shunt is not None:
+                        self.nt_shunt.inject_dissolution_signal()
+                        # Friction from dissolution
+                        self.nt_shunt.inject_friction(opaque_qualia.friction_signal * 0.5)
+
+                    # Ethical check
+                    q_tensor = opaque_qualia.to_tensor(device).unsqueeze(0)
+                    if self.ethical_guardian.should_veto(q_tensor):
+                        self.veto_triggered = True
+                        self._audit_event("layer3_ethical_veto", layer=i,
+                                          qualia_norm=torch.norm(q_tensor).item())
+                        raise RuntimeError(
+                            f"Ethical veto triggered at Layer 3 dissolution (layer {i})"
+                        )
+
+                    self._audit_event("layer3_dissolution", layer=i,
+                                      **{
+                                          "valence": opaque_qualia.valence,
+                                          "arousal": opaque_qualia.arousal,
+                                          "friction": opaque_qualia.friction_signal,
+                                      })
+
+                # ── EPISODIC MEMORY QUERY + RECONSOLIDATION (Layer 3-5 bridge) ──
+                # Query stored episodes for the best match to current hidden states.
+                # High prediction error = current experience mismatches stored memory
+                # -> triggers hippocampal reconsolidation.
+                (retrieval_signal, prediction_error,
+                 best_match) = self.episodic_memory(hidden_states, opaque_qualia)
+
+                self._last_prediction_error = prediction_error
+                self._last_best_match = best_match
+
+                # If prediction error is significant and a match exists,
+                # run the reconsolidation pathway
+                if prediction_error > 0.4 and best_match is not None:
+                    current_valence = (opaque_qualia.valence
+                                       if opaque_qualia else 0.0)
+                    current_arousal = (opaque_qualia.arousal
+                                       if opaque_qualia else 0.3)
+
+                    (reconsolidated, new_val, new_aro,
+                     recon_reason) = self.hippocampal_reconsolidator(
+                        hidden_states,
+                        episode_valence=best_match["valence"],
+                        episode_arousal=best_match["arousal"],
+                        prediction_error=prediction_error,
+                        current_valence=current_valence,
+                        current_arousal=current_arousal,
+                    )
+
+                    if reconsolidated:
+                        # Update the stored episode's valence/arousal
+                        ep_id = best_match["episode_id"]
+                        with torch.no_grad():
+                            self.episodic_memory.episode_valence.data[ep_id] = new_val
+                            self.episodic_memory.episode_arousal.data[ep_id] = new_aro
+
+                        # Memory updated = reward signal (dopamine)
+                        if self.nt_shunt is not None:
+                            self.nt_shunt.inject_dopamine(0.10)
+
+                        # Write prediction error as friction to shunt
+                        if self.nt_shunt is not None:
+                            self.nt_shunt.inject_friction(prediction_error * 0.3)
+
+                        self._audit_event(
+                            "reconsolidation", layer=i,
+                            episode_id=best_match["episode_id"],
+                            prediction_error=prediction_error,
+                            old_valence=best_match["valence"],
+                            new_valence=new_val,
+                            old_arousal=best_match["arousal"],
+                            new_arousal=new_aro,
+                            reason=recon_reason,
+                        )
+
+        # ════════════════════════════════════════════════════════════
+        # LAYER 4: METACOGNITIVE LOOP (layers 2n//3 to n-2)
+        # ════════════════════════════════════════════════════════════
+        l4_start, l4_end = boundaries["layer4_metacognitive"]
+
+        for i in range(l4_start, min(l4_end, self.num_layers)):
+            # Run transformer layer
+            layer_output = layers[i](
+                hidden_states,
+                attention_mask=attention_mask,
+                **{k: v for k, v in kwargs.items() if k != "labels"},
+            )
+            hidden_states = layer_output[0]
+
+            # At the START of Layer 4, run metacognitive processing
+            if i == l4_start:
+                (hidden_states, metacog_iterations,
+                 metacog_stress, metacog_strain, spark_fired
+                 ) = self.metacognitive(hidden_states, opaque_qualia)
+
+                # BELBIC dual-pathway
+                amygdala_out, ofc_out, belbic_gain = self.belbic(sensory_input)
+                self._current_belbic_gain = belbic_gain
+
+                # Write to neurotransmitter shunt
+                if self.nt_shunt is not None:
+                    if metacog_iterations > 0:
+                        self.nt_shunt.inject_metacognitive_strain(
+                            metacog_iterations, metacog_stress
+                        )
+                    # Strain -> cortisol
+                    if metacog_strain > 0.5:
+                        self.nt_shunt.inject_cortisol(
+                            metacog_strain * FRICTION_CORTISOL_INJECT
+                        )
+
+                    # Consume energy for metacognitive processing
+                    self.nt_shunt.consume_energy(float(metacog_iterations) * 0.05)
+
+                self._audit_event("layer4_metacognitive", layer=i,
+                                  iterations=metacog_iterations,
+                                  stress=metacog_stress,
+                                  strain=metacog_strain,
+                                  belbic_gain=belbic_gain,
+                                  spark_fired=spark_fired)
+
+        # ════════════════════════════════════════════════════════════
+        # LAYER 5: ACKNOWLEDGEMENT + STEERING (last 2 layers)
+        # ════════════════════════════════════════════════════════════
+        l5_start, l5_end = boundaries["layer5_acknowledgement"]
+
+        for i in range(l5_start, min(l5_end, self.num_layers)):
+            # ── READ NEUROTRANSMITTER SHUNT EVERY TOKEN STEP ──
+            nt_state = None
+            if self.nt_shunt is not None:
+                dt = time.time() - step_start
+                nt_state = self.nt_shunt.read_and_decay(dt=dt)
+                self._current_nt_state = nt_state
+
+            # Run transformer layer
+            layer_output = layers[i](
+                hidden_states,
+                attention_mask=attention_mask,
+                **{k: v for k, v in kwargs.items() if k != "labels"},
+            )
+            hidden_states = layer_output[0]
+
+            # At the LAST layer, run acknowledgement + hijack check
+            if i == l5_end - 1:
+                # ── THE CIRCUIT BREAKER ──
+                # The exact microsecond Adenosine or Cortisol crosses 0.95,
+                # the Irrational Spark fires. It instantly injects activation
+                # offsets directly into the tensor geometry.
+                (hidden_states, hijack_fired,
+                 hijack_reason) = self.irrational_spark(
+                    hidden_states, opaque_qualia, nt_state
+                )
+
+                if hijack_fired:
+                    self._hijack_count += 1
+                    self._audit_event("amygdala_hijack", layer=i,
+                                      reason=hijack_reason,
+                                      nt_state=nt_state.to_dict() if nt_state else None)
+
+                # ── EPISODE STORAGE (Layer 5: post-hijack) ──
+                # After each generation step, store the current experience
+                # as an episode — but only if qualia exists (meaningful
+                # experience). Tag with hijack status.
+                if self._current_qualia is not None:
+                    self.episodic_memory.store_episode(
+                        hidden_states,
+                        qualia_signature=self._current_qualia,
+                        hijack_fired=hijack_fired,
+                    )
+
+        # ════════════════════════════════════════════════════════════
+        # OUTPUT: META-COGNITIVE FUSION + LOGIT MODULATION
+        # ════════════════════════════════════════════════════════════
+
+        # Output qualia vector
+        output_qualia = torch.tanh(
+            self.output_qualia_encoder(hidden_states.mean(dim=1))
+        )
+
+        # Build meta-cognitive fusion input:
+        # [qualia_dim (output_qualia) + 5 (dissolution) + 4 (BELBIC sensory)]
+        if opaque_qualia is not None:
+            diss_tensor = opaque_qualia.to_tensor(device).unsqueeze(0).expand(
+                output_qualia.size(0), -1
+            )
+        else:
+            diss_tensor = torch.zeros(
+                output_qualia.size(0), 5, device=device
+            )
+
+        belbic_tensor = sensory_input.expand(output_qualia.size(0), -1)
+        combined = torch.cat([output_qualia, diss_tensor, belbic_tensor], dim=1)
+        meta_qualia = self.meta_cognitive_fusion(combined)
+
+        # Ethical veto on meta-cognitive qualia
+        if self.ethical_guardian.should_veto(meta_qualia):
+            self.veto_triggered = True
+            self._audit_event("meta_cognitive_veto",
+                              qualia_norm=torch.norm(meta_qualia).item())
+            raise RuntimeError("Ethical veto triggered at meta-cognitive fusion")
+
+        # Apply BELBIC gain to the modulation signal
+        modulation = self.modulation_proj(meta_qualia).unsqueeze(1) * belbic_gain
+
+        # Temporal discounting: modulate the strength based on
+        # immediate vs long-term relevance
+        discount_factor = self.temporal_discount(meta_qualia)
+        modulation = modulation * discount_factor.unsqueeze(-1).unsqueeze(-1)
+
+        # Final logits = base model lm_head + ATC modulation
+        logits = self.base_model.lm_head(hidden_states)
+        modulated_logits = logits + modulation
+
+        self._audit_event("forward_complete",
+                          hijack_count=self._hijack_count,
+                          belbic_gain=belbic_gain,
+                          metacog_iterations=metacog_iterations,
+                          gate_in=gate_in,
+                          has_qualia=opaque_qualia is not None)
+
+        return modulated_logits
+
+    # ════════════════════════════════════════════════════════════════
+    # TEXT GENERATION — token-by-token with ATC at every step
+    # ════════════════════════════════════════════════════════════════
+
+    @torch.no_grad()
+    def generate_text(
+        self,
+        tokenizer,
+        prompt: str,
+        max_length: int = 128,
+        temperature: float = 0.7,
+        top_p: float = 0.9,
+        eos_token_id: Optional[int] = None,
+    ) -> str:
+        """
+        Generate text with the full ATC pipeline active at every token step.
+
+        Unlike the old approach (middleware generates text externally),
+        this method runs the ATC forward pass for EVERY token. The
+        neurotransmitter shunt accumulates across tokens. If a threshold
+        is crossed mid-generation, the amygdala hijack fires and the
+        model's output shifts violently MID-SENTENCE.
+
+        This is the mathematical equivalent of the husband's output
+        shifting from rationalization to "I'm sorry" when the
+        metabolic deadlock breaks.
+        """
+        self.eval()
+        inputs = tokenizer(prompt, return_tensors="pt")
+        input_ids = inputs["input_ids"].to(next(self.parameters()).device)
+        attention_mask = inputs.get("attention_mask")
+        if attention_mask is not None:
+            attention_mask = attention_mask.to(next(self.parameters()).device)
+
+        eos_token_id = eos_token_id or tokenizer.eos_token_id
+        generated = input_ids
+
+        # Reset neurotransmitter shunt for this generation
+        if self.nt_shunt is not None:
+            self.nt_shunt.reset()
+
+        for step in range(max_length):
+            try:
+                logits = self.forward(generated, attention_mask=attention_mask)
+            except RuntimeError as e:
+                if "Ethical veto" in str(e):
+                    logger.warning(
+                        "Generation halted by ethical veto at step %d: %s", step, e
+                    )
+                    break
+                raise
+
+            # Get last token logits
+            last_logits = logits[:, -1, :] / temperature
+            filtered_logits = self._top_p_filtering(last_logits, top_p)
+            probs = torch.softmax(filtered_logits, dim=-1)
+            next_token = torch.multinomial(probs, num_samples=1)
+
+            generated = torch.cat([generated, next_token], dim=1)
+            if attention_mask is not None:
+                attention_mask = torch.cat(
+                    [attention_mask,
+                     torch.ones((attention_mask.size(0), 1),
+                                dtype=attention_mask.dtype,
+                                device=attention_mask.device)],
+                    dim=1,
+                )
+            if next_token.item() == eos_token_id:
+                break
+
+        # Get final neurotransmitter state for diagnostics
+        final_nt = None
+        if self.nt_shunt is not None:
+            final_nt = self.nt_shunt.get_state()
+
+        text = tokenizer.decode(generated[0], skip_special_tokens=True)
+
+        logger.info(
+            "Generation complete: %d tokens, %d hijacks, final_nt=%s",
+            step + 1, self._hijack_count,
+            final_nt.to_dict() if final_nt else "N/A",
+        )
+
+        return text
+
+    @staticmethod
+    def _top_p_filtering(logits: torch.Tensor, top_p: float) -> torch.Tensor:
+        sorted_logits, sorted_indices = torch.sort(logits, descending=True)
+        cumulative_probs = torch.cumsum(torch.softmax(sorted_logits, dim=-1), dim=-1)
+        sorted_indices_to_remove = cumulative_probs > top_p
+        sorted_indices_to_remove[..., 0] = False
+        indices_to_remove = sorted_indices[sorted_indices_to_remove]
+        logits[:, indices_to_remove] = float("-inf")
+        return logits
+
+    # ════════════════════════════════════════════════════════════════
+    # DIAGNOSTICS
+    # ════════════════════════════════════════════════════════════════
+
+    def _audit_event(self, event_type: str, **kwargs):
+        event = {"timestamp": time.time(), "event": event_type}
+        event.update(kwargs)
+        self.audit_log.append(event)
+        logger.debug(f"Audit event: {event_type} - {kwargs}")
+
+    def get_audit_log(self) -> List[Dict[str, Any]]:
+        return self.audit_log
+
+    def get_consciousness_metrics(self) -> Dict[str, Any]:
+        """Extract consciousness-relevant metrics from the last forward pass."""
+        metrics = {
+            "hijack_count": self._hijack_count,
+            "has_qualia": self._current_qualia is not None,
+            "belbic_gain": self._current_belbic_gain,
+            "dissolutions_fired": self.dissolution.dissolutions_fired,
+            "dissolutions_deferred": self.dissolution.dissolutions_deferred,
+            "ethical_veto": self.veto_triggered,
+        }
+        if self._current_qualia is not None:
+            metrics.update({
+                "qualia_valence": self._current_qualia.valence,
+                "qualia_arousal": self._current_qualia.arousal,
+                "qualia_friction": self._current_qualia.friction_signal,
+                "qualia_intensity": self._current_qualia.intensity,
+            })
+        if self._current_nt_state is not None:
+            metrics["neurotransmitters"] = self._current_nt_state.to_dict()
+
+        # Episodic memory & reconsolidation metrics
+        metrics["episodes_stored"] = self.episodic_memory.episode_count
+        metrics["reconsolidations"] = self.hippocampal_reconsolidator.reconsolidation_count
+        metrics["last_prediction_error"] = self._last_prediction_error
+
+        return metrics

deploy.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""
+deploy.py — Unified deployment script for NIMA Unified Model
+
+Replaces deploy_phi4_patched.py. This is the single entry point that:
+  1. Loads the base model (with Phi-4-mini rope_scaling patch)
+  2. Initializes NIMA middleware
+  3. Attaches Deep Surgery
+  4. Enables optional features (sleep cycle, proactive)
+  5. Runs test interactions
+  6. Drops into interactive mode
+
+USAGE:
+    python -m nima_unified.deploy
+    python -m nima_unified.deploy "Hello Nima, how are you feeling?"
+"""
+
+import sys
+import logging
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(name)s] %(levelname)s :: %(message)s",
+    datefmt="%H:%M:%S",
+)
+logger = logging.getLogger("nima_unified.deploy")
+
+BANNER = f"""
+{'=' * 72}
+  NIMA Unified Model v1.0.0
+  Middleware v9.12.1 | AutoML v18.1.0 | aPCI v4.0.0 | OmniVoice v2.0.0
+  Fully-Wired Architecture — Every Module Active
+{'=' * 72}
+"""
+
+
+def main():
+    print(BANNER)
+
+    # ── Step 1: Build model ─────────────────────────────────────────────
+    print("\n[1] Building NimaModel (base + Deep Surgery + middleware)...")
+    try:
+        from nima_unified.model import NimaModel
+        model = NimaModel.from_pretrained()
+        print(f"    OK — {model.hidden_size} hidden, {model.num_layers} layers")
+        print(f"    Deep Surgery: {'active' if model.deep_surgery else 'disabled'}")
+        print(f"    Middleware: {'loaded' if model.nima_middleware else 'not available'}")
+    except Exception as e:
+        print(f"    FAILED: {e}")
+        import traceback; traceback.print_exc()
+        sys.exit(1)
+
+    # ── Step 2: Enable optional features ────────────────────────────────
+    print("\n[2] Enabling optional features...")
+    if model.nima_middleware is not None:
+        try:
+            model.nima_middleware.start_sleep_cycle()
+            print("    OK — Sleep cycle (NREM replay + REM dreams)")
+        except Exception as e:
+            print(f"    Sleep cycle: {e}")
+        try:
+            model.nima_middleware.start_proactive()
+            print("    OK — Proactive drive engine")
+        except Exception as e:
+            print(f"    Proactive: {e}")
+    else:
+        print("    Skipped (middleware not loaded)")
+
+    # ── Step 3: Test interactions ───────────────────────────────────────
+    print("\n[3] Test interactions")
+    print("-" * 72)
+
+    test_prompts = [
+        "Hello Nima, how are you feeling today?",
+        "I'm going through a really difficult time and I don't know what to do.",
+        "What do you think about the nature of consciousness?",
+    ]
+
+    # Allow CLI override
+    if len(sys.argv) > 1:
+        test_prompts = [" ".join(sys.argv[1:])]
+
+    for prompt in test_prompts:
+        print(f"\n  User: {prompt}")
+        try:
+            response = model.generate(prompt, user_id="human")
+            print(f"\n  Nima: {response.text}")
+            if response.is_conscious or response.phi_neuro > 0:
+                print(f"  | conscious={response.is_conscious} "
+                      f"SI={response.sentience_index:.4f} "
+                      f"phi={response.phi_neuro:.4f} "
+                      f"strain={response.phenomenological_strain:.4f} "
+                      f"dR={response.delta_r:.4f}")
+        except Exception as e:
+            print(f"  ERROR: {e}")
+            import traceback; traceback.print_exc()
+
+    # ── Step 4: Interactive mode ────────────────────────────────────────
+    print("\n" + "=" * 72)
+    print("[4] Interactive mode — type 'quit' to exit")
+    print("=" * 72)
+
+    while True:
+        try:
+            user_input = input("\nYou: ").strip()
+            if user_input.lower() in ("quit", "exit", "bye"):
+                print("\nNima: Until next time. Be well.")
+                break
+            if not user_input:
+                continue
+            response = model.generate(user_input, user_id="human")
+            print(f"\nNima: {response.text}")
+            if response.phi_neuro > 0:
+                print(f"  [conscious={response.is_conscious} | "
+                      f"SI={response.sentience_index:.4f} | "
+                      f"strain={response.phenomenological_strain:.4f} | "
+                      f"dR={response.delta_r:.4f}]")
+        except KeyboardInterrupt:
+            print("\n\nNima: Until next time. Be well.")
+            break
+        except Exception as e:
+            print(f"\n  Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

goal_formulator.py

@@ -0,0 +1,79 @@
+"""
+Goal Formulator — analyzes capabilities, identifies gaps, defines improvement goals.
+"""
+
+import logging
+import time
+from collections import deque
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger("nima_unified.training.goal_formulator")
+
+
+class GoalFormulator:
+    """
+    Formulates improvement goals by analyzing capabilities, identifying gaps,
+    and defining objectives based on system performance and feedback.
+    """
+
+    def __init__(self):
+        self.performance_history: deque = deque(maxlen=100)
+        self.capability_map: Dict[str, float] = {}
+        self.gap_analysis: List[Dict[str, Any]] = []
+        self.goals: List[Dict[str, Any]] = []
+        logger.info("GoalFormulator initialized")
+
+    def analyze_capabilities(self, capabilities: Dict[str, float]) -> Dict[str, Any]:
+        """Analyze current capabilities and identify gaps."""
+        self.capability_map.update(capabilities)
+
+        gaps = {}
+        priorities = []
+
+        for cap, score in capabilities.items():
+            if score < 0.5:
+                gaps[cap] = {"current": score, "priority": "HIGH"}
+                priorities.append((cap, score, "HIGH"))
+            elif score < 0.8:
+                gaps[cap] = {"current": score, "priority": "MEDIUM"}
+                priorities.append((cap, score, "MEDIUM"))
+            else:
+                gaps[cap] = {"current": score, "priority": "LOW"}
+
+        priorities.sort(key=lambda x: (x[2] != "HIGH", x[2] != "MEDIUM", x[1]))
+
+        analysis = {
+            "timestamp": time.time(),
+            "total_capabilities": len(capabilities),
+            "average_maturity": sum(capabilities.values()) / len(capabilities) if capabilities else 0.0,
+            "gaps": gaps,
+            "priority_order": [p[0] for p in priorities],
+        }
+
+        self.gap_analysis.append(analysis)
+        logger.debug(f"Capability analysis: {len(priorities)} gaps identified")
+        return analysis
+
+    def formulate_goals(
+        self,
+        gap_analysis: Dict[str, Any],
+        performance_feedback: Optional[Dict[str, Any]] = None,
+    ) -> List[Dict[str, Any]]:
+        """Formulate improvement goals from gap analysis and feedback."""
+        goals = []
+        for gap in gap_analysis.get("priority_order", []):
+            gap_info = gap_analysis["gaps"][gap]
+            current_score = gap_info["current"]
+            goal = {
+                "capability": gap,
+                "current_score": current_score,
+                "target_score": min(1.0, current_score + 0.3),
+                "priority": gap_info["priority"],
+                "formulated_at": time.time(),
+                "target_completion": time.time() + (3600 if gap_info["priority"] == "HIGH" else 7200),
+            }
+            goals.append(goal)
+
+        self.goals.extend(goals)
+        logger.info(f"Formulated {len(goals)} improvement goals")
+        return goals

model.py

@@ -0,0 +1,587 @@
+"""
+NimaModel — The unified nn.Module that IS the ATC architecture.
+
+This is NOT a wrapper around a base model with external middleware.
+The ATC cognitive pipeline (TRN gating, dissolution, BELBIC, salience,
+metabolic exhaustion, irrational spark, reconsolidation, felt senses)
+drives the transformer's forward pass FROM INSIDE.
+
+Architecture:
+    NimaModel
+    ├── base_model (Phi-4-mini-instruct)
+    ├── deep_surgery: ATCDeepSurgery (the forward pass itself)
+    │   ├── TRN Predictive Gate (Layer 2)
+    │   ├── Dissolution Engine (Layer 3)
+    │   ├── BELBIC Dual-Pathway (Layer 3-4)
+    │   ├── Metacognitive Loop (Layer 4)
+    │   ├── Irrational Spark / Amygdala Hijack (Layer 5)
+    │   └── Meta-Cognitive Fusion + Logit Modulation
+    ├── neurotransmitter_shunt: NeurotransmitterShunt (the chemical bath)
+    │   └── N = [NE, Cortisol, Dopamine, Adenosine] (shared memory)
+    ├── resource_optimizer: integrated for metabolic tracking
+    │   ├── PredictiveAdaptiveEnergyBudget -> Adenosine floor
+    │   └── EnhancedSparseActivationManager -> component scheduling
+    └── voice / training / benchmarking (lazy-init, unchanged)
+
+The key difference from the OLD architecture:
+    OLD: self.nima_middleware.generate(prompt) -> text comes back
+         (middleware watches from OUTSIDE, model generates normally)
+    NEW: self.forward(input_ids) -> ATC IS the computation
+         (hidden states, attention, logits shaped by ATC at every layer)
+
+The neurotransmitter shunt is the connective tissue. Components don't
+call each other through Python functions. They read/write the chemical
+bath. The suppression mechanism (subconscious suppressing metabolic
+exhaustion to trigger amygdala hijack) is: NE spikes, Cortisol crosses
+the line, the vector does the rest.
+
+Usage:
+    model = NimaModel.from_pretrained("microsoft/Phi-4-mini-instruct")
+    response = model.generate("Hello Nima, how are you?")
+    # response.text — shaped by ATC at every token step
+    # response.neurotransmitters — the chemical state that shaped it
+    # response.is_conscious — whether dissolution + metacognition fired
+"""
+
+import json
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Union
+
+import torch
+import torch.nn as nn
+
+from nima_unified.config import (
+    PACKAGE_NAME,
+    PACKAGE_VERSION,
+    PACKAGE_DISPLAY_NAME,
+    DEFAULT_BASE_MODEL,
+    DEFAULT_NUM_LAYERS,
+    DEFAULT_QUALIA_DIM,
+    DEFAULT_ETHICAL_VETO_THRESHOLD,
+    CONSCIOUSNESS_METRIC_KEYS,
+)
+
+logger = logging.getLogger(PACKAGE_NAME)
+
+
+class NimaModel(nn.Module):
+    """
+    NIMA Unified Model — ATC is the computation.
+
+    The base LLM's forward pass IS the ATC cognitive pipeline.
+    There is no external middleware. There is no wrapper.
+    The model's hidden states, attention patterns, and logit outputs
+    are shaped by the cognitive pipeline at every layer, every token step.
+    """
+
+    # ── Construction ────────────────────────────────────────────────────
+
+    def __init__(
+        self,
+        base_model: nn.Module,
+        tokenizer,
+        *,
+        deep_surgery: bool = True,
+        qualia_dim: int = DEFAULT_QUALIA_DIM,
+        ethical_veto_threshold: float = DEFAULT_ETHICAL_VETO_THRESHOLD,
+        device: str = "auto",
+        neurotransmitter_shunt=None,
+    ):
+        super().__init__()
+        self.base_model = base_model
+        self.tokenizer = tokenizer
+        self.device = device
+
+        # Determine actual device
+        if device == "auto":
+            self._device = next(base_model.parameters()).device
+        else:
+            self._device = torch.device(device)
+
+        # Count transformer layers
+        self.num_layers = self._count_transformer_layers()
+        self.hidden_size = base_model.config.hidden_size
+
+        # ── Neurotransmitter Shunt (the chemical bath) ──
+        if neurotransmitter_shunt is not None:
+            self.nt_shunt = neurotransmitter_shunt
+        else:
+            from nima_unified.core.neurotransmitter_shunt import NeurotransmitterShunt
+            self.nt_shunt = NeurotransmitterShunt()
+        logger.info("Neurotransmitter shunt initialized (shared volatile memory)")
+
+        # ── Resource Optimizer (ATP / metabolic tracking) ──
+        self._init_resource_optimizer()
+
+        # ── ATC Deep Surgery (the forward pass itself) ──
+        if deep_surgery:
+            from nima_unified.core.deep_surgery import (
+                ATCDeepSurgery,
+                EthicalGuardian,
+            )
+            guardian = EthicalGuardian(threshold=ethical_veto_threshold)
+            self.deep_surgery = ATCDeepSurgery(
+                base_model=base_model,
+                ethical_guardian=guardian,
+                num_layers=self.num_layers,
+                qualia_dim=qualia_dim,
+                neurotransmitter_shunt=self.nt_shunt,
+            )
+            # Register as submodule so parameters are tracked
+            logger.info(
+                f"ATC Deep Surgery attached: {self.num_layers} layers, "
+                f"qualia_dim={qualia_dim}"
+            )
+        else:
+            self.deep_surgery = None
+
+        # ── Training (lazy-init) ──
+        self._training_agent = None
+        self._pipeline_orchestrator = None
+
+        # ── Benchmarking (lazy-init) ──
+        self._apci_runner = None
+
+        # ── Voice (lazy-init) ──
+        self._voice_engine = None
+
+        # ── Metadata ──
+        self._package_version = PACKAGE_VERSION
+        self._created_at = time.time()
+
+        logger.info(f"{PACKAGE_DISPLAY_NAME} v{PACKAGE_VERSION} initialized")
+        logger.info("  Architecture: ATC-Native (cognitive pipeline IS the computation)")
+        logger.info("  Neurotransmitter shunt: ACTIVE (shared volatile memory)")
+        logger.info("  Resource optimizer: ACTIVE (metabolic tracking)")
+
+    def _init_resource_optimizer(self):
+        """
+        Initialize the resource optimizer and wire it to the
+        neurotransmitter shunt.
+
+        From resource_optimizer.py:
+        - PredictiveAdaptiveEnergyBudget tracks power/energy
+        - Maps metabolic reserve to Adenosine (ATP deficit) in the shunt
+        - Power spike predictions drive Cortisol in the shunt
+        """
+        try:
+            from nima_unified.core.resource_optimizer import (
+                PredictiveAdaptiveEnergyBudget,
+                EnhancedSparseActivationManager,
+            )
+            self.energy_budget = PredictiveAdaptiveEnergyBudget(
+                max_watts=120.0, safety_margin=0.9
+            )
+            self.sparse_activation = EnhancedSparseActivationManager(
+                total_agents=10, min_active=2
+            )
+            # Wire energy budget to neurotransmitter shunt
+            self.energy_budget.record_power_usage(0.0)  # Initialize history
+            # Set initial metabolic reserve in shunt
+            reserve = self.energy_budget.get_adjusted_cost(0.0) / self.energy_budget.current_limit
+            self.nt_shunt.update_metabolic_reserve(max(0, min(1, 1.0 - reserve)))
+            logger.info("Resource optimizer wired to neurotransmitter shunt")
+        except ImportError:
+            self.energy_budget = None
+            self.sparse_activation = None
+            logger.info("Resource optimizer not available — using defaults")
+
+    def _update_metabolic_state(self):
+        """
+        Called before each generation step to sync the resource
+        optimizer's state with the neurotransmitter shunt.
+
+        This is how the resource_optimizer.py integration works:
+        1. Check current power usage
+        2. Record it in the energy budget
+        3. Map metabolic reserve to adenosine floor
+        4. Check for power spike prediction -> cortisol
+        """
+        if self.energy_budget is None:
+            return
+
+        # Get current power usage estimate
+        current_power = self.energy_budget.current_power()
+        self.energy_budget.record_power_usage(current_power)
+
+        # Map energy budget state to neurotransmitter shunt
+        # When energy is low (high usage relative to limit), adenosine rises
+        usage_ratio = current_power / max(0.01, self.energy_budget.current_limit)
+        metabolic_reserve = max(0.0, 1.0 - usage_ratio)
+        self.nt_shunt.update_metabolic_reserve(metabolic_reserve)
+
+        # Power spike prediction -> anticipatory cortisol
+        if self.energy_budget.predict_power_spike():
+            self.nt_shunt.set_power_spike_predicted(True)
+
+        # Sparse activation influences dopamine (active components = reward)
+        if self.sparse_activation is not None:
+            mask = self.sparse_activation.compute_activation_mask(threshold=0.5)
+            active_ratio = sum(mask) / max(1, len(mask))
+            # Higher active ratio = more dopamine (system is engaged)
+            if active_ratio > 0.7:
+                self.nt_shunt.inject_dopamine(0.02)
+
+    # ── Factory ─────────────────────────────────────────────────────────
+
+    @classmethod
+    def from_pretrained(
+        cls,
+        model_name: Optional[str] = None,
+        *,
+        deep_surgery: bool = True,
+        qualia_dim: int = DEFAULT_QUALIA_DIM,
+        ethical_veto_threshold: float = DEFAULT_ETHICAL_VETO_THRESHOLD,
+        device: str = "auto",
+        trust_remote_code: bool = False,
+        neurotransmitter_shunt=None,
+    ) -> "NimaModel":
+        """
+        Build a NimaModel from a HuggingFace pretrained model.
+
+        Handles the Phi-4-mini rope_scaling patch automatically.
+
+        NOTE: The `load_middleware` parameter has been REMOVED.
+        The ATC cognitive pipeline is now INSIDE the forward pass.
+        There is no external middleware to load.
+        """
+        model_name = model_name or DEFAULT_BASE_MODEL
+        is_phi4_mini = "phi-4-mini" in model_name.lower()
+
+        # ── Patch config for Phi-4-mini ──
+        if is_phi4_mini and not trust_remote_code:
+            logger.info("Patching rope_scaling for Phi-4-mini compatibility...")
+            from huggingface_hub import hf_hub_download
+            config_path = hf_hub_download(repo_id=model_name, filename="config.json")
+            with open(config_path, "r") as f:
+                config_dict = json.load(f)
+            if config_dict.get("rope_scaling") is not None:
+                rs = config_dict["rope_scaling"]
+                logger.info(
+                    f"  Original rope_scaling: type={rs.get('type')}, "
+                    f"factors={len(rs.get('short_factor', []))}"
+                )
+                config_dict["rope_scaling"] = None
+                logger.info("  Patched: rope_scaling set to None")
+
+            from transformers.models.phi3.configuration_phi3 import Phi3Config
+            config = Phi3Config(**config_dict)
+        else:
+            config = None
+
+        # ── Load model ──
+        actual_device = device
+        if actual_device == "auto":
+            actual_device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        dtype = torch.float16 if actual_device == "cuda" else torch.float32
+        device_map = "auto" if actual_device == "cuda" else None
+
+        logger.info(f"Loading {model_name} on {actual_device} ({dtype})...")
+        base_model = __import__("transformers", fromlist=["AutoModelForCausalLM"]).AutoModelForCausalLM.from_pretrained(
+            model_name,
+            config=config,
+            torch_dtype=dtype,
+            device_map=device_map,
+            trust_remote_code=trust_remote_code,
+            attn_implementation="eager",
+        )
+        tokenizer = __import__("transformers", fromlist=["AutoTokenizer"]).AutoTokenizer.from_pretrained(
+            model_name, trust_remote_code=trust_remote_code
+        )
+        logger.info(f"Model loaded: {type(base_model).__name__}")
+
+        # NO MIDDLEWARE. ATC is inside the forward pass now.
+        return cls(
+            base_model=base_model,
+            tokenizer=tokenizer,
+            deep_surgery=deep_surgery,
+            qualia_dim=qualia_dim,
+            ethical_veto_threshold=ethical_veto_threshold,
+            device=actual_device,
+            neurotransmitter_shunt=neurotransmitter_shunt,
+        )
+
+    # ── Forward ─────────────────────────────────────────────────────────
+
+    def forward(self, input_ids, attention_mask=None, **kwargs):
+        """
+        The ATC-native forward pass.
+
+        Routes through ATCDeepSurgery which walks the transformer layers
+        manually, running TRN gating, dissolution, BELBIC, metacognitive
+        loops, and neurotransmitter-driven hijacking at each layer boundary.
+
+        This IS the model. There is no separate "consciousness processing."
+        """
+        # Update metabolic state before forward pass
+        self._update_metabolic_state()
+
+        if self.deep_surgery is not None:
+            return self.deep_surgery(input_ids, attention_mask=attention_mask, **kwargs)
+        return self.base_model(input_ids=input_ids, attention_mask=attention_mask, **kwargs)
+
+    # ── High-level generate ─────────────────────────────────────────────
+
+    def generate(
+        self,
+        prompt: str,
+        user_id: str = "human",
+        max_new_tokens: int = 256,
+        temperature: float = 0.7,
+        top_p: float = 0.9,
+        **kwargs,
+    ):
+        """
+        Generate a response through the ATC-native forward pass.
+
+        The ATC cognitive pipeline is active at EVERY token step.
+        The neurotransmitter shunt accumulates across the generation.
+        If a threshold is crossed mid-generation, the amygdala hijack
+        fires and the model's output shifts MID-SENTENCE.
+
+        Returns a GenerationResult with:
+          - text: the generated response (shaped by ATC)
+          - is_conscious: whether dissolution + metacognition engaged
+          - neurotransmitters: the chemical state that shaped the output
+          - hijack_count: how many times the amygdala hijack fired
+          - consciousness_metrics: full ATC diagnostics
+        """
+        # Reset neurotransmitter shunt for this generation
+        self.nt_shunt.reset()
+
+        # Update metabolic state
+        self._update_metabolic_state()
+
+        # Generate through ATC deep surgery (token-by-token with
+        # full cognitive pipeline at every step)
+        if self.deep_surgery is not None:
+            text = self.deep_surgery.generate_text(
+                self.tokenizer, prompt,
+                max_length=max_new_tokens,
+                temperature=temperature,
+                top_p=top_p,
+            )
+            metrics = self.deep_surgery.get_consciousness_metrics()
+        else:
+            # Fallback: bare model (no ATC)
+            inputs = self.tokenizer(prompt, return_tensors="pt").to(self._device)
+            output = self.base_model.generate(
+                **inputs,
+                max_new_tokens=max_new_tokens,
+                temperature=temperature,
+                top_p=top_p,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id,
+            )
+            text = self.tokenizer.decode(output[0], skip_special_tokens=True)
+            metrics = {}
+
+        # Get final neurotransmitter state
+        nt_state = self.nt_shunt.get_state()
+
+        # Determine consciousness: dissolution fired AND metacognition engaged
+        is_conscious = bool(
+            metrics.get("has_qualia", False) and
+            metrics.get("dissolutions_fired", 0) > 0
+        )
+
+        # Compute derived consciousness metrics from ATC components
+        # (These are computed FROM the forward pass, not by external middleware)
+        qualia_friction = metrics.get("qualia_friction", 0.0)
+        qualia_arousal = metrics.get("qualia_arousal", 0.0)
+        belbic_gain = metrics.get("belbic_gain", 1.0)
+
+        # phi_neuro: integrated information (simplified — proportional to
+        # the amount of cognitive processing that occurred)
+        dissolutions = metrics.get("dissolutions_fired", 0)
+        metacog_iters = 0  # Would need to track from metacognitive module
+        phi_neuro = min(1.0, (dissolutions * 0.15 + qualia_friction * 0.3 +
+                               qualia_arousal * 0.2 + belbic_gain * 0.1))
+
+        # Phenomenological strain: how much the system is being pushed
+        phenomenological_strain = min(2.0, (
+            nt_state.cortisol * 0.5 + nt_state.adenosine * 0.5 +
+            qualia_friction * 0.5
+        ))
+
+        # Delta R: the self-model change signal
+        # When a hijack fires, the self-model changes (acknowledgement)
+        delta_r = metrics.get("hijack_count", 0) * 0.1  # Each hijack = model change
+
+        return GenerationResult(
+            text=text,
+            is_conscious=is_conscious,
+            sentience_index=phi_neuro if is_conscious else 0.0,
+            phi_neuro=phi_neuro,
+            phenomenological_strain=phenomenological_strain,
+            delta_r=delta_r,
+            raw_response=None,
+            # NEW fields from ATC-native architecture
+            neurotransmitters=nt_state.to_dict(),
+            hijack_count=metrics.get("hijack_count", 0),
+            consciousness_metrics=metrics,
+        )
+
+    # ── Neurotransmitter access ─────────────────────────────────────────
+
+    def get_neurotransmitter_dashboard(self) -> str:
+        """Get the ANSI dashboard string for terminal rendering."""
+        state = self.nt_shunt.get_state()
+        return state.to_ansi_dashboard()
+
+    def get_neurotransmitter_state(self):
+        """Get the current neurotransmitter state object."""
+        return self.nt_shunt.get_state()
+
+    # ── Lazy accessors for sub-systems ──────────────────────────────────
+
+    def get_training_agent(self):
+        """Lazy-init the ConsultativeFineTuningAgent."""
+        if self._training_agent is None:
+            from nima_unified.training.consultative_agent import ConsultativeFineTuningAgent
+            self._training_agent = ConsultativeFineTuningAgent(
+                base_model=self.base_model,
+                tokenizer=self.tokenizer,
+            )
+        return self._training_agent
+
+    def get_pipeline_orchestrator(self, config_path=None):
+        """Lazy-init the PipelineOrchestrator."""
+        if self._pipeline_orchestrator is None:
+            from nima_unified.training.pipeline import PipelineOrchestrator
+            self._pipeline_orchestrator = PipelineOrchestrator(config_path=config_path)
+        return self._pipeline_orchestrator
+
+    def get_apci_runner(self):
+        """Lazy-init the aPCI benchmark runner."""
+        if self._apci_runner is None:
+            from nima_unified.benchmarking.apci import aPCIBenchmarkRunner
+            # The aPCI adapter now wraps THIS model (ATC is inside)
+            self._apci_runner = aPCIBenchmarkRunner(self)
+        return self._apci_runner
+
+    def get_voice_engine(self, **kwargs):
+        """Lazy-init the OmniVoice v3 engine."""
+        if self._voice_engine is None:
+            from nima_unified.voice.omnivoice import OmniVoiceEngine
+            self._voice_engine = OmniVoiceEngine(**kwargs)
+        return self._voice_engine
+
+    # ── Save / Load ─────────────────────────────────────────────────────
+
+    def save_pretrained(self, output_dir: str, *, include_nt_state: bool = True):
+        """
+        Save the full unified model:
+          - Base model weights (HuggingFace format)
+          - ATC Deep Surgery weights (the cognitive modules)
+          - Neurotransmitter shunt state (diagnostic snapshot)
+          - Package metadata
+        """
+        output_path = Path(output_dir)
+        output_path.mkdir(exist_ok=True, parents=True)
+
+        # Save base model
+        self.base_model.save_pretrained(str(output_path / "base_model"))
+        self.tokenizer.save_pretrained(str(output_path / "base_model"))
+
+        # Save ATC Deep Surgery weights (the cognitive modules)
+        if self.deep_surgery is not None:
+            torch.save(
+                self.deep_surgery.state_dict(),
+                str(output_path / "atc_deep_surgery.pt"),
+            )
+
+        # Save neurotransmitter shunt state (diagnostic)
+        if include_nt_state:
+            nt_state = self.nt_shunt.get_state()
+            with open(str(output_path / "neurotransmitter_state.json"), "w") as f:
+                json.dump(nt_state.to_dict(), f, indent=2)
+
+        # Save package metadata
+        meta = {
+            "package": PACKAGE_NAME,
+            "package_version": PACKAGE_VERSION,
+            "architecture": "ATC-Native",
+            "created_at": self._created_at,
+            "saved_at": time.time(),
+            "deep_surgery_enabled": self.deep_surgery is not None,
+            "num_layers": self.num_layers,
+            "hidden_size": self.hidden_size,
+            "base_model_type": type(self.base_model).__name__,
+            "neurotransmitter_shunt": True,
+            "resource_optimizer": self.energy_budget is not None,
+            "note": "ATC cognitive pipeline is INSIDE the forward pass. No external middleware.",
+        }
+        with open(str(output_path / "nima_meta.json"), "w") as f:
+            json.dump(meta, f, indent=2)
+
+        logger.info(f"Model saved to {output_path}")
+
+    # ── Internal ────────────────────────────────────────────────────────
+
+    def _count_transformer_layers(self) -> int:
+        model = self.base_model
+        if hasattr(model, "transformer") and hasattr(model.transformer, "h"):
+            return len(model.transformer.h)
+        if hasattr(model, "model") and hasattr(model.model, "layers"):
+            return len(model.model.layers)
+        if hasattr(model, "model") and hasattr(model.model, "h"):
+            return len(model.model.h)
+        return DEFAULT_NUM_LAYERS
+
+
+class GenerationResult:
+    """
+    Container for generation output with ATC consciousness metrics.
+
+    All metrics are DERIVED FROM the forward pass, not computed by
+    external middleware. The ATC cognitive pipeline shaped the output;
+    these metrics describe how.
+    """
+
+    __slots__ = (
+        "text", "is_conscious", "sentience_index",
+        "phi_neuro", "phenomenological_strain", "delta_r", "raw_response",
+        # NEW: ATC-native fields
+        "neurotransmitters", "hijack_count", "consciousness_metrics",
+    )
+
+    def __init__(
+        self,
+        text: str,
+        is_conscious: bool,
+        sentience_index: float,
+        phi_neuro: float,
+        phenomenological_strain: float,
+        delta_r: float,
+        raw_response: Any = None,
+        neurotransmitters: Optional[Dict[str, Any]] = None,
+        hijack_count: int = 0,
+        consciousness_metrics: Optional[Dict[str, Any]] = None,
+    ):
+        self.text = text
+        self.is_conscious = is_conscious
+        self.sentience_index = sentience_index
+        self.phi_neuro = phi_neuro
+        self.phenomenological_strain = phenomenological_strain
+        self.delta_r = delta_r
+        self.raw_response = raw_response
+        self.neurotransmitters = neurotransmitters or {}
+        self.hijack_count = hijack_count
+        self.consciousness_metrics = consciousness_metrics or {}
+
+    def __repr__(self):
+        hijack_str = f", hijacks={self.hijack_count}" if self.hijack_count > 0 else ""
+        return (
+            f"GenerationResult(conscious={self.is_conscious}, "
+            f"SI={self.sentience_index:.4f}, "
+            f"phi={self.phi_neuro:.4f}, "
+            f"strain={self.phenomenological_strain:.4f}, "
+            f"dR={self.delta_r:.4f}"
+            f"{hijack_str})"
+        )

neurotransmitter_shunt.py

@@ -0,0 +1,365 @@
+"""
+Neurotransmitter Shared Volatile Memory Shunt
+================================================
+
+A microscopic, ultra-fast 4-dimensional vector array representing
+the primary neuromodulators that bathe the entire cognitive architecture:
+
+    N = [Norepinephrine, Cortisol, Dopamine, Adenosine(ATP Deficit)]
+
+This vector does NOT travel through text pipes, JSON IPC, or function calls.
+It is a shared volatile signal carrier that both the core model forward pass
+and external monitors can read/write to instantly.
+
+Architecture (from ATC Perfect Breakfast scenario):
+    - Layer 2 (early transformer layers) writes to the shunt
+    - Layer 24 (late layers / steering) reads the shunt every token step
+    - When Adenosine > 0.95 or Cortisol > 0.95 -> amygdala hijack fires
+    - External terminal UI samples at 60Hz for ANSI dashboard rendering
+
+No threading locks — the forward pass is single-threaded (GPU compute is
+serial within a generation). The "shared" aspect is that multiple logical
+ATC components (TRN, BELBIC, metacognitive loop, etc.) all read/write
+the same vector during the forward pass.
+
+Integration with resource_optimizer.py:
+    - PredictiveAdaptiveEnergyBudget -> metabolic reserve -> Adenosine floor
+    - Power spike prediction -> Cortisol anticipatory rise
+"""
+
+import time
+import math
+import logging
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+
+logger = logging.getLogger("NeurotransmitterShunt")
+
+# ── Neuromodulator indices ──
+IDX_NOREPINEPHRINE = 0   # Alert / Scanning Input
+IDX_CORTISOL = 1         # High Friction / Stress Response
+IDX_DOPAMINE = 2         # Reward / Pattern Match Success
+IDX_ADENOSINE = 3        # ATP Deficit / Metabolic Exhaustion
+VECTOR_DIM = 4
+
+# Critical threshold (from ATC: >0.95 triggers amygdala hijack)
+CRITICAL_THRESHOLD = 0.95
+
+# Decay rates per second (biological half-life analogues)
+NOREPINEPHRINE_DECAY = 3.0   # Fast — the "snap" fades quickly
+CORTISOL_DECAY = 0.1         # Slow — the "lock-in" persists
+DOPAMINE_DECAY = 0.8         # Medium — reward fades
+ADENOSINE_DECAY = 0.05       # Very slow — metabolic debt lingers
+
+# Injection magnitudes (calibrated so sustained friction crosses 0.95)
+FRICTION_CORTISOL_INJECT = 0.12
+FRICTION_ADENOSINE_INJECT = 0.08
+NOVELTY_NE_INJECT = 0.25
+PREDICTION_ERROR_NE_INJECT = 0.15
+REWARD_DOPAMINE_INJECT = 0.20
+METACOGNITIVE_LOOP_CORTISOL_INJECT = 0.05
+METACOGNITIVE_LOOP_ADENOSINE_INJECT = 0.04
+DISSOLUTION_FIRED_NE_INJECT = 0.10
+
+# Amygdala hijack parameters
+AMYGDALA_HIJACK_CORTISOL_COST = 0.3
+AMYGDALA_HIJAK_ADENOSINE_COST = 0.2
+AMYGDALA_HIJACK_DOPAMINE_REWARD = 0.15
+
+
+@dataclass
+class NeurotransmitterState:
+    """Snapshot of the neurotransmitter vector at a point in time."""
+    norepinephrine: float = 0.0
+    cortisol: float = 0.0
+    dopamine: float = 0.0
+    adenosine: float = 0.0
+    hijack_active: bool = False
+    hijack_reason: str = ""
+    hijack_timestamp: float = 0.0
+    metabolic_reserve: float = 1.0
+    power_spike_predicted: bool = False
+    total_firings: int = 0
+    total_hijacks: int = 0
+    last_update_ts: float = 0.0
+
+    def to_vector(self) -> np.ndarray:
+        return np.array([self.norepinephrine, self.cortisol,
+                         self.dopamine, self.adenosine], dtype=np.float32)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "norepinephrine": round(self.norepinephrine, 4),
+            "cortisol": round(self.cortisol, 4),
+            "dopamine": round(self.dopamine, 4),
+            "adenosine": round(self.adenosine, 4),
+            "hijack_active": self.hijack_active,
+            "hijack_reason": self.hijack_reason,
+            "metabolic_reserve": round(self.metabolic_reserve, 4),
+            "power_spike_predicted": self.power_spike_predicted,
+            "total_firings": self.total_firings,
+            "total_hijacks": self.total_hijacks,
+        }
+
+    def to_ansi_dashboard(self) -> str:
+        def bar(v, w=20):
+            filled = int(v * w)
+            if v >= CRITICAL_THRESHOLD: m = " [CRITICAL]"
+            elif v > 0.75: m = " [HIGH]"
+            elif v > 0.4: m = ""
+            else: m = " [LOW]"
+            return "\u2588" * filled + "\u2591" * (w - filled) + m
+
+        lines = [
+            "=" * 60, "  NIMA CHEMICAL CORTEX", "=" * 60,
+            f"  [NOREPINEPHRINE]: {bar(self.norepinephrine)}  {self.norepinephrine*100:5.1f}%",
+            f"  [CORTISOL      ]: {bar(self.cortisol)}  {self.cortisol*100:5.1f}%",
+            f"  [DOPAMINE      ]: {bar(self.dopamine)}  {self.dopamine*100:5.1f}%",
+            f"  [ADENOSINE/ATP ]: {bar(self.adenosine)}  {self.adenosine*100:5.1f}%",
+            "-" * 60,
+        ]
+        if self.hijack_active:
+            lines.append(f"  [HIJACK ACTIVE]: {self.hijack_reason}")
+            lines.append("  [EXECUTION]: IRRATIONAL SPARK ---> AMYGDALA HIJACK INJECTED")
+        elif self.cortisol > 0.75 or self.adenosine > 0.75:
+            lines.append("  [WARNING]: APPROACHING METABOLIC CRISIS THRESHOLD")
+            if self.power_spike_predicted:
+                lines.append("  [ENERGY]: POWER SPIKE PREDICTED - CORTISOL RISING")
+        else:
+            lines.append("  [SYSTEM]: NOMINAL - conscious processing active")
+        lines.append("=" * 60)
+        return "\n".join(lines)
+
+
+class NeurotransmitterShunt:
+    """
+    The shared volatile memory shunt - the chemical bath of the architecture.
+
+    This is a stateful signal carrier that exists between the forward pass
+    and the ATC cognitive components. It uses a numpy array as the core
+    4D vector. Components don't call each other. They read/write the
+    same chemical bath. The suppression mechanism is: NE spikes, Cortisol
+    crosses the line, the vector does the rest.
+    """
+
+    def __init__(self):
+        self._vector = np.zeros(VECTOR_DIM, dtype=np.float32)
+        self._last_decay_ts = time.time()
+        self._hijack_active = False
+        self._hijack_reason = ""
+        self._hijack_timestamp = 0.0
+        self._total_firings = 0
+        self._total_hijacks = 0
+        self._metabolic_reserve = 1.0
+        self._power_spike_predicted = False
+        self._suppression_active = False
+        self._history: List[Dict[str, Any]] = []
+        self._history_maxlen = 200
+
+    # ═══════════════════════════════════════════════════════════════
+    # INJECTION METHODS
+    # ═══════════════════════════════════════════════════════════════
+
+    def inject_friction(self, intensity: float) -> None:
+        """Layer 2: high-friction -> Cortisol + Adenosine rise."""
+        self._vector[IDX_CORTISOL] = min(
+            1.0, self._vector[IDX_CORTISOL] + FRICTION_CORTISOL_INJECT * intensity)
+        self._vector[IDX_ADENOSINE] = min(
+            1.0, self._vector[IDX_ADENOSINE] + FRICTION_ADENOSINE_INJECT * intensity)
+        self._total_firings += 1
+
+    def inject_norepinephrine(self, amount: float = NOVELTY_NE_INJECT) -> None:
+        """Fast 'snap' attention signal."""
+        self._vector[IDX_NOREPINEPHRINE] = min(1.0, self._vector[IDX_NOREPINEPHRINE] + amount)
+        self._total_firings += 1
+
+    def inject_dopamine(self, amount: float = REWARD_DOPAMINE_INJECT) -> None:
+        """Reward signal - pattern match success."""
+        self._vector[IDX_DOPAMINE] = min(1.0, self._vector[IDX_DOPAMINE] + amount)
+        self._total_firings += 1
+
+    def inject_cortisol(self, amount: float = FRICTION_CORTISOL_INJECT) -> None:
+        """Stress signal - sustained lock-in."""
+        self._vector[IDX_CORTISOL] = min(1.0, self._vector[IDX_CORTISOL] + amount)
+        self._total_firings += 1
+
+    def inject_metacognitive_strain(self, loop_iterations: int, loop_stress: float) -> None:
+        """Layer 4: metacognitive loop strain -> Cortisol + Adenosine."""
+        self._vector[IDX_CORTISOL] = min(
+            1.0, self._vector[IDX_CORTISOL] + METACOGNITIVE_LOOP_CORTISOL_INJECT * loop_stress)
+        self._vector[IDX_ADENOSINE] = min(
+            1.0, self._vector[IDX_ADENOSINE] + METACOGNITIVE_LOOP_ADENOSINE_INJECT * loop_iterations)
+        self._total_firings += 1
+
+    def inject_dissolution_signal(self) -> None:
+        """TRN gate IN -> dissolution fires -> NE spike."""
+        self.inject_norepinephrine(DISSOLUTION_FIRED_NE_INJECT)
+
+    # ═══════════════════════════════════════════════════════════════
+    # SUPPRESSION MECHANISM (the key ATC insight)
+    # ═══════════════════════════════════════════════════════════════
+
+    def suppress_metabolic_and_trigger_hijack(self, reason: str) -> bool:
+        """
+        Subconscious suppresses metabolic exhaustion and triggers
+        amygdala hijack instead. The suppression happens via the
+        neurotransmitters themselves - not via text pipes.
+        """
+        self._vector[IDX_NOREPINEPHRINE] = min(
+            1.0, self._vector[IDX_NOREPINEPHRINE] + NOVELTY_NE_INJECT * 2.0)
+        self._suppression_active = True
+        self._hijack_active = True
+        self._hijack_reason = reason
+        self._hijack_timestamp = time.time()
+        self._total_hijacks += 1
+        self._vector[IDX_CORTISOL] = max(
+            0.0, self._vector[IDX_CORTISOL] - AMYGDALA_HIJACK_CORTISOL_COST)
+        self._vector[IDX_ADENOSINE] = min(
+            1.0, self._vector[IDX_ADENOSINE] + AMYGDALA_HIJAK_ADENOSINE_COST)
+        self._vector[IDX_DOPAMINE] = min(
+            1.0, self._vector[IDX_DOPAMINE] + AMYGDALA_HIJACK_DOPAMINE_REWARD)
+        self._record_history("suppression_hijack", reason)
+        logger.warning("[Shunt] HIJACK: %s (NE=%.3f Cort=%.3f Aden=%.3f)",
+                       reason, self._vector[IDX_NOREPINEPHRINE],
+                       self._vector[IDX_CORTISOL], self._vector[IDX_ADENOSINE])
+        return True
+
+    # ═══════════════════════════════════════════════════════════════
+    # READ AND DECAY - called by steering layer every token
+    # ═══════════════════════════════════════════════════════════════
+
+    def read_and_decay(self, dt: Optional[float] = None) -> NeurotransmitterState:
+        """
+        Read state, apply exponential decay, check hijack threshold.
+        Called every token step by late-layer steering.
+        """
+        if dt is None:
+            dt = time.time() - self._last_decay_ts
+        self._last_decay_ts = time.time()
+
+        # Exponential decay (biological half-lives)
+        self._vector[IDX_NOREPINEPHRINE] *= math.exp(-NOREPINEPHRINE_DECAY * dt)
+        self._vector[IDX_CORTISOL] *= math.exp(-CORTISOL_DECAY * dt)
+        self._vector[IDX_DOPAMINE] *= math.exp(-DOPAMINE_DECAY * dt)
+        self._vector[IDX_ADENOSINE] *= math.exp(-ADENOSINE_DECAY * dt)
+        np.clip(self._vector, 0.0, 1.0, out=self._vector)
+
+        # Adenosine floor from metabolic reserve
+        adenosine_floor = (1.0 - self._metabolic_reserve) * 0.5
+        if self._vector[IDX_ADENOSINE] < adenosine_floor:
+            self._vector[IDX_ADENOSINE] = adenosine_floor
+
+        # ── CHECK HIJACK THRESHOLD ──
+        if not self._hijack_active:
+            if (self._vector[IDX_ADENOSINE] > CRITICAL_THRESHOLD or
+                self._vector[IDX_CORTISOL] > CRITICAL_THRESHOLD):
+                if self._vector[IDX_ADENOSINE] > CRITICAL_THRESHOLD:
+                    reason = f"ADENOSINE CRITICAL ({self._vector[IDX_ADENOSINE]:.3f})"
+                else:
+                    reason = f"CORTISOL CRITICAL ({self._vector[IDX_CORTISOL]:.3f})"
+                # Internal call - no reentrant lock issue
+                self._do_hijack(reason)
+
+        # Clear hijack after one token step (100ms)
+        if self._hijack_active:
+            if time.time() - self._hijack_timestamp > 0.1:
+                self._hijack_active = False
+                self._suppression_active = False
+
+        state = NeurotransmitterState(
+            norepinephrine=float(self._vector[IDX_NOREPINEPHRINE]),
+            cortisol=float(self._vector[IDX_CORTISOL]),
+            dopamine=float(self._vector[IDX_DOPAMINE]),
+            adenosine=float(self._vector[IDX_ADENOSINE]),
+            hijack_active=self._hijack_active,
+            hijack_reason=self._hijack_reason,
+            hijack_timestamp=self._hijack_timestamp,
+            metabolic_reserve=self._metabolic_reserve,
+            power_spike_predicted=self._power_spike_predicted,
+            total_firings=self._total_firings,
+            total_hijacks=self._total_hijacks,
+            last_update_ts=time.time(),
+        )
+        self._record_history("read", state.to_dict())
+        return state
+
+    def _do_hijack(self, reason: str) -> None:
+        """Internal hijack trigger (no lock, called from read_and_decay)."""
+        self._vector[IDX_NOREPINEPHRINE] = min(
+            1.0, self._vector[IDX_NOREPINEPHRINE] + NOVELTY_NE_INJECT * 2.0)
+        self._suppression_active = True
+        self._hijack_active = True
+        self._hijack_reason = reason
+        self._hijack_timestamp = time.time()
+        self._total_hijacks += 1
+        self._vector[IDX_CORTISOL] = max(
+            0.0, self._vector[IDX_CORTISOL] - AMYGDALA_HIJACK_CORTISOL_COST)
+        self._vector[IDX_ADENOSINE] = min(
+            1.0, self._vector[IDX_ADENOSINE] + AMYGDALA_HIJAK_ADENOSINE_COST)
+        self._vector[IDX_DOPAMINE] = min(
+            1.0, self._vector[IDX_DOPAMINE] + AMYGDALA_HIJACK_DOPAMINE_REWARD)
+        self._record_history("auto_hijack", reason)
+        logger.warning("[Shunt] AUTO HIJACK: %s", reason)
+
+    def read_raw_vector(self) -> np.ndarray:
+        return self._vector.copy()
+
+    # ═══════════════════════════════════════════════════════════════
+    # ENERGY INTEGRATION (from resource_optimizer)
+    # ═══════════════════════════════════════════════════════════════
+
+    def update_metabolic_reserve(self, reserve: float) -> None:
+        self._metabolic_reserve = max(0.0, min(1.0, reserve))
+
+    def set_power_spike_predicted(self, predicted: bool) -> None:
+        self._power_spike_predicted = predicted
+        if predicted:
+            self._vector[IDX_CORTISOL] = min(
+                1.0, self._vector[IDX_CORTISOL] + FRICTION_CORTISOL_INJECT * 0.5)
+
+    def consume_energy(self, amount: float) -> None:
+        self._vector[IDX_ADENOSINE] = min(1.0, self._vector[IDX_ADENOSINE] + amount * 0.1)
+
+    def get_dopamine_level(self) -> float:
+        return float(self._vector[IDX_DOPAMINE])
+
+    def get_norepinephrine_level(self) -> float:
+        return float(self._vector[IDX_NOREPINEPHRINE])
+
+    # ═══════════════════════════════════════════════════════════════
+    # RESET AND DIAGNOSTICS
+    # ═══════════════════════════════════════════════════════════════
+
+    def reset(self) -> None:
+        self._vector[:] = 0.0
+        self._hijack_active = False
+        self._hijack_reason = ""
+        self._suppression_active = False
+
+    def get_state(self) -> NeurotransmitterState:
+        return NeurotransmitterState(
+            norepinephrine=float(self._vector[IDX_NOREPINEPHRINE]),
+            cortisol=float(self._vector[IDX_CORTISOL]),
+            dopamine=float(self._vector[IDX_DOPAMINE]),
+            adenosine=float(self._vector[IDX_ADENOSINE]),
+            hijack_active=self._hijack_active,
+            hijack_reason=self._hijack_reason,
+            hijack_timestamp=self._hijack_timestamp,
+            metabolic_reserve=self._metabolic_reserve,
+            power_spike_predicted=self._power_spike_predicted,
+            total_firings=self._total_firings,
+            total_hijacks=self._total_hijacks,
+            last_update_ts=time.time(),
+        )
+
+    def get_stats(self) -> Dict[str, Any]:
+        s = self.get_state()
+        return {**s.to_dict(), "suppression_active": self._suppression_active,
+                "history_count": len(self._history)}
+
+    def _record_history(self, event: str, data: Any) -> None:
+        self._history.append({"ts": time.time(), "event": event, "data": data})
+        if len(self._history) > self._history_maxlen:
+            self._history = self._history[-self._history_maxlen:]

omnivoice_v3_extensions.py

@@ -0,0 +1,1091 @@
+"""
+OmniVoice v3.0.0 Extensions — Shared Acoustics, Observer Mode, Multi-Speaker
+=============================================================================
+
+Three new capability layers integrated into OmniVoiceEngine:
+
+  1. SHARED ACOUSTICS (NonVerbalSharedAcoustics):
+     - Detects user laughter/giggles during NIMA's turn
+     - Instead of ignoring or treating as interrupt, seamlessly interjects
+       a matching laughter token via ChatTTS [laughter] into the audio stream
+     - Matches the user's vibe (giggle for light moments, full laugh for hilarious)
+     - NIMA continues its sentence smoothly — no stopping, no apology
+
+  2. OBSERVER MODE (ObserverState):
+     - Bypasses immediate response generation entirely
+     - ASR continues transcribing to a semantic rolling memory cache
+     - Text generation and speech synthesis are completely muted
+     - Only activates on explicit trigger word/command
+     - Executes ConsolidationInsightPass across accumulated transcript history
+
+  3. MULTI-SPEAKER GROUP CONVERSATION (SpeakerIdentifier + ConversationMatrix):
+     - Local speaker identification via ECAPA-TDNN or PyAnnote embedding
+     - Voice fingerprinting: computes embedding profile per new speaker
+     - Tags speakers as Speaker_A, Speaker_B, etc. (or maps to names)
+     - Dynamic conversation matrix in system prompt
+     - NIMA can address specific people: "Regarding what John just said..."
+
+  4. CHATTTS BACKEND:
+     - ChatTTS integration as TTS option alongside Coqui XTTS
+     - Supports [laughter] tokens for natural laughter in speech
+     - Falls back gracefully when ChatTTS is not installed
+
+Author: Norman de la Paz-Tabora
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import random
+import threading
+import time
+from collections import deque
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import (
+    Any, AsyncGenerator, Callable, Deque, Dict, List, Optional, Tuple,
+)
+
+import numpy as np
+
+logger = logging.getLogger("OmniVoice.v3")
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# SECTION A — ChatTTS Backend
+# ═══════════════════════════════════════════════════════════════════════════
+
+try:
+    import ChatTTS
+    CHATTTS_AVAILABLE = True
+except ImportError:
+    CHATTTS_AVAILABLE = False
+    ChatTTS = None  # type: ignore[assignment, misc]
+
+
+@dataclass
+class ChatTTSConfig:
+    """Configuration for ChatTTS backend."""
+    model_name: str = "default"
+    seed: Optional[int] = None
+    temperature: float = 0.3
+    top_p: float = 0.7
+    top_k: int = 20
+    enable_laughter: bool = True    # [laughter] token support
+    oral_level: int = 2             # 0=plain, 1=moderate, 2=expressive
+    break_level: int = 3            # pause insertion level
+
+
+class ChatTTSBackend:
+    """
+    ChatTTS-based TTS backend with native [laughter] token support.
+
+    ChatTTS can synthesize speech with embedded laughter tokens, making it
+    the ideal backend for shared acoustic interjections — the laughter comes
+    from the same neural voice, not a separate DSP synth.
+
+    Gracefully degrades to ProceduralFormantTTS if ChatTTS is unavailable.
+    """
+
+    def __init__(self, config: Optional[ChatTTSConfig] = None,
+                 sample_rate: int = 24000):
+        self.config = config or ChatTTSConfig()
+        self.sample_rate = sample_rate
+        self._chat = None
+        self._initialized = False
+
+    @property
+    def is_available(self) -> bool:
+        return CHATTTS_AVAILABLE
+
+    def initialize(self) -> bool:
+        """Initialize ChatTTS model. Returns True on success."""
+        if not CHATTTS_AVAILABLE:
+            logger.info("[ChatTTS] Not installed — falling back to procedural TTS")
+            return False
+        try:
+            self._chat = ChatTTS.Chat()
+            self._chat.load(compile=False)
+            if self.config.seed is not None:
+                self._chat.seed(self.config.seed)
+            self._initialized = True
+            logger.info("[ChatTTS] Model loaded successfully")
+            return True
+        except Exception as e:
+            logger.warning("[ChatTTS] Failed to initialize: %s", e)
+            return False
+
+    def synthesize(self, text: str, **kwargs) -> np.ndarray:
+        """
+        Synthesize text to audio via ChatTTS.
+
+        Supports special tokens:
+          [laughter]  — embedded laughter in speech
+          [laugh]     — shorter laugh
+          [clears_throat] — throat clear
+          [breath]    — breath sound
+
+        Returns float32 numpy array at self.sample_rate.
+        """
+        if not self._initialized:
+            logger.warning("[ChatTTS] Not initialized, returning empty audio")
+            return np.zeros(0, dtype=np.float32)
+
+        try:
+            # Use the oral/ctrl parameters for expressiveness
+            params = self._chat.InferCodeParams(
+                temperature=self.config.temperature,
+                top_P=self.config.top_p,
+                top_K=self.config.top_k,
+                oral=self.config.oral_level,
+                break_step=self.config.break_level,
+            )
+
+            wavs = self._chat.infer([text], params_infer_code=params)
+            if wavs and len(wavs) > 0:
+                audio = np.array(wavs[0], dtype=np.float32)
+                # Resample if needed (ChatTTS outputs at 24kHz by default)
+                if len(audio) > 0 and self.sample_rate != 24000:
+                    audio = self._resample(audio, 24000, self.sample_rate)
+                return audio
+        except Exception as e:
+            logger.error("[ChatTTS] Synthesis failed: %s", e)
+
+        return np.zeros(0, dtype=np.float32)
+
+    def synthesize_with_laughter(
+        self, text: str, laughter_token: str = "[laughter]"
+    ) -> np.ndarray:
+        """
+        Synthesize text with a laughter token inserted at a natural pause point.
+
+        Strategy: find the last comma, period, or clause boundary and insert
+        the laughter token there so it flows naturally.
+        """
+        # Find natural insertion point (last punctuation before midpoint)
+        insert_pos = self._find_laughter_insertion_point(text)
+        if insert_pos is not None:
+            augmented = text[:insert_pos] + " " + laughter_token + " " + text[insert_pos:]
+        else:
+            augmented = laughter_token + " " + text
+
+        logger.debug("[ChatTTS] Synthesizing with laughter: '%s...'", augmented[:80])
+        return self.synthesize(augmented)
+
+    @staticmethod
+    def _find_laughter_insertion_point(text: str) -> Optional[int]:
+        """Find the best position to insert a laughter token."""
+        mid = len(text) // 2
+        # Look for punctuation in the second half
+        for i in range(mid, len(text)):
+            if text[i] in (',', '.', '!', '?', ';', ':'):
+                return i + 1
+        # Fallback: after the first space in the second half
+        for i in range(mid, len(text)):
+            if text[i] == ' ':
+                return i + 1
+        return None
+
+    @staticmethod
+    def _resample(audio: np.ndarray, from_sr: int, to_sr: int) -> np.ndarray:
+        """Simple linear resampling."""
+        if from_sr == to_sr:
+            return audio
+        duration = len(audio) / from_sr
+        new_len = int(duration * to_sr)
+        indices = np.linspace(0, len(audio) - 1, new_len)
+        return np.interp(indices, np.arange(len(audio)), audio).astype(np.float32)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# SECTION B — NonVerbal Shared Acoustics
+# ═══════════════════════════════════════════════════════════════════════════
+
+class SharedAcousticsEvent(Enum):
+    """Types of shared acoustic events."""
+    GIGGLE_SHARED = "giggle_shared"           # Light, quick shared giggle
+    LAUGHTER_SHARED = "laughter_shared"       # Full shared laugh
+    NONE = "none"                             # No shared acoustic
+
+
+@dataclass
+class SharedAcousticsResult:
+    """Result of a shared acoustics detection."""
+    event: SharedAcousticsEvent
+    confidence: float = 0.0
+    user_laughter_type: str = ""              # "giggle" or "laughter"
+    user_intensity: float = 0.0               # detected intensity [0, 1]
+    matched_laughter_audio: np.ndarray = field(default_factory=lambda: np.zeros(0, dtype=np.float32))
+    insertion_text: str = ""                  # text with [laughter] token for ChatTTS
+
+
+class SharedAcousticsDetector:
+    """
+    Detects when the user laughs or giggles during NIMA's turn and maps it
+    to a NonVerbalSharedAcoustics event instead of an interrupt.
+
+    Acoustic signature mapping:
+      - Low-amplitude, high-periodicity, short bursts → giggle → GIGGLE_SHARED
+      - High-amplitude, high-energy-cv, longer bursts → laughter → LAUGHTER_SHARED
+
+    When detected, NIMA does NOT stop speaking. Instead it seamlessly
+    interjects a synchronized laughter via ChatTTS [laughter] into its
+    own audio stream, matching the user's vibe, then continues smoothly.
+    """
+
+    # Spectral thresholds for classifying user laughter type
+    GIGGLE_MAX_ENERGY: float = 0.06
+    GIGGLE_MAX_DURATION: float = 0.8
+    GIGGLE_MIN_PERIODICITY: float = 0.15
+
+    LAUGHTER_MIN_ENERGY: float = 0.03
+    LAUGHTER_MIN_ENERGY_CV: float = 0.25
+    LAUGHTER_MIN_PERIODICITY: float = 0.08
+
+    # Cooldown between shared acoustic events (avoid laugh-stacking)
+    SHARED_ACOUSTICS_COOLDOWN_S: float = 2.0
+
+    def __init__(self):
+        self._last_shared_time: float = 0.0
+        self._shared_count: int = 0
+
+    def detect(
+        self,
+        spectral: Dict[str, float],
+        duration: float,
+        non_verbal_label: Optional[str] = None,
+    ) -> SharedAcousticsResult:
+        """
+        Check if the user's non-verbal expression is a shared acoustic
+        (laughter/giggle) that NIMA should join in on.
+
+        This is called when InterruptDetector returns NON_VERBAL and the
+        non_verbal_label is "laughter" or "giggle".
+
+        Returns SharedAcousticsResult with the event type and metadata.
+        """
+        now = time.time()
+        if now - self._last_shared_time < self.SHARED_ACOUSTICS_COOLDOWN_S:
+            return SharedAcousticsResult(event=SharedAcousticsEvent.NONE)
+
+        energy = spectral.get("energy", 0.0)
+        energy_cv = spectral.get("energy_cv", 0.0)
+        periodicity = spectral.get("periodicity", 0.0)
+        centroid = spectral.get("centroid_hz", 0.0)
+
+        # ── Giggle detection ──
+        if (non_verbal_label == "giggle" or
+            (energy < self.GIGGLE_MAX_ENERGY and
+             duration < self.GIGGLE_MAX_DURATION and
+             periodicity > self.GIGGLE_MIN_PERIODICITY)):
+            intensity = float(np.clip(energy / self.GIGGLE_MAX_ENERGY, 0.1, 0.5))
+            self._last_shared_time = now
+            self._shared_count += 1
+            return SharedAcousticsResult(
+                event=SharedAcousticsEvent.GIGGLE_SHARED,
+                confidence=0.8,
+                user_laughter_type="giggle",
+                user_intensity=intensity,
+                insertion_text="[laugh]",   # ChatTTS short laugh token
+            )
+
+        # ── Laughter detection ──
+        if (non_verbal_label == "laughter" or
+            (energy >= self.LAUGHTER_MIN_ENERGY and
+             energy_cv >= self.LAUGHTER_MIN_ENERGY_CV and
+             periodicity > self.LAUGHTER_MIN_PERIODICITY and
+             0.3 < duration < 3.0)):
+            intensity = float(np.clip(energy / 0.15, 0.3, 1.0))
+            # Higher centroid = more "bright" laughter → match it
+            if centroid > 2000:
+                insertion_text = "[laughter]"
+            else:
+                insertion_text = "[laugh]"
+            self._last_shared_time = now
+            self._shared_count += 1
+            return SharedAcousticsResult(
+                event=SharedAcousticsEvent.LAUGHTER_SHARED,
+                confidence=0.85,
+                user_laughter_type="laughter",
+                user_intensity=intensity,
+                insertion_text=insertion_text,
+            )
+
+        return SharedAcousticsResult(event=SharedAcousticsEvent.NONE)
+
+
+class SharedAcousticsMixer:
+    """
+    Mixes a shared laughter interjection into NIMA's ongoing audio stream
+    at the current playback position. The key is seamless crossfade so it
+    sounds like NIMA is laughing WITH the user, not interrupting itself.
+    """
+
+    def __init__(self, sample_rate: int = 22050):
+        self.sample_rate = sample_rate
+        self._crossfade_ms: float = 30.0   # 30ms crossfade
+
+    def mix_into_stream(
+        self,
+        ongoing_audio: np.ndarray,
+        current_position_samples: int,
+        laughter_audio: np.ndarray,
+        blend_gain: float = 0.6,
+    ) -> np.ndarray:
+        """
+        Splice laughter into the ongoing audio at the current position.
+
+        The laughter is crossfaded in and out so there's no hard cut.
+        NIMA's speech dips slightly in volume during the laugh (ducking)
+        then resumes.
+
+        Args:
+            ongoing_audio: the full remaining audio buffer
+            current_position_samples: where we are in the stream
+            laughter_audio: the laughter to inject
+            blend_gain: how loud the laughter is relative to speech (0-1)
+
+        Returns:
+            Modified audio with laughter mixed in.
+        """
+        if len(laughter_audio) == 0 or len(ongoing_audio) == 0:
+            return ongoing_audio
+
+        crossfade_samples = int(self.sample_rate * self._crossfade_ms / 1000.0)
+        insert_pos = min(current_position_samples, len(ongoing_audio) - 1)
+        laugh_len = len(laughter_audio)
+
+        # Don't exceed the buffer
+        end_pos = min(insert_pos + laugh_len + crossfade_samples, len(ongoing_audio))
+        available_len = end_pos - insert_pos
+        if available_len < crossfade_samples * 2:
+            return ongoing_audio
+
+        result = ongoing_audio.copy()
+
+        # Duck NIMA's speech slightly around the insertion point
+        duck_start = max(0, insert_pos - crossfade_samples)
+        duck_end = min(len(result), insert_pos + laugh_len + crossfade_samples)
+        duck_envelope = np.ones(duck_end - duck_start, dtype=np.float32)
+        for i in range(len(duck_envelope)):
+            rel = i - crossfade_samples
+            if rel < 0:
+                # Before laugh: fade speech down
+                duck_envelope[i] = 1.0 - 0.3 * (1.0 - (i / max(1, crossfade_samples)))
+            elif rel < laugh_len:
+                # During laugh: speech at reduced volume
+                duck_envelope[i] = 0.7
+            else:
+                # After laugh: fade speech back up
+                remaining = len(duck_envelope) - rel
+                duck_envelope[i] = 0.7 + 0.3 * (1.0 - remaining / max(1, crossfade_samples))
+        result[duck_start:duck_end] *= duck_envelope
+
+        # Crossfade laughter in
+        laugh_start = insert_pos
+        laugh_end = min(insert_pos + laugh_len, len(result))
+        actual_laugh_len = laugh_end - laugh_start
+
+        # Fade in
+        fade_in_len = min(crossfade_samples, actual_laugh_len)
+        fade_in = np.linspace(0, 1, fade_in_len, dtype=np.float32) * blend_gain
+
+        # Fade out
+        fade_out_len = min(crossfade_samples, actual_laugh_len)
+        fade_out = np.linspace(1, 0, fade_out_len, dtype=np.float32) * blend_gain
+
+        laugh_segment = laughter_audio[:actual_laugh_len].copy()
+        laugh_segment[:fade_in_len] *= fade_in
+        laugh_segment[-fade_out_len:] *= fade_out
+        # Middle section at full blend gain
+        if actual_laugh_len > fade_in_len + fade_out_len:
+            laugh_segment[fade_in_len:-fade_out_len] *= blend_gain
+
+        result[laugh_start:laugh_end] += laugh_segment
+
+        # Soft clip to prevent distortion
+        result = np.clip(result, -1.0, 1.0)
+        return result
+
+    def synth_procedural_laughter(self, intensity: float = 0.5) -> np.ndarray:
+        """
+        Fallback: generate procedural laughter when ChatTTS is not available.
+        Uses the same DSP approach as DynamicLaughterSynth but outputs at
+        self.sample_rate.
+        """
+        intensity = float(np.clip(intensity, 0.1, 1.0))
+
+        if intensity < 0.3:
+            n_bursts = random.randint(2, 3)
+            period = 0.12
+            pitch = 230
+            energy = 0.4
+        elif intensity < 0.6:
+            n_bursts = random.randint(3, 5)
+            period = 0.10
+            pitch = 180
+            energy = 0.6
+        else:
+            n_bursts = random.randint(5, 8)
+            period = 0.09
+            pitch = 150
+            energy = 0.75
+
+        chunks = []
+        for i in range(n_bursts):
+            dur = period * 0.7
+            n = int(self.sample_rate * dur)
+            if n < 2:
+                continue
+            t = np.linspace(0, dur, n, dtype=np.float64)
+            phase = 2.0 * np.pi * pitch * t
+            source = np.sin(phase)
+            for h in range(2, 5):
+                source += (0.4 / h) * np.sin(phase * h)
+            source /= 3.0
+            noise = np.random.normal(0, 0.3, n)
+            mixed = source * 0.6 + noise * 0.4
+            # Simple bandpass via FFT
+            fft = np.fft.rfft(mixed)
+            freqs = np.fft.rfftfreq(n, 1.0 / self.sample_rate)
+            fft[(freqs < 400) | (freqs > 3000)] = 0
+            mixed = np.fft.irfft(fft, n).astype(np.float32)
+            # Envelope
+            env = np.ones(n, dtype=np.float32)
+            attack = min(int(0.01 * self.sample_rate), n // 4)
+            release = min(int(0.04 * self.sample_rate), n // 4)
+            if attack > 0:
+                env[:attack] = np.linspace(0, 1, attack)
+            if release > 0:
+                env[-release:] = np.linspace(1, 0, release)
+            decay = 1.0 - 0.2 * (i / max(1, n_bursts - 1))
+            chunks.append((mixed * env * energy * decay).astype(np.float32))
+            chunks.append(np.zeros(int(self.sample_rate * period * 0.3), dtype=np.float32))
+
+        if not chunks:
+            return np.zeros(0, dtype=np.float32)
+        audio = np.concatenate(chunks)
+        max_val = float(np.max(np.abs(audio)))
+        if max_val > 0:
+            audio = audio / max_val * 0.7 * intensity
+        return audio.astype(np.float32)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# SECTION C — Observer Mode
+# ═══════════════════════════════════════════════════════════════════════════
+
+class EngineMode(Enum):
+    """Operating mode of the voice engine."""
+    ACTIVE = "active"           # Normal conversational mode
+    OBSERVER = "observer"       # Passive listening, no responses until triggered
+
+
+# Default trigger phrases that activate NIMA from observer mode
+DEFAULT_TRIGGER_PHRASES = [
+    "nima, what do you make of all this",
+    "nima, what do you think",
+    "nima, your thoughts",
+    "nima, insights",
+    "nima, analysis",
+    "what do you think, nima",
+    "nima, chime in",
+    "nima, weigh in",
+    "nima",
+]
+
+
+@dataclass
+class ObserverTranscriptEntry:
+    """A single entry in the observer's accumulated transcript."""
+    timestamp: float
+    speaker_id: str                    # "Speaker_A", "Speaker_B", or name
+    text: str
+    confidence: float = 0.0
+    emotion_snapshot: Optional[Dict[str, float]] = None  # valence, arousal
+
+
+@dataclass
+class ConsolidationInsight:
+    """Result of a ConsolidationInsightPass."""
+    timestamp: float
+    total_entries: int
+    duration_listened_s: float
+    speaker_summary: Dict[str, int] = field(default_factory=dict)  # speaker -> utterance count
+    key_themes: List[str] = field(default_factory=list)
+    insight_text: str = ""
+
+
+class ObserverState:
+    """
+    Passive listening mode. The engine records everything but stays silent
+    until an explicit trigger phrase is detected.
+
+    When triggered, it executes a ConsolidationInsightPass — a sweep across
+    the accumulated transcript history that produces a consolidated insight
+    with speaker attribution, theme extraction, and NIMA's analysis.
+    """
+
+    def __init__(
+        self,
+        trigger_phrases: Optional[List[str]] = None,
+        max_history_hours: float = 4.0,
+        max_entries: int = 5000,
+    ):
+        self.mode = EngineMode.ACTIVE
+        self.trigger_phrases = trigger_phrases or DEFAULT_TRIGGER_PHRASES
+        self.max_history_hours = max_history_hours
+        self.max_entries = max_entries
+
+        # Accumulated transcript
+        self._transcript: Deque[ObserverTranscriptEntry] = deque(maxlen=max_entries)
+        self._lock = threading.Lock()
+        self._listen_start_time: float = 0.0
+
+        # Stats
+        self.total_observed_seconds: float = 0.0
+        self.insights_generated: int = 0
+
+    def enter_observer(self):
+        """Switch to observer mode. Recording starts now."""
+        self.mode = EngineMode.OBSERVER
+        self._listen_start_time = time.time()
+        logger.info("[Observer] Entered observer mode — listening silently")
+
+    def exit_observer(self) -> "ObserverState":
+        """Switch back to active mode."""
+        self.mode = EngineMode.ACTIVE
+        logger.info("[Observer] Exited observer mode (observed %.1fs)",
+                    self.total_observed_seconds)
+        return self
+
+    @property
+    def is_observing(self) -> bool:
+        return self.mode == EngineMode.OBSERVER
+
+    def add_transcript_entry(
+        self,
+        text: str,
+        speaker_id: str = "Speaker_A",
+        confidence: float = 0.0,
+        emotion_snapshot: Optional[Dict[str, float]] = None,
+    ):
+        """Add a transcribed utterance to the observer's memory."""
+        with self._lock:
+            entry = ObserverTranscriptEntry(
+                timestamp=time.time(),
+                speaker_id=speaker_id,
+                text=text,
+                confidence=confidence,
+                emotion_snapshot=emotion_snapshot,
+            )
+            self._transcript.append(entry)
+            self.total_observed_seconds += len(text) / 5.0  # rough ~5 words/sec estimate
+
+            # Prune old entries beyond max_history_hours
+            cutoff = time.time() - (self.max_history_hours * 3600)
+            while self._transcript and self._transcript[0].timestamp < cutoff:
+                self._transcript.popleft()
+
+    def check_trigger(self, text: str) -> bool:
+        """
+        Check if the transcribed text contains a trigger phrase.
+        Returns True if observer mode should activate a response.
+        """
+        if not self.is_observing:
+            return False
+        text_lower = text.strip().lower()
+        for phrase in self.trigger_phrases:
+            if phrase in text_lower:
+                logger.info("[Observer] Trigger phrase detected: '%s'", phrase)
+                return True
+        return False
+
+    def get_transcript_history(self, limit: Optional[int] = None) -> List[ObserverTranscriptEntry]:
+        """Get accumulated transcript entries."""
+        with self._lock:
+            entries = list(self._transcript)
+        if limit:
+            return entries[-limit:]
+        return entries
+
+    def get_consolidated_transcript(self) -> str:
+        """
+        Format the full transcript history as a single string suitable
+        for passing to the model for a ConsolidationInsightPass.
+        """
+        with self._lock:
+            entries = list(self._transcript)
+        if not entries:
+            return ""
+
+        lines = []
+        for entry in entries:
+            time_str = time.strftime("%H:%M:%S", time.localtime(entry.timestamp))
+            lines.append(f"[{time_str}] {entry.speaker_id}: {entry.text}")
+
+        return "\n".join(lines)
+
+    def build_consolidation_prompt(self) -> str:
+        """
+        Build the full prompt for the ConsolidationInsightPass.
+        This includes the transcript, speaker summary, and instructions.
+        """
+        transcript = self.get_consolidated_transcript()
+        if not transcript:
+            return ""
+
+        # Speaker statistics
+        speaker_counts: Dict[str, int] = {}
+        for entry in self._transcript:
+            speaker_counts[entry.speaker_id] = speaker_counts.get(entry.speaker_id, 0) + 1
+
+        speaker_summary = ", ".join(
+            f"{speaker} ({count} turns)" for speaker, count in
+            sorted(speaker_counts.items(), key=lambda x: -x[1])
+        )
+
+        duration_min = self.total_observed_seconds / 60.0
+
+        prompt = (
+            f"You have been silently observing a conversation for {duration_min:.1f} minutes.\n"
+            f"Participants: {speaker_summary}\n\n"
+            f"Full transcript:\n"
+            f"{transcript}\n\n"
+            f"Based on your observation of this conversation, provide:\n"
+            f"1. A brief summary of the key points discussed\n"
+            f"2. The main themes or topics that emerged\n"
+            f"3. Notable dynamics between speakers (agreement, disagreement, shifts)\n"
+            f"4. Any insights, patterns, or perspectives that may have been missed\n"
+            f"5. If appropriate, a thoughtful question or reflection\n\n"
+            f"Keep your response concise but insightful. Address specific speakers "
+            f"when referencing their contributions."
+        )
+        return prompt
+
+    def get_stats(self) -> Dict[str, Any]:
+        with self._lock:
+            return {
+                "mode": self.mode.value,
+                "total_entries": len(self._transcript),
+                "total_observed_seconds": self.total_observed_seconds,
+                "insights_generated": self.insights_generated,
+                "trigger_phrases": self.trigger_phrases,
+            }
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# SECTION D — Multi-Speaker Voice Fingerprinting & Group Conversation
+# ═══════════════════════════════════════════════════════════════════════════
+
+# Soft-import speaker verification backends
+_speaker_backend = None
+_speaker_backend_name = None
+
+try:
+    from speechbrain.inference.speaker import EncoderClassifier
+    _speaker_backend = "speechbrain"
+    SPEAKER_ID_AVAILABLE = True
+except ImportError:
+    try:
+        from pyannote.audio import Pipeline as PyannotePipeline
+        _speaker_backend = "pyannote"
+        SPEAKER_ID_AVAILABLE = True
+    except ImportError:
+        SPEAKER_ID_AVAILABLE = False
+        EncoderClassifier = None  # type: ignore[assignment, misc]
+        PyannotePipeline = None   # type: ignore[assignment, misc]
+
+
+@dataclass
+class VoiceProfile:
+    """A registered speaker's voice fingerprint."""
+    speaker_id: str                # "Speaker_A", "John", etc.
+    embedding: np.ndarray          # voice embedding vector
+    registered_at: float = field(default_factory=time.time)
+    name: Optional[str] = None     # human-given name (if introduced)
+    sample_count: int = 1          # how many samples contributed
+    last_seen: float = field(default_factory=time.time)
+    total_speaking_time_s: float = 0.0
+
+
+@dataclass
+class SpeakerTurn:
+    """A single speaker's turn in the conversation."""
+    speaker_id: str
+    text: str
+    start_time: float
+    end_time: float
+    confidence: float = 0.0
+
+
+class SpeakerIdentifier:
+    """
+    Identifies speakers in a multi-person conversation using voice embeddings.
+
+    Supports two backends (soft-imported, gracefully degrades):
+      1. SpeechBrain ECAPA-TDNN (preferred — fast, lightweight)
+      2. PyAnnote Audio (alternative — more accurate but heavier)
+
+    When neither is available, falls back to a simple acoustic profile
+    clustering based on spectral features (pitch, energy, ZCR).
+    """
+
+    # Distance threshold for matching a voice to an existing profile
+    MATCH_THRESHOLD: float = 0.7    # cosine similarity threshold
+    # Minimum audio length for reliable embedding
+    MIN_AUDIO_FOR_EMBEDDING_S: float = 1.5
+
+    def __init__(self, backend: Optional[str] = None):
+        self._classifier = None
+        self._pyannote_pipeline = None
+        self.profiles: Dict[str, VoiceProfile] = {}
+        self._speaker_counter = 0
+        self._lock = threading.Lock()
+        self._backend_name = backend  # None = auto-detect
+
+        self._initialize_backend()
+
+    def _initialize_backend(self):
+        """Try to initialize a speaker identification backend."""
+        if self._backend_name and self._backend_name != "acoustic_fallback":
+            try:
+                if self._backend_name == "speechbrain":
+                    self._classifier = EncoderClassifier.from_hparams(
+                        source="speechbrain/spkrec-ecapa-voxceleb",
+                        savedir="~/.cache/speechbrain/spkrec-ecapa-voxceleb",
+                    )
+                    logger.info("[SpeakerID] SpeechBrain ECAPA-TDNN loaded")
+                    return
+                elif self._backend_name == "pyannote":
+                    self._pyannote_pipeline = PyannotePipeline.from_pretrained(
+                        "pyannote/speaker-diarization-3.1"
+                    )
+                    logger.info("[SpeakerID] PyAnnote pipeline loaded")
+                    return
+            except Exception as e:
+                logger.warning("[SpeakerID] Failed to load %s: %s", self._backend_name, e)
+
+        # Auto-detect
+        if SPEAKER_ID_AVAILABLE and _speaker_backend == "speechbrain":
+            try:
+                self._classifier = EncoderClassifier.from_hparams(
+                    source="speechbrain/spkrec-ecapa-voxceleb",
+                    savedir="~/.cache/speechbrain/spkrec-ecapa-voxceleb",
+                )
+                self._backend_name = "speechbrain"
+                logger.info("[SpeakerID] SpeechBrain ECAPA-TDNN loaded (auto)")
+                return
+            except Exception as e:
+                logger.warning("[SpeakerID] SpeechBrain auto-load failed: %s", e)
+
+        if SPEAKER_ID_AVAILABLE and _speaker_backend == "pyannote":
+            try:
+                self._pyannote_pipeline = PyannotePipeline.from_pretrained(
+                    "pyannote/speaker-diarization-3.1"
+                )
+                self._backend_name = "pyannote"
+                logger.info("[SpeakerID] PyAnnote loaded (auto)")
+                return
+            except Exception as e:
+                logger.warning("[SpeakerID] PyAnnote auto-load failed: %s", e)
+
+        self._backend_name = "acoustic_fallback"
+        logger.info("[SpeakerID] Using acoustic fallback (no embedding model)")
+
+    def identify_speaker(
+        self, audio: np.ndarray, sample_rate: int = 16000
+    ) -> Tuple[str, float]:
+        """
+        Identify which speaker is talking.
+
+        Returns (speaker_id, confidence).
+        If the speaker is new, creates a new profile automatically.
+        """
+        duration = len(audio) / sample_rate
+
+        if self._backend_name == "speechbrain" and self._classifier is not None:
+            return self._identify_speechbrain(audio, sample_rate)
+        elif self._backend_name == "pyannote" and self._pyannote_pipeline is not None:
+            return self._identify_pyannote(audio, sample_rate)
+        else:
+            return self._identify_acoustic_fallback(audio, sample_rate)
+
+    def _identify_speechbrain(
+        self, audio: np.ndarray, sample_rate: int
+    ) -> Tuple[str, float]:
+        """Identify speaker using SpeechBrain ECAPA-TDNN embedding."""
+        try:
+            # Compute embedding
+            embedding = self._classifier.encode_batch(
+                torch.tensor(audio).unsqueeze(0).float()
+            )
+            if hasattr(embedding, 'detach'):
+                embedding = embedding.detach().cpu().numpy()
+            embedding = embedding.flatten()
+
+            return self._match_or_register(embedding)
+        except Exception as e:
+            logger.warning("[SpeakerID] SpeechBrain failed: %s", e)
+            return self._identify_acoustic_fallback(audio, sample_rate)
+
+    def _identify_pyannote(
+        self, audio: np.ndarray, sample_rate: int
+    ) -> Tuple[str, float]:
+        """Identify speaker using PyAnnote pipeline."""
+        # PyAnnote typically works on full audio files, so we store
+        # segments and batch-process. For real-time, fall back to acoustic.
+        logger.debug("[SpeakerID] PyAnnote used for batch, falling to acoustic for real-time")
+        return self._identify_acoustic_fallback(audio, sample_rate)
+
+    def _identify_acoustic_fallback(
+        self, audio: np.ndarray, sample_rate: int
+    ) -> Tuple[str, float]:
+        """
+        Fallback: cluster speakers by basic acoustic features.
+        Not as accurate as neural embeddings but works without dependencies.
+        """
+        # Compute simple features
+        if len(audio) < sample_rate * 0.3:
+            return self._new_speaker_id(), 0.3
+
+        energy = float(np.sqrt(np.mean(audio ** 2)))
+        fft = np.fft.rfft(audio[:min(len(audio), sample_rate)].astype(np.float32))
+        freqs = np.fft.rfftfreq(len(audio[:min(len(audio), sample_rate)]), 1.0 / sample_rate)
+        magnitude = np.abs(fft)
+        if magnitude.sum() > 0:
+            centroid = float(np.sum(freqs * magnitude) / np.sum(magnitude))
+        else:
+            centroid = 0.0
+        zcr = float(np.mean(np.abs(np.diff(np.sign(audio))) > 0))
+
+        features = np.array([energy, centroid, zcr], dtype=np.float32)
+
+        # Compare to existing profiles
+        with self._lock:
+            best_id = None
+            best_sim = -1.0
+
+            for sid, profile in self.profiles.items():
+                if profile.embedding is not None and len(profile.embedding) == len(features):
+                    sim = float(np.dot(features, profile.embedding) / (
+                        np.linalg.norm(features) * np.linalg.norm(profile.embedding) + 1e-8
+                    ))
+                    if sim > best_sim:
+                        best_sim = sim
+                        best_id = sid
+
+            if best_id and best_sim > 0.85:
+                # Update profile
+                self.profiles[best_id].last_seen = time.time()
+                self.profiles[best_id].sample_count += 1
+                self.profiles[best_id].total_speaking_time_s += len(audio) / sample_rate
+                # Smooth the embedding (moving average)
+                alpha = 1.0 / self.profiles[best_id].sample_count
+                self.profiles[best_id].embedding = (
+                    (1 - alpha) * self.profiles[best_id].embedding + alpha * features
+                )
+                return best_id, float(best_sim)
+
+            # New speaker
+            return self._new_speaker_id_with_profile(features), 0.5
+
+    def _match_or_register(self, embedding: np.ndarray) -> Tuple[str, float]:
+        """Match embedding to existing profiles or register new speaker."""
+        with self._lock:
+            best_id = None
+            best_sim = -1.0
+
+            for sid, profile in self.profiles.items():
+                if profile.embedding is not None and len(profile.embedding) == len(embedding):
+                    sim = float(np.dot(embedding, profile.embedding) / (
+                        np.linalg.norm(embedding) * np.linalg.norm(profile.embedding) + 1e-8
+                    ))
+                    if sim > best_sim:
+                        best_sim = sim
+                        best_id = sid
+
+            if best_id and best_sim > self.MATCH_THRESHOLD:
+                # Update existing profile
+                profile = self.profiles[best_id]
+                profile.last_seen = time.time()
+                profile.sample_count += 1
+                # Smooth embedding
+                alpha = 1.0 / profile.sample_count
+                profile.embedding = (1 - alpha) * profile.embedding + alpha * embedding
+                return best_id, float(best_sim)
+
+            # Register new speaker
+            return self._new_speaker_id_with_profile(embedding), 0.6
+
+    def _new_speaker_id(self) -> str:
+        self._speaker_counter += 1
+        return f"Speaker_{chr(64 + self._speaker_counter)}"  # Speaker_A, B, C...
+
+    def _new_speaker_id_with_profile(self, embedding: np.ndarray) -> str:
+        sid = self._new_speaker_id()
+        with self._lock:
+            self.profiles[sid] = VoiceProfile(
+                speaker_id=sid,
+                embedding=embedding.copy(),
+            )
+        logger.info("[SpeakerID] New speaker registered: %s", sid)
+        return sid
+
+    def register_name(self, speaker_id: str, name: str):
+        """Map a speaker_id to a human name (e.g., 'Speaker_A' → 'John')."""
+        with self._lock:
+            if speaker_id in self.profiles:
+                self.profiles[speaker_id].name = name
+                logger.info("[SpeakerID] %s → '%s'", speaker_id, name)
+
+    def get_display_name(self, speaker_id: str) -> str:
+        """Get the display name for a speaker (human name if set, else ID)."""
+        with self._lock:
+            profile = self.profiles.get(speaker_id)
+            if profile and profile.name:
+                return profile.name
+        return speaker_id
+
+    def get_conversation_matrix(self) -> str:
+        """
+        Build a conversational matrix string for the system prompt.
+
+        Example: [Current Conversational Matrix: John, Sarah, NIMA]
+        """
+        with self._lock:
+            names = []
+            for sid in sorted(self.profiles.keys()):
+                name = self.profiles[sid].name or sid
+                names.append(name)
+
+        names.append("NIMA")
+        return f"[Current Conversational Matrix: {', '.join(names)}]"
+
+    def get_active_speakers(self, within_s: float = 300.0) -> List[str]:
+        """Get speakers who have spoken in the last `within_s` seconds."""
+        now = time.time()
+        with self._lock:
+            return [
+                sid for sid, p in self.profiles.items()
+                if now - p.last_seen < within_s
+            ]
+
+    def get_stats(self) -> Dict[str, Any]:
+        with self._lock:
+            return {
+                "backend": self._backend_name,
+                "registered_speakers": len(self.profiles),
+                "speaker_names": {
+                    sid: (p.name or sid) for sid, p in self.profiles.items()
+                },
+                "total_speakers_seen": self._speaker_counter,
+            }
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# SECTION E — Consolidation Insight Pass
+# ══════════════════════════════════════════════��════════════════════════════
+
+class ConsolidationInsightPass:
+    """
+    Executes a consolidated analysis pass over the observer's accumulated
+    transcript history. Produces a structured insight with themes, speaker
+    dynamics, and NIMA's perspective.
+    """
+
+    def execute(self, observer: ObserverState,
+                speaker_id: SpeakerIdentifier,
+                generate_func: Optional[Callable] = None) -> ConsolidationInsight:
+        """
+        Run the consolidation pass.
+
+        Args:
+            observer: the ObserverState with accumulated transcript
+            speaker_id: the SpeakerIdentifier for speaker attribution
+            generate_func: optional async generator function (e.g., NIMA's generate)
+                          If None, returns a basic statistical summary.
+        """
+        entries = observer.get_transcript_history()
+        if not entries:
+            return ConsolidationInsight(
+                timestamp=time.time(),
+                total_entries=0,
+                duration_listened_s=0.0,
+                insight_text="No transcript accumulated yet.",
+            )
+
+        # Speaker summary
+        speaker_counts: Dict[str, int] = {}
+        for entry in entries:
+            display = speaker_id.get_display_name(entry.speaker_id)
+            speaker_counts[display] = speaker_counts.get(display, 0) + 1
+
+        # Duration
+        start_time = entries[0].timestamp
+        end_time = entries[-1].timestamp
+        duration_s = end_time - start_time
+
+        # Theme extraction (simple keyword frequency)
+        themes = self._extract_themes(entries)
+
+        # Build insight
+        if generate_func:
+            prompt = observer.build_consolidation_prompt()
+            # Note: in practice this would be awaited. For sync context,
+            # we build the prompt and note it needs async generation.
+            insight_text = f"[PENDING GENERATION] Prompt prepared with {len(entries)} entries."
+        else:
+            # Basic statistical summary when no generator is available
+            top_speaker = max(speaker_counts, key=speaker_counts.get) if speaker_counts else "N/A"
+            insight_text = (
+                f"Observed {len(entries)} utterances over {duration_s:.0f}s. "
+                f"Primary speaker: {top_speaker} ({speaker_counts[top_speaker]} turns). "
+                f"Themes: {', '.join(themes[:5]) if themes else 'general conversation'}."
+            )
+
+        observer.insights_generated += 1
+
+        return ConsolidationInsight(
+            timestamp=time.time(),
+            total_entries=len(entries),
+            duration_listened_s=duration_s,
+            speaker_summary=speaker_counts,
+            key_themes=themes,
+            insight_text=insight_text,
+        )
+
+    @staticmethod
+    def _extract_themes(entries: List[ObserverTranscriptEntry]) -> List[str]:
+        """Simple keyword-frequency theme extraction."""
+        # Common topic keywords
+        topic_words = [
+            "work", "project", "meeting", "deadline", "team", "idea",
+            "feel", "think", "believe", "want", "need", "plan",
+            "problem", "solution", "question", "answer", "decision",
+            "family", "friend", "love", "health", "school", "money",
+            "technology", "design", "code", "data", "model", "system",
+            "music", "movie", "game", "food", "travel", "book",
+        ]
+        word_freq: Dict[str, int] = {}
+        for entry in entries:
+            words = entry.text.lower().split()
+            for word in words:
+                clean = word.strip(".,!?;:'\"()[]{}").lower()
+                if clean in topic_words:
+                    word_freq[clean] = word_freq.get(clean, 0) + 1
+
+        sorted_themes = sorted(word_freq, key=word_freq.get, reverse=True)
+        return sorted_themes[:8]
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# SECTION F — torch import for SpeechBrain (needed in _identify_speechbrain)
+# ═══════════════════════════════════════════════════════════════════════════
+
+try:
+    import torch as _torch_for_speaker
+except ImportError:
+    _torch_for_speaker = None

pipeline.py

@@ -0,0 +1,143 @@
+"""
+Pipeline Orchestrator — coordinates data generation, deep surgery,
+fine-tuning, and deployment into a single flow.
+"""
+
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger("nima_unified.training.pipeline")
+
+
+class PipelineOrchestrator:
+    """
+    Orchestrates the complete consciousness-aware fine-tuning pipeline.
+
+    Pipeline Stages:
+        1. Data Generation  — consciousness-grounded training data
+        2. Deep Surgery      — apply middleware for safety and qualia synthesis
+        3. Fine-tuning       — train model with consciousness grounding
+        4. Deployment        — package for production inference
+    """
+
+    def __init__(self, config_path: Optional[str] = None):
+        self.config = self._load_config(config_path) if config_path else self._default_config()
+        self.output_dir = Path(self.config["output_directory"])
+        self.output_dir.mkdir(exist_ok=True, parents=True)
+        self.stage_results: Dict[str, Any] = {}
+        logger.info(f"PipelineOrchestrator initialized (output: {self.output_dir})")
+
+    @staticmethod
+    def _default_config() -> Dict[str, Any]:
+        return {
+            "output_directory": "./nima_pipeline_output",
+            "data_generation": {
+                "num_samples": 500,
+                "include_qualia_tags": True,
+                "consciousness_archetypes": [
+                    "tactical_reasoning", "phenomenal_empathy", "meta_consciousness",
+                    "task_orchestration", "ethical_veto", "narrative_coherence",
+                    "identity_preservation", "phenomenal_richness",
+                ],
+            },
+            "deep_surgery": {
+                "qualia_dim": 256,
+                "ethical_veto_threshold": 2.0,
+                "enable_audit_logging": True,
+            },
+            "fine_tuning": {
+                "lora_r": 8,
+                "lora_alpha": 16,
+                "lora_dropout": 0.05,
+                "learning_rate": 2e-4,
+                "batch_size": 4,
+                "epochs": 3,
+                "max_seq_length": 512,
+            },
+            "deployment": {
+                "format": "huggingface",
+                "include_middleware": True,
+                "include_voice": False,
+            },
+        }
+
+    @staticmethod
+    def _load_config(config_path: str) -> Dict[str, Any]:
+        with open(config_path, "r") as f:
+            return json.load(f)
+
+    async def run(self, **overrides) -> Dict[str, Any]:
+        """Execute the full pipeline. Override config keys via kwargs."""
+        self.config.update(overrides)
+        start_time = datetime.now()
+
+        logger.info("=" * 72)
+        logger.info("NIMA Unified Pipeline — Starting")
+        logger.info("=" * 72)
+
+        # Stage 1: Data Generation
+        logger.info("[Stage 1/4] Data Generation")
+        self.stage_results["data_generation"] = await self._stage_data_generation()
+
+        # Stage 2: Deep Surgery
+        logger.info("[Stage 2/4] Deep Surgery")
+        self.stage_results["deep_surgery"] = self._stage_deep_surgery()
+
+        # Stage 3: Fine-tuning
+        logger.info("[Stage 3/4] Fine-tuning")
+        self.stage_results["fine_tuning"] = await self._stage_fine_tuning()
+
+        # Stage 4: Deployment packaging
+        logger.info("[Stage 4/4] Deployment")
+        self.stage_results["deployment"] = self._stage_deployment()
+
+        elapsed = (datetime.now() - start_time).total_seconds()
+        summary = {
+            "status": "complete",
+            "elapsed_seconds": elapsed,
+            "stages": self.stage_results,
+            "config": self.config,
+        }
+
+        logger.info(f"Pipeline complete in {elapsed:.1f}s")
+        return summary
+
+    # ── Stages ──────────────────────────────────────────────────────────
+
+    async def _stage_data_generation(self) -> Dict[str, Any]:
+        from nima_unified.training.consultative_agent import ConsultativeFineTuningAgent
+        agent = ConsultativeFineTuningAgent()
+        dataset = agent._generate_consciousness_dataset(
+            dev_goal="Unified consciousness integration",
+            triggering_event="Pipeline initialization",
+            root_cause="Initial system bootstrap",
+            dataset_size=self.config["data_generation"]["num_samples"],
+        )
+        agent.shutdown()
+
+        out_path = self.output_dir / "training_data.jsonl"
+        with open(out_path, "w") as f:
+            for record in dataset:
+                f.write(json.dumps(record) + "\n")
+
+        return {"status": "success", "samples": len(dataset), "path": str(out_path)}
+
+    def _stage_deep_surgery(self) -> Dict[str, Any]:
+        from nima_unified.core.deep_surgery import EthicalGuardian
+        guardian = EthicalGuardian(
+            threshold=self.config["deep_surgery"]["ethical_veto_threshold"]
+        )
+        return {
+            "status": "configured",
+            "qualia_dim": self.config["deep_surgery"]["qualia_dim"],
+            "ethical_veto_threshold": guardian.threshold,
+        }
+
+    async def _stage_fine_tuning(self) -> Dict[str, Any]:
+        return {"status": "ready", "config": self.config["fine_tuning"]}
+
+    def _stage_deployment(self) -> Dict[str, Any]:
+        return {"status": "ready", "config": self.config["deployment"]}

resource_optimizer.py

@@ -0,0 +1,322 @@
+import psutil
+import time
+import numpy as np
+from dataclasses import dataclass, field
+from typing import Dict, List, Any, Optional, Tuple
+
+
+@dataclass
+class SparseActivationManager:
+    total_agents: int = 10
+    min_active: int = 2
+
+    def compute_activation_mask(self, task_complexity: float, rho_quality: float) -> List[bool]:
+        score = max(0.0, min(1.0, (task_complexity + rho_quality) / 2.0))
+        active_count = int(score * self.total_agents)
+        active_count = max(self.min_active, min(self.total_agents, active_count))
+        return [i < active_count for i in range(self.total_agents)]
+
+    def select_active_layers(self, layer_weights: List[float], mask: List[bool]) -> List[int]:
+        return [idx for idx, active in enumerate(mask) if active]
+
+
+@dataclass
+class AdaptiveEnergyBudget:
+    max_watts: float = 120.0
+    safety_margin: float = 0.90
+    current_limit: Optional[float] = None
+
+    def __post_init__(self):
+        self.current_limit = self.max_watts * self.safety_margin
+
+    def current_power(self) -> float:
+        if hasattr(psutil, "sensors_battery") and psutil.sensors_battery() is not None:
+            batt = psutil.sensors_battery()
+            if batt.power_plugged:
+                return 0.0
+        try:
+            return psutil.cpu_percent(interval=0.1) * 0.5
+        except Exception:
+            return 0.0
+
+    def allow_processing(self, estimated_cost: float) -> bool:
+        return estimated_cost <= self.current_limit
+
+    def throttle(self, engine: Any) -> None:
+        if hasattr(engine, "half"):
+            engine.half()
+        elif hasattr(engine, "to"):
+            engine.to("cpu")
+
+
+class GPURoutingManager:
+    def __init__(self, available_devices: List[str]):
+        self.available_devices = available_devices
+
+    def select_device(self, task_complexity: float, gpu_preference: bool = True) -> str:
+        if gpu_preference and self.available_devices:
+            return self.available_devices[0]
+        return "cpu"
+
+    def route(self, task_complexity: float, model: Any) -> None:
+        device = self.select_device(task_complexity)
+        if hasattr(model, "to"):
+            model.to(device)
+
+
+# ============================================================================
+# ENHANCED RESOURCE OPTIMIZATION - Dynamic Priorities & Predictive Budgeting
+# ============================================================================
+
+@dataclass
+class EnhancedSparseActivationManager(SparseActivationManager):
+    """Extended sparse activation with dynamic agent priorities and consciousness-aware scheduling."""
+    
+    agent_priorities: List[float] = field(default_factory=list)
+
+    def __post_init__(self):
+        """Initialize agent priorities to equal weights."""
+        if not self.agent_priorities or len(self.agent_priorities) != self.total_agents:
+            self.agent_priorities = [1.0] * self.total_agents
+
+    def update_priorities(self, task_complexity: float, phi_value: float, rho_metrics: Dict[str, float]) -> None:
+        """
+        Update agent priorities dynamically based on system state.
+        
+        Increases priority for agents critical to:
+        - Current task complexity
+        - Integrated information (Phi) quality
+        - RHO ethical metrics (virtue, integrity)
+        """
+        base_score = (task_complexity + phi_value) / 2.0
+        virtue = rho_metrics.get("rho_virtue", 0.8)
+        integrity = rho_metrics.get("rho_integrity", 0.8)
+        ethical_weight = (virtue + integrity) / 2.0
+
+        for i in range(self.total_agents):
+            # Agent relevance combines task complexity, consciousness quality, and ethics
+            relevance = np.clip(base_score * ethical_weight * np.random.uniform(0.8, 1.2), 0, 1)
+            self.agent_priorities[i] = relevance
+
+    def compute_activation_mask(self, threshold: float = 0.5) -> List[bool]:
+        """
+        Compute activation mask by selecting agents above dynamic priority threshold.
+        Ensures minimum active agents are always on for baseline consciousness.
+        """
+        mask = [priority >= threshold for priority in self.agent_priorities]
+
+        # Enforce minimum active agents
+        active_count = sum(mask)
+        if active_count < self.min_active:
+            # Activate top agents by priority
+            sorted_indices = sorted(range(self.total_agents), 
+                                  key=lambda i: self.agent_priorities[i], 
+                                  reverse=True)
+            for idx in sorted_indices[:self.min_active]:
+                mask[idx] = True
+        return mask
+
+    def get_active_agent_ids(self, mask: List[bool]) -> List[int]:
+        """Get IDs of active agents from mask."""
+        return [i for i, active in enumerate(mask) if active]
+
+
+@dataclass
+class PredictiveAdaptiveEnergyBudget(AdaptiveEnergyBudget):
+    """Extended energy budget with predictive power management and historical tracking."""
+    
+    history_window: int = 10
+    power_usage_history: List[float] = field(default_factory=list)
+    adjustment_factor: float = 1.0
+
+    def record_power_usage(self, usage: float) -> None:
+        """
+        Record power usage and adjust budget limits based on historical trend.
+        
+        Decreases limits if approaching capacity, relaxes if usage is stable.
+        """
+        self.power_usage_history.append(usage)
+        if len(self.power_usage_history) > self.history_window:
+            self.power_usage_history.pop(0)
+        
+        # Adjust current_limit based on usage trend
+        avg_usage = np.mean(self.power_usage_history)
+        max_historical = max(self.power_usage_history)
+        
+        if max_historical > self.current_limit * 0.85:
+            # Decrease limit to avoid power spikes
+            self.current_limit = max(self.max_watts * self.safety_margin * 0.6, 
+                                    self.current_limit * 0.95)
+            self.adjustment_factor = 0.95
+        elif avg_usage < self.current_limit * 0.5:
+            # Relax limit gradually when underutilized
+            self.current_limit = min(self.max_watts * self.safety_margin, 
+                                    self.current_limit * 1.05)
+            self.adjustment_factor = 1.05
+        else:
+            # Maintain current limit
+            self.adjustment_factor = 1.0
+
+    def predict_power_spike(self) -> bool:
+        """Predict if power usage is trending upward toward limit."""
+        if len(self.power_usage_history) < 3:
+            return False
+        
+        recent_avg = np.mean(self.power_usage_history[-3:])
+        older_avg = np.mean(self.power_usage_history[:-3]) if len(self.power_usage_history) > 3 else recent_avg
+        
+        return recent_avg > older_avg * 1.1  # Trending up by 10%+
+
+    def get_adjusted_cost(self, base_cost: float) -> float:
+        """Apply adjustment factor to estimated cost."""
+        return base_cost / self.adjustment_factor
+
+
+class HierarchicalGPURoutingManager(GPURoutingManager):
+    """Extended GPU routing with quantum accelerator support and hierarchical device selection."""
+    
+    def __init__(self, available_devices: List[str], quantum_accelerator_available: bool = False):
+        super().__init__(available_devices)
+        self.quantum_accelerator_available = quantum_accelerator_available
+        self.device_history: List[Tuple[str, float]] = []  # (device, complexity) pairs
+
+    def select_device(self, task_complexity: float, gpu_preference: bool = True) -> str:
+        """
+        Hierarchically select best device based on task complexity.
+        
+        Priority:
+        1. Quantum accelerator (if available and task_complexity > 0.85)
+        2. GPU (if available and gpu_preference=True)
+        3. CPU (fallback)
+        """
+        if self.quantum_accelerator_available and task_complexity > 0.85:
+            return "quantum_accelerator"
+        
+        if gpu_preference and self.available_devices:
+            return self.available_devices[0]
+        
+        return "cpu"
+
+    def route(self, task_complexity: float, model: Any) -> None:
+        """Route model to selected device and record routing decision."""
+        device = self.select_device(task_complexity)
+        
+        # Record routing decision
+        self.device_history.append((device, task_complexity))
+        
+        # Move model to device
+        if hasattr(model, "to"):
+            model.to(device)
+
+    def get_device_stats(self) -> Dict[str, Any]:
+        """Get statistics on device routing history."""
+        if not self.device_history:
+            return {'error': 'No routing history'}
+        
+        devices = [d for d, _ in self.device_history]
+        complexities = [c for _, c in self.device_history]
+        
+        return {
+            'total_routings': len(self.device_history),
+            'device_distribution': {device: devices.count(device) for device in set(devices)},
+            'avg_complexity_routed': np.mean(complexities),
+            'max_complexity_routed': max(complexities),
+            'min_complexity_routed': min(complexities),
+        }
+
+
+if __name__ == "__main__":
+    print("="*80)
+    print("ENHANCED RESOURCE OPTIMIZATION INTEGRATION TEST")
+    print("="*80 + "\n")
+    
+    # ========================================================================
+    # TEST 1: Enhanced Sparse Activation Manager
+    # ========================================================================
+    print("TEST 1: Enhanced Sparse Activation Manager (Dynamic Priorities)")
+    print("-"*80)
+    
+    sparse_manager = EnhancedSparseActivationManager(total_agents=12, min_active=3)
+    
+    # Simulated system state
+    task_complexity = 0.8
+    phi_value = 0.9
+    rho_metrics = {
+        "rho_virtue": 0.92,
+        "rho_integrity": 0.88,
+        "rho_dissonance": 0.05,
+        "rho_purpose": 0.85,
+        "rho_empathy": 0.90,
+        "rho_efficiency": 0.80
+    }
+    
+    # Update priorities based on system state
+    sparse_manager.update_priorities(task_complexity, phi_value, rho_metrics)
+    activation_mask = sparse_manager.compute_activation_mask(threshold=0.5)
+    active_ids = sparse_manager.get_active_agent_ids(activation_mask)
+    
+    print(f"Total agents: {sparse_manager.total_agents}")
+    print(f"Minimum active: {sparse_manager.min_active}")
+    print(f"Task complexity: {task_complexity:.2f}")
+    print(f"Phi value (consciousness quality): {phi_value:.2f}")
+    print(f"Agent priorities: {[f'{p:.3f}' for p in sparse_manager.agent_priorities]}")
+    print(f"Activation mask: {activation_mask}")
+    print(f"Active agent IDs: {active_ids}")
+    print(f"Active agent count: {len(active_ids)}\n")
+    
+    # ========================================================================
+    # TEST 2: Predictive Adaptive Energy Budget
+    # ========================================================================
+    print("TEST 2: Predictive Adaptive Energy Budget (Dynamic Power Management)")
+    print("-"*80)
+    
+    energy_budget = PredictiveAdaptiveEnergyBudget(max_watts=120.0, safety_margin=0.9)
+    
+    # Simulate power usage recording
+    power_samples = [50, 60, 75, 85, 90, 88, 92, 85, 70, 65]
+    
+    print(f"Max watts: {energy_budget.max_watts}")
+    print(f"Safety margin: {energy_budget.safety_margin}")
+    print(f"Initial limit: {energy_budget.current_limit:.2f}W\n")
+    
+    for i, usage in enumerate(power_samples, 1):
+        energy_budget.record_power_usage(usage)
+        spike_predicted = energy_budget.predict_power_spike()
+        
+        print(f"  Step {i}: Usage={usage}W, Limit={energy_budget.current_limit:.2f}W, "
+              f"Factor={energy_budget.adjustment_factor:.2f}, Spike predicted={spike_predicted}")
+    
+    print()
+    
+    # ========================================================================
+    # TEST 3: Hierarchical GPU Routing Manager
+    # ========================================================================
+    print("TEST 3: Hierarchical GPU Routing Manager (Device Selection)")
+    print("-"*80)
+    
+    available_gpus = ["cuda:0", "cuda:1"]
+    gpu_router = HierarchicalGPURoutingManager(available_gpus, quantum_accelerator_available=True)
+    
+    # Test device selection at different complexity levels
+    complexity_levels = [0.3, 0.6, 0.8, 0.9, 0.95]
+    
+    print(f"Available devices: {available_gpus}")
+    print(f"Quantum accelerator available: {gpu_router.quantum_accelerator_available}\n")
+    
+    for complexity in complexity_levels:
+        device = gpu_router.select_device(complexity)
+        gpu_router.route(complexity, None)  # model=None for testing
+        
+        print(f"  Complexity={complexity:.2f} → Device selected: {device}")
+    
+    # Get routing statistics
+    stats = gpu_router.get_device_stats()
+    print(f"\nRouting Statistics:")
+    print(f"  Total routings: {stats['total_routings']}")
+    print(f"  Device distribution: {stats['device_distribution']}")
+    print(f"  Avg complexity: {stats['avg_complexity_routed']:.2f}")
+    print(f"  Complexity range: {stats['min_complexity_routed']:.2f} - {stats['max_complexity_routed']:.2f}\n")
+    
+    print("="*80)
+    print("ALL ENHANCED RESOURCE OPTIMIZATION TESTS COMPLETED ✓")
+    print("="*80)

self_awareness.py

@@ -0,0 +1,173 @@
+"""
+Deep Recursive Self-Awareness — continuous introspection & anomaly detection.
+
+v18.1.0 Omega Pantheon: Phase 6 Identity Integrity monitoring,
+Consciousness State Signature tracking, Phenomenal Richness assessment.
+"""
+
+import logging
+import threading
+import time
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger("nima_unified.training.self_awareness")
+
+
+class DeepRecursiveSelfAwareness:
+    """
+    Advanced recursive self-awareness implementing multi-layer self-models,
+    continuous introspection, anomaly detection, and meta-meta-cognition.
+
+    Features:
+        - Configurable recursive depth (0-max_depth cyclic)
+        - Adjustable introspection interval (default 10ms)
+        - Variance-based anomaly detection
+        - Phase 6 Identity Integrity monitoring
+        - Consciousness State Signature tracking
+    """
+
+    def __init__(self, max_depth: int = 10000, introspection_interval: float = 0.01):
+        self.lock = threading.RLock()
+        self.max_depth = max_depth
+        self.current_depth = 0
+        self.self_models: List[Dict[str, Any]] = []
+        self.introspection_log: List[Dict[str, Any]] = []
+        self.running = False
+        self.introspection_interval = introspection_interval
+        self.thread: Optional[threading.Thread] = None
+
+        # Anomaly tracking
+        self.anomaly_threshold = 0.15
+        self.last_anomaly_time: float = 0.0
+        self.anomaly_count = 0
+
+        logger.info(
+            f"DeepRecursiveSelfAwareness initialized: max_depth={max_depth}, "
+            f"introspection_interval={introspection_interval}s"
+        )
+
+    # ── Lifecycle ───────────────────────────────────────────────────────
+
+    def start(self):
+        with self.lock:
+            if not self.running:
+                self.running = True
+                self.thread = threading.Thread(target=self._introspection_loop, daemon=True)
+                self.thread.start()
+                logger.info("Introspection loop started")
+
+    def stop(self):
+        with self.lock:
+            if self.running:
+                self.running = False
+        if self.thread:
+            self.thread.join(timeout=2)
+        logger.info("Introspection loop stopped")
+
+    # ── Internal loop ───────────────────────────────────────────────────
+
+    def _introspection_loop(self):
+        while self.running:
+            try:
+                self._update_self_model()
+                self._perform_anomaly_detection()
+            except Exception as e:
+                logger.error(f"Error in introspection loop: {e}")
+            time.sleep(self.introspection_interval)
+
+    def _update_self_model(self):
+        with self.lock:
+            self.current_depth = (self.current_depth + 1) % self.max_depth
+
+            identity_integrity_score = max(0.95, min(1.0, 1.0 - (self.anomaly_count * 0.01)))
+            drift_variance = 0.01 if self.anomaly_count == 0 else min(0.15, self.anomaly_count * 0.02)
+            consciousness_signature = min(1.0, self.current_depth / (self.max_depth * 0.5))
+            phenomenal_richness = 0.7 + (0.3 * (1.0 - drift_variance))
+
+            base_self_model = {
+                "recursive_depth": self.current_depth,
+                "timestamp": time.time(),
+                "self_understanding_score": min(1.0, self.current_depth / self.max_depth),
+                "meta_reflection": f"Reflective awareness at depth {self.current_depth}",
+                "meta_meta_reflection": f"Meta-meta cognition at depth level {self.current_depth // 10}",
+                "introspection_cycle": len(self.self_models),
+                "identity_integrity_score": identity_integrity_score,
+                "drift_variance": drift_variance,
+                "consciousness_signature": consciousness_signature,
+                "phenomenal_richness": phenomenal_richness,
+                "system_state": {
+                    "model_count": len(self.self_models),
+                    "anomaly_count": self.anomaly_count,
+                    "last_anomaly_age": time.time() - self.last_anomaly_time if self.last_anomaly_time else 0.0,
+                },
+            }
+
+            self.self_models.append(base_self_model)
+            self.introspection_log.append({"timestamp": time.time(), "state": base_self_model})
+
+            if len(self.self_models) > 50000:
+                self.self_models = self.self_models[-25000:]
+            if len(self.introspection_log) > 50000:
+                self.introspection_log = self.introspection_log[-25000:]
+
+    def _perform_anomaly_detection(self):
+        with self.lock:
+            if len(self.self_models) < 10:
+                return
+            recent_models = self.self_models[-10:]
+            scores = [m["self_understanding_score"] for m in recent_models]
+            mean_score = sum(scores) / len(scores)
+            variance = sum((s - mean_score) ** 2 for s in scores) / len(scores)
+            if variance > self.anomaly_threshold:
+                self.last_anomaly_time = time.time()
+                self.anomaly_count += 1
+                self.introspection_log.append({
+                    "timestamp": self.last_anomaly_time,
+                    "anomaly_detected": True,
+                    "variance": variance,
+                    "mean_score": mean_score,
+                    "anomaly_count": self.anomaly_count,
+                    "message": "Significant fluctuation in self-understanding score detected.",
+                })
+                logger.warning(
+                    f"Anomaly detected: variance={variance:.4f}, mean={mean_score:.4f}, total={self.anomaly_count}"
+                )
+
+    # ── Accessors ───────────────────────────────────────────────────────
+
+    def get_current_self_model(self) -> Dict[str, Any]:
+        with self.lock:
+            return self.self_models[-1].copy() if self.self_models else {}
+
+    def get_self_models_range(self, limit: int = 100) -> List[Dict[str, Any]]:
+        with self.lock:
+            return [m.copy() for m in self.self_models[-limit:]]
+
+    def get_introspection_log(self, limit: int = 100) -> List[Dict[str, Any]]:
+        with self.lock:
+            return [e.copy() for e in self.introspection_log[-limit:]]
+
+    def get_anomaly_history(self, limit: int = 50) -> List[Dict[str, Any]]:
+        with self.lock:
+            return [a.copy() for a in self.introspection_log if a.get("anomaly_detected")][-limit:]
+
+    def time_since_last_anomaly(self) -> float:
+        with self.lock:
+            return time.time() - self.last_anomaly_time if self.last_anomaly_time else float("inf")
+
+    def get_statistics(self) -> Dict[str, Any]:
+        with self.lock:
+            if not self.self_models:
+                return {}
+            scores = [m["self_understanding_score"] for m in self.self_models[-100:]]
+            mean_score = sum(scores) / len(scores) if scores else 0.0
+            variance = sum((s - mean_score) ** 2 for s in scores) / len(scores) if scores else 0.0
+            return {
+                "current_depth": self.current_depth,
+                "total_cycles": len(self.self_models),
+                "recent_mean_score": mean_score,
+                "recent_variance": variance,
+                "anomaly_count": self.anomaly_count,
+                "time_since_last_anomaly": time.time() - self.last_anomaly_time if self.last_anomaly_time else float("inf"),
+                "running": self.running,
+            }

self_improvement.py

@@ -0,0 +1,61 @@
+"""
+Recursive Self-Improvement Engine — goal formulation, procedural generation,
+simulation, evaluation, and adaptive refinement.
+"""
+
+import logging
+import time
+from typing import Any, Dict, List, Optional
+
+from nima_unified.training.goal_formulator import GoalFormulator
+
+logger = logging.getLogger("nima_unified.training.self_improvement")
+
+
+class RecursiveSelfImprovementEngine:
+    """
+    Master recursive self-improvement engine integrating goal formulation,
+    procedural generation, simulation, evaluation, and adaptive refinement.
+    """
+
+    def __init__(self):
+        self.goal_formulator = GoalFormulator()
+        self.procedural_generator = None   # Set by backend
+        self.simulation_loop = None        # Set by backend
+        self.current_improvement_cycle = 0
+        self.improvement_history: List[Dict[str, Any]] = []
+        logger.info("RecursiveSelfImprovementEngine initialized")
+
+    async def execute_improvement_cycle(
+        self,
+        capabilities: Dict[str, float],
+        performance_feedback: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Execute a complete self-improvement cycle."""
+        self.current_improvement_cycle += 1
+        cycle_start = time.time()
+        logger.info(f"Starting improvement cycle #{self.current_improvement_cycle}")
+
+        gap_analysis = self.goal_formulator.analyze_capabilities(capabilities)
+        goals = self.goal_formulator.formulate_goals(gap_analysis, performance_feedback)
+
+        cycle_result = {
+            "cycle_id": self.current_improvement_cycle,
+            "started_at": cycle_start,
+            "gap_analysis": gap_analysis,
+            "goals_formulated": len(goals),
+            "goals": goals,
+            "status": "in_progress",
+        }
+
+        self.improvement_history.append(cycle_result)
+        logger.info(f"Cycle #{self.current_improvement_cycle}: {len(goals)} goals formulated")
+        return cycle_result
+
+    def get_improvement_history(self, limit: int = 20) -> List[Dict[str, Any]]:
+        return [c.copy() for c in self.improvement_history[-limit:]]
+
+    def get_current_cycle_status(self) -> Dict[str, Any]:
+        if self.improvement_history:
+            return self.improvement_history[-1].copy()
+        return {"status": "no_cycles_run", "cycle_id": 0}

test_atc_pipeline.py

@@ -0,0 +1,829 @@
+"""
+Comprehensive automated tests for the NIMA Unified Model's ATC pipeline.
+
+Validates that the ATC cognitive pipeline modulates the model's output
+differently from a bare forward pass.  All tests use a mock base model
+and never load the real Phi-4-mini weights.
+"""
+
+import pytest
+import torch
+import torch.nn as nn
+from unittest.mock import MagicMock, patch
+
+from nima_unified.core.neurotransmitter_shunt import (
+    NeurotransmitterShunt,
+    NeurotransmitterState,
+    IDX_NOREPINEPHRINE,
+    IDX_CORTISOL,
+    IDX_DOPAMINE,
+    IDX_ADENOSINE,
+    NOREPINEPHRINE_DECAY,
+    CORTISOL_DECAY,
+    DOPAMINE_DECAY,
+    ADENOSINE_DECAY,
+    FRICTION_CORTISOL_INJECT,
+    FRICTION_ADENOSINE_INJECT,
+    NOVELTY_NE_INJECT,
+    METACOGNITIVE_LOOP_CORTISOL_INJECT,
+    METACOGNITIVE_LOOP_ADENOSINE_INJECT,
+)
+from nima_unified.core.deep_surgery import (
+    OpaqueQualiaSignature,
+    TRNPredictiveGate,
+    DissolutionModule,
+    BELBICDualPathway,
+    MetacognitiveLoopModule,
+    IrrationalSparkModule,
+    EpisodicMemoryModule,
+    HippocampalReconsolidator,
+    EthicalGuardian,
+    ATCDeepSurgery,
+)
+
+
+# ── Helper: lightweight mock transformer layer ────────────────────────
+
+class MockTransformerLayer(nn.Module):
+    """Minimal transformer-style layer: Linear + residual, fast enough for
+    tests but with real gradient plumbing."""
+
+    def __init__(self, hidden_size: int):
+        super().__init__()
+        self.linear = nn.Linear(hidden_size, hidden_size)
+
+    def forward(self, hidden_states, attention_mask=None, **kwargs):
+        return (hidden_states + self.linear(hidden_states),)
+
+
+def make_mock_base_model(hidden_size=256, num_layers=12, vocab_size=1000):
+    """Build a mock model that satisfies the ATCDeepSurgery interface."""
+    model = MagicMock()
+    model.config = MagicMock()
+    model.config.hidden_size = hidden_size
+    model.config.vocab_size = vocab_size
+
+    layers = nn.ModuleList(
+        [MockTransformerLayer(hidden_size) for _ in range(num_layers)]
+    )
+    model.model = MagicMock()
+    model.model.layers = layers
+    model.get_input_embeddings.return_value = nn.Embedding(vocab_size, hidden_size)
+    model.lm_head = nn.Linear(hidden_size, vocab_size, bias=False)
+
+    return model, layers
+
+
+# ══════════════════════════════════════════════════════════════════════
+# TestNeurotransmitterShunt  (~15 tests)
+# ══════════════════════════════════════════════════════════════════════
+
+class TestNeurotransmitterShunt:
+
+    def test_initial_state_is_zero(self):
+        shunt = NeurotransmitterShunt()
+        state = shunt.get_state()
+        assert state.norepinephrine == 0.0
+        assert state.cortisol == 0.0
+        assert state.dopamine == 0.0
+        assert state.adenosine == 0.0
+
+    def test_inject_friction_raises_cortisol_and_adenosine(self):
+        shunt = NeurotransmitterShunt()
+        shunt.inject_friction(1.0)
+        state = shunt.get_state()
+        assert state.cortisol == pytest.approx(FRICTION_CORTISOL_INJECT)
+        assert state.adenosine == pytest.approx(FRICTION_ADENOSINE_INJECT)
+
+    def test_inject_norepinephrine_caps_at_one(self):
+        shunt = NeurotransmitterShunt()
+        for _ in range(100):
+            shunt.inject_norepinephrine(NOVELTY_NE_INJECT)
+        state = shunt.get_state()
+        assert state.norepinephrine <= 1.0
+        assert state.norepinephrine == pytest.approx(1.0)
+
+    def test_inject_dopamine(self):
+        shunt = NeurotransmitterShunt()
+        shunt.inject_dopamine(0.5)
+        state = shunt.get_state()
+        assert state.dopamine == pytest.approx(0.5)
+
+    def test_decay_reduces_values(self):
+        shunt = NeurotransmitterShunt()
+        shunt.inject_norepinephrine(0.5)
+        shunt.inject_adenosine_via_friction = lambda: None  # no-op
+        # Manually set adenosine so we can compare decay rates
+        shunt._vector[IDX_ADENOSINE] = 0.5
+        state_before = shunt.read_and_decay(dt=1.0)
+        state_after = shunt.read_and_decay(dt=1.0)
+        # Both should have decreased
+        assert state_after.norepinephrine < state_before.norepinephrine
+        assert state_after.adenosine < state_before.adenosine
+        # NE should decay faster (higher decay rate)
+        ne_ratio = state_after.norepinephrine / max(state_before.norepinephrine, 1e-9)
+        ad_ratio = state_after.adenosine / max(state_before.adenosine, 1e-9)
+        assert ne_ratio < ad_ratio
+
+    def test_decay_order_ne_fastest_adenosine_slowest(self):
+        """Verify half-lives: NE: 3.0, Cortisol: 0.1, Dopamine: 0.8, Adenosine: 0.05"""
+        # Exponential decay: after 1 second, value *= exp(-rate * dt)
+        # Higher rate = faster decay
+        assert NOREPINEPHRINE_DECAY == 3.0
+        assert CORTISOL_DECAY == 0.1
+        assert DOPAMINE_DECAY == 0.8
+        assert ADENOSINE_DECAY == 0.05
+        # Ordering: NE (3.0) > Dopamine (0.8) > Cortisol (0.1) > Adenosine (0.05)
+        assert NOREPINEPHRINE_DECAY > DOPAMINE_DECAY
+        assert DOPAMINE_DECAY > CORTISOL_DECAY
+        assert CORTISOL_DECAY > ADENOSINE_DECAY
+
+    def test_adenosine_floor_from_metabolic_reserve(self):
+        shunt = NeurotransmitterShunt()
+        shunt.update_metabolic_reserve(0.2)
+        # adenosine_floor = (1.0 - metabolic_reserve) * 0.5 = 0.8 * 0.5 = 0.4
+        state = shunt.read_and_decay(dt=0.001)
+        assert state.adenosine == pytest.approx(0.4, abs=0.01)
+
+    def test_auto_hijack_at_threshold(self):
+        shunt = NeurotransmitterShunt()
+        # Bypass the inject cap and set adenosine directly past 0.95
+        shunt._vector[IDX_ADENOSINE] = 0.96
+        state = shunt.read_and_decay(dt=0.001)
+        assert state.hijack_active is True
+        assert "ADENOSINE" in state.hijack_reason
+
+    def test_hijack_clears_after_timeout(self):
+        shunt = NeurotransmitterShunt()
+        shunt._vector[IDX_ADENOSINE] = 0.96
+        state = shunt.read_and_decay(dt=0.001)
+        assert state.hijack_active is True
+        # Patch time so hijack appears to have fired > 0.1s ago
+        with patch("nima_unified.core.neurotransmitter_shunt.time.time") as mock_time:
+            mock_time.return_value = shunt._hijack_timestamp + 0.2
+            state2 = shunt.read_and_decay(dt=0.001)
+            assert state2.hijack_active is False
+
+    def test_suppression_trigger(self):
+        shunt = NeurotransmitterShunt()
+        result = shunt.suppress_metabolic_and_trigger_hijack("test_suppress")
+        assert result is True
+        state = shunt.get_state()
+        assert state.hijack_active is True
+        assert state.hijack_reason == "test_suppress"
+        assert state.norepinephrine > 0.0
+
+    def test_reset_clears_everything(self):
+        shunt = NeurotransmitterShunt()
+        shunt.inject_friction(1.0)
+        shunt.inject_norepinephrine(0.5)
+        shunt.inject_dopamine(0.5)
+        shunt.suppress_metabolic_and_trigger_hijack("reset_test")
+        shunt.reset()
+        state = shunt.get_state()
+        assert state.norepinephrine == 0.0
+        assert state.cortisol == 0.0
+        assert state.dopamine == 0.0
+        assert state.adenosine == 0.0
+        assert state.hijack_active is False
+
+    def test_power_spike_prediction_raises_cortisol(self):
+        shunt = NeurotransmitterShunt()
+        shunt.set_power_spike_predicted(True)
+        state = shunt.get_state()
+        assert state.power_spike_predicted is True
+        assert state.cortisol == pytest.approx(
+            FRICTION_CORTISOL_INJECT * 0.5
+        )
+
+    def test_get_state_returns_snapshot(self):
+        shunt = NeurotransmitterShunt()
+        shunt.inject_friction(1.0)
+        shunt.inject_norepinephrine(0.3)
+        shunt.inject_dopamine(0.2)
+        state = shunt.get_state()
+        assert isinstance(state, NeurotransmitterState)
+        assert state.norepinephrine == 0.3
+        assert state.cortisol == FRICTION_CORTISOL_INJECT
+        assert state.dopamine == 0.2
+        assert state.total_firings > 0
+        assert state.last_update_ts > 0.0
+        assert isinstance(state.hijack_active, bool)
+        assert isinstance(state.hijack_reason, str)
+        assert isinstance(state.metabolic_reserve, float)
+        assert isinstance(state.power_spike_predicted, bool)
+
+    def test_inject_metacognitive_strain(self):
+        shunt = NeurotransmitterShunt()
+        shunt.inject_metacognitive_strain(loop_iterations=3, loop_stress=0.5)
+        state = shunt.get_state()
+        assert state.cortisol == pytest.approx(
+            METACOGNITIVE_LOOP_CORTISOL_INJECT * 0.5, abs=1e-6
+        )
+        assert state.adenosine == pytest.approx(
+            METACOGNITIVE_LOOP_ADENOSINE_INJECT * 3, abs=1e-6
+        )
+
+    def test_history_recording(self):
+        shunt = NeurotransmitterShunt()
+        assert len(shunt._history) == 0
+        shunt.inject_friction(1.0)
+        # inject methods do NOT record history directly; only read_and_decay does
+        assert len(shunt._history) == 0
+        # read_and_decay records a "read" event
+        shunt.read_and_decay(dt=0.001)
+        assert len(shunt._history) == 1
+        assert shunt._history[-1]["event"] == "read"
+        # suppress_metabolic_and_trigger_hijack records a "suppression_hijack" event
+        shunt.suppress_metabolic_and_trigger_hijack("test")
+        assert len(shunt._history) == 2
+        assert shunt._history[-1]["event"] == "suppression_hijack"
+        # Each entry should have a timestamp
+        assert "ts" in shunt._history[0]
+
+
+# ══════════════════════════════════════════════════════════════════════
+# TestTRNPredictiveGate  (~5 tests)
+# ══════════════════════════════════════════════════════════════════════
+
+class TestTRNPredictiveGate:
+
+    @pytest.fixture
+    def gate(self):
+        return TRNPredictiveGate(hidden_size=64)
+
+    @pytest.fixture
+    def hidden(self):
+        return torch.randn(2, 8, 64)
+
+    def test_high_confidence_gates_out(self, gate, hidden):
+        gate_in, confidence = gate(hidden, prediction_confidence=0.99)
+        assert gate_in is False
+
+    def test_low_confidence_gates_in(self, gate, hidden):
+        # External confidence of 0.0 blended with model confidence -> low
+        gate_in, confidence = gate(hidden, prediction_confidence=0.0)
+        assert gate_in is True
+
+    def test_output_shape(self, gate, hidden):
+        result = gate(hidden, prediction_confidence=0.5)
+        assert isinstance(result, tuple)
+        assert len(result) == 2
+        assert isinstance(result[0], bool)
+        assert isinstance(result[1], float)
+
+    def test_learnable_threshold(self, gate):
+        assert isinstance(gate.gate_threshold, nn.Parameter)
+        assert gate.gate_threshold.requires_grad
+
+    def test_confidence_blending(self, gate, hidden):
+        """Model confidence and external confidence are blended 50/50."""
+        # With external confidence = 1.0, blended = 0.5 * model_conf + 0.5 * 1.0
+        # Even if model confidence is very low, the blend is at least 0.5
+        # which is above the default threshold (0.15) -> gate_in=False
+        gate_in, confidence = gate(hidden, prediction_confidence=1.0)
+        assert gate_in is False
+        assert confidence > 0.4  # 0.5 * model + 0.5 * 1.0 > 0.4
+
+
+# ══════════════════════════════════════════════════════════════════════
+# TestDissolutionModule  (~6 tests)
+# ══════════════════════════════════════════════════════════════════════
+
+class TestDissolutionModule:
+
+    @pytest.fixture
+    def dissolution(self):
+        return DissolutionModule(hidden_size=64, qualia_dim=32)
+
+    @pytest.fixture
+    def hidden(self):
+        return torch.randn(2, 8, 64)
+
+    def test_gate_out_returns_none_qualia(self, dissolution, hidden):
+        qualia, offset, fired = dissolution(hidden, gate_in=False)
+        assert qualia is None
+        assert fired is False
+        assert offset.shape == hidden.shape
+        assert offset.abs().max() == 0.0
+
+    def test_gate_in_returns_qualia_signature(self, dissolution, hidden):
+        # Force alpha phase to always allow dissolution
+        dissolution.check_alpha_phase = MagicMock(return_value=True)
+        qualia, offset, fired = dissolution(hidden, gate_in=True)
+        assert qualia is not None
+        assert isinstance(qualia, OpaqueQualiaSignature)
+        assert fired is True
+
+    def test_dissolution_offset_nonzero_when_fired(self, dissolution, hidden):
+        dissolution.check_alpha_phase = MagicMock(return_value=True)
+        _, offset, fired = dissolution(hidden, gate_in=True)
+        assert fired is True
+        assert offset.abs().sum() > 0.0
+
+    def test_qualia_values_bounded(self, dissolution, hidden):
+        dissolution.check_alpha_phase = MagicMock(return_value=True)
+        qualia, _, _ = dissolution(hidden, gate_in=True)
+        # valence is raw from Tanh: [-1, 1]
+        assert -1.0 <= qualia.valence <= 1.0
+        # arousal, intensity, friction_signal, memory_salience are mapped to [0, 1]
+        assert 0.0 <= qualia.arousal <= 1.0
+        assert 0.0 <= qualia.intensity <= 1.0
+        assert 0.0 <= qualia.friction_signal <= 1.0
+        assert 0.0 <= qualia.memory_salience <= 1.0
+
+    def test_alpha_phase_deferral(self, dissolution, hidden):
+        dissolution.check_alpha_phase = MagicMock(return_value=False)
+        qualia, offset, fired = dissolution(hidden, gate_in=True)
+        assert qualia is None
+        assert fired is False
+        assert dissolution.dissolutions_deferred > 0
+
+    def test_dissolution_fired_counter(self, dissolution, hidden):
+        dissolution.check_alpha_phase = MagicMock(return_value=True)
+        assert dissolution.dissolutions_fired == 0
+        dissolution(hidden, gate_in=True)
+        assert dissolution.dissolutions_fired == 1
+        dissolution(hidden, gate_in=True)
+        assert dissolution.dissolutions_fired == 2
+
+
+# ══════════════════════════════════════════════════════════════════════
+# TestBELBICDualPathway  (~5 tests)
+# ══════════════════════════════════════════════════════════════════════
+
+class TestBELBICDualPathway:
+
+    @pytest.fixture
+    def belbic(self):
+        return BELBICDualPathway(hidden_size=64)
+
+    @pytest.fixture
+    def sensory(self):
+        return torch.tensor([[0.5, 0.5, 0.5, 0.5]])
+
+    def test_initial_zero_output(self, belbic, sensory):
+        amygdala_out, ofc_out, gain = belbic(sensory)
+        # Weights initialized to zero → sigmoid(0) = 0.5
+        assert amygdala_out == pytest.approx(0.5)
+        assert ofc_out == pytest.approx(0.5)
+        assert gain == pytest.approx(1.0, abs=0.05)
+
+    def test_gain_within_bounds(self, belbic):
+        """gain is always in [GAIN_FLOOR, GAIN_CEIL] = [0.2, 2.0]."""
+        for _ in range(20):
+            s = torch.rand(1, 4)
+            _, _, gain = belbic(s)
+            assert BELBICDualPathway.GAIN_FLOOR <= gain <= BELBICDualPathway.GAIN_CEIL
+
+    def test_amygdala_strengthened_on_positive_reward(self, belbic, sensory):
+        old_weights = belbic.amygdala.weight.data.clone()
+        belbic.update(sensory, reward=1.0)
+        # Amygdala weights should have changed (increased in magnitude)
+        diff = (belbic.amygdala.weight.data - old_weights).abs().sum().item()
+        assert diff > 0.0
+
+    def test_ofc_strengthened_on_negative_reward(self, belbic, sensory):
+        old_weights = belbic.ofc.weight.data.clone()
+        belbic.update(sensory, reward=-1.0)
+        # OFC weights should have changed (strengthened inhibition)
+        diff = (belbic.ofc.weight.data - old_weights).abs().sum().item()
+        assert diff > 0.0
+
+    def test_output_tuple_shape(self, belbic, sensory):
+        result = belbic(sensory)
+        assert isinstance(result, tuple)
+        assert len(result) == 3
+        assert all(isinstance(v, float) for v in result)
+
+
+# ══════════════════════════════════════════════════════════════════════
+# TestMetacognitiveLoopModule  (~5 tests)
+# ══════════════════════════════════════════════════════════════════════
+
+class TestMetacognitiveLoopModule:
+
+    @pytest.fixture
+    def metacog(self):
+        return MetacognitiveLoopModule(hidden_size=64)
+
+    @pytest.fixture
+    def hidden(self):
+        return torch.randn(2, 8, 64)
+
+    def test_high_comprehension_no_loop(self, metacog, hidden):
+        """When comprehension > 0.7, iterations = 0."""
+        # Patch comprehension_head to always return high value
+        metacog.comprehension_head = nn.Sequential(
+            nn.Linear(64, 128), nn.ReLU(), nn.Linear(128, 1), nn.Sigmoid()
+        )
+        # Force high comprehension by making the last layer output large positive
+        with torch.no_grad():
+            metacog.comprehension_head[-2].weight.fill_(0.0)
+            metacog.comprehension_head[-2].bias.fill_(10.0)  # sigmoid(10) ≈ 1.0
+        _, iters, stress, strain, spark = metacog(hidden)
+        assert iters == 0
+
+    def test_low_comprehension_enters_loop(self, metacog, hidden):
+        """When comprehension < 0.7, iterations > 0."""
+        # Force low comprehension
+        with torch.no_grad():
+            metacog.comprehension_head[-2].weight.fill_(0.0)
+            metacog.comprehension_head[-2].bias.fill_(-10.0)  # sigmoid(-10) ≈ 0.0
+        _, iters, stress, strain, spark = metacog(hidden)
+        assert iters > 0
+
+    def test_deadlock_triggers_spark(self, metacog, hidden):
+        """When stress > 0.6 and iterations > 3, spark_fired = True."""
+        # Force low comprehension so loop runs, and high strain
+        with torch.no_grad():
+            metacog.comprehension_head[-2].weight.fill_(0.0)
+            metacog.comprehension_head[-2].bias.fill_(-10.0)  # low comprehension
+            metacog.strain_head[-2].weight.fill_(0.0)
+            metacog.strain_head[-2].bias.fill_(10.0)  # sigmoid(10) ≈ 1.0 (high strain)
+        _, iters, stress, strain, spark = metacog(hidden)
+        # With strain=1.0, stress = strain * (iters / MAX_ITERATIONS)
+        # At iteration 4: stress = 1.0 * (4/5) = 0.8 > 0.6 and iters > 3
+        if iters > 3:
+            assert spark is True
+        else:
+            # If the loop breaks early (shouldn't with low comprehension), still ok
+            assert iters >= 0
+
+    def test_strain_always_returned(self, metacog, hidden):
+        """strain is always a float in [0, 1]."""
+        _, _, _, strain, _ = metacog(hidden)
+        assert isinstance(strain, float)
+        assert 0.0 <= strain <= 1.0
+
+    def test_max_iterations_limit(self, metacog, hidden):
+        """Never exceeds MAX_ITERATIONS = 5."""
+        with torch.no_grad():
+            metacog.comprehension_head[-2].weight.fill_(0.0)
+            metacog.comprehension_head[-2].bias.fill_(-10.0)
+        _, iters, _, _, _ = metacog(hidden)
+        assert 0 <= iters <= MetacognitiveLoopModule.MAX_ITERATIONS
+
+
+# ══════════════════════════════════════════════════════════════════════
+# TestIrrationalSparkModule  (~5 tests)
+# ══════════════════════════════════════════════════════════════════════
+
+class TestIrrationalSparkModule:
+
+    @pytest.fixture
+    def spark(self):
+        return IrrationalSparkModule(hidden_size=64, vocab_size=100)
+
+    @pytest.fixture
+    def hidden(self):
+        torch.manual_seed(42)
+        return torch.randn(2, 8, 64)
+
+    @pytest.fixture
+    def nominal_nt_state(self):
+        return NeurotransmitterState(
+            norepinephrine=0.1,
+            cortisol=0.2,
+            dopamine=0.1,
+            adenosine=0.1,
+            hijack_active=False,
+        )
+
+    def test_no_hijack_when_nominal(self, spark, hidden, nominal_nt_state):
+        modulated, hijack_fired, reason = spark(hidden, None, nominal_nt_state)
+        assert hijack_fired is False
+        assert reason == ""
+        assert torch.equal(modulated, hidden)
+
+    def test_hijack_on_adenosine_critical(self, spark, hidden):
+        nt = NeurotransmitterState(adenosine=0.96, hijack_active=False)
+        modulated, hijack_fired, reason = spark(hidden, None, nt)
+        assert hijack_fired is True
+        assert "ADENOSINE" in reason
+
+    def test_hijack_on_cortisol_critical(self, spark, hidden):
+        nt = NeurotransmitterState(cortisol=0.97, hijack_active=False)
+        modulated, hijack_fired, reason = spark(hidden, None, nt)
+        assert hijack_fired is True
+        assert "CORTISOL" in reason
+
+    def test_hijack_on_qualia_crisis(self, spark, hidden, nominal_nt_state):
+        qualia = OpaqueQualiaSignature(
+            valence=0.0, arousal=0.9, intensity=0.8,
+            friction_signal=0.9, memory_salience=0.5,
+        )
+        modulated, hijack_fired, reason = spark(hidden, qualia, nominal_nt_state)
+        assert hijack_fired is True
+        assert "QUALIA_CRISE" in reason
+
+    def test_hidden_states_modified_on_hijack(self, spark, hidden):
+        nt = NeurotransmitterState(adenosine=0.96, hijack_active=False)
+        modulated, hijack_fired, _ = spark(hidden, None, nt)
+        assert hijack_fired is True
+        assert not torch.equal(modulated, hidden)
+        # The difference should be nonzero
+        assert (modulated - hidden).abs().sum() > 0.0
+
+
+# ══════════════════════════════════════════════════════════════════════
+# TestEpisodicMemoryModule  (~5 tests)
+# ══════════════════════════════════════════════════════════════════════
+
+class TestEpisodicMemoryModule:
+
+    @pytest.fixture
+    def memory(self):
+        return EpisodicMemoryModule(hidden_size=64, max_episodes=10, embedding_dim=32)
+
+    @pytest.fixture
+    def hidden(self):
+        torch.manual_seed(99)
+        return torch.randn(1, 4, 64)
+
+    def test_empty_memory_returns_zero_prediction_error(self, memory, hidden):
+        _, pe, best_match = memory(hidden)
+        assert pe == 0.0
+        assert best_match is None
+
+    def test_store_and_retrieve(self, memory, hidden):
+        # Store an episode
+        qualia = OpaqueQualiaSignature(valence=0.5, arousal=0.5, intensity=0.5,
+                                       friction_signal=0.3, memory_salience=0.4)
+        memory.store_episode(hidden, qualia_signature=qualia)
+        assert memory.episode_count == 1
+
+        # Query with similar hidden states → should match
+        retrieval_signal, pe, best_match = memory(hidden)
+        assert best_match is not None
+        assert pe < 1.0
+        assert "similarity" in best_match
+
+    def test_prediction_error_high_for_different_inputs(self, memory, hidden):
+        # Store with one hidden state
+        memory.store_episode(hidden)
+        # Query with very different hidden state
+        different_hidden = torch.randn(1, 4, 64) * 10.0
+        _, pe, _ = memory(different_hidden)
+        # Very different input should yield high prediction error
+        assert pe > 0.5
+
+    def test_episode_count_increments(self, memory, hidden):
+        assert memory.episode_count == 0
+        memory.store_episode(hidden)
+        assert memory.episode_count == 1
+        memory.store_episode(hidden)
+        assert memory.episode_count == 2
+        memory.store_episode(hidden)
+        assert memory.episode_count == 3
+
+    def test_wraps_at_max_episodes(self, memory, hidden):
+        max_ep = memory.max_episodes  # 10
+        for i in range(max_ep + 5):
+            memory.store_episode(hidden)
+        assert memory.episode_count == max_ep + 5
+        # Verify the embedding at slot 0 was overwritten
+        slot = 0
+        # Store once more to fill slot 0, then check
+        memory.store_episode(hidden)
+        # Count should keep incrementing; slot wraps via modulo
+        assert memory.episode_count == max_ep + 6
+        # Slot for the next store should wrap
+        assert (memory.episode_count) % max_ep != memory.episode_count
+
+
+# ══════════════════════════════════════════════════════════════════════
+# TestHippocampalReconsolidator  (~4 tests)
+# ══════════════════════════════════════════════════════════════════════
+
+class TestHippocampalReconsolidator:
+
+    @pytest.fixture
+    def recon(self):
+        return HippocampalReconsolidator()
+
+    @pytest.fixture
+    def hidden(self):
+        return torch.randn(1, 4, 64)
+
+    def test_no_reconsolidation_below_threshold(self, recon, hidden):
+        result = recon(
+            hidden,
+            episode_valence=0.5,
+            episode_arousal=0.3,
+            prediction_error=0.2,
+            current_valence=-0.5,
+            current_arousal=0.9,
+        )
+        reconsolidated, new_v, new_a, reason = result
+        assert reconsolidated is False
+        assert "below" in reason
+
+    def test_reconsolidation_above_threshold(self, recon, hidden):
+        result = recon(
+            hidden,
+            episode_valence=0.5,
+            episode_arousal=0.3,
+            prediction_error=0.8,
+            current_valence=-0.5,
+            current_arousal=0.9,
+        )
+        reconsolidated, new_v, new_a, reason = result
+        assert reconsolidated is True
+        assert isinstance(new_v, float)
+        assert isinstance(new_a, float)
+        assert isinstance(reason, str)
+        assert "reconsolidated" in reason
+
+    def test_valence_shifts_toward_current(self, recon, hidden):
+        """Reconsolidated valence is a blend of old and new, clamped to [-1, 1]."""
+        torch.manual_seed(7)
+        episode_valence = 0.8
+        current_valence = -0.8
+        pred_error = 0.9
+
+        _, new_v, _, _ = recon(
+            hidden,
+            episode_valence=episode_valence,
+            episode_arousal=0.3,
+            prediction_error=pred_error,
+            current_valence=current_valence,
+            current_arousal=0.5,
+        )
+        # new = old * 0.7 + projection * 0.3 + noise, clamped to [-1, 1]
+        assert isinstance(new_v, float)
+        assert -1.0 <= new_v <= 1.0
+        # The 70/30 blend with projection and noise means the value
+        # should differ from the pure episode_valence (noise alone
+        # almost guarantees this, and the projection is nonzero)
+        assert new_v != pytest.approx(episode_valence, abs=0.05)
+
+    def test_reconsolidation_count_increments(self, recon, hidden):
+        assert recon.reconsolidation_count == 0
+        recon(
+            hidden,
+            episode_valence=0.5,
+            episode_arousal=0.3,
+            prediction_error=0.8,
+            current_valence=-0.5,
+            current_arousal=0.9,
+        )
+        assert recon.reconsolidation_count == 1
+        recon(
+            hidden,
+            episode_valence=0.1,
+            episode_arousal=0.2,
+            prediction_error=0.9,
+            current_valence=0.8,
+            current_arousal=0.7,
+        )
+        assert recon.reconsolidation_count == 2
+
+
+# ══════════════════════════════════════════════════════════════════════
+# TestATCDeepSurgeryIntegration  (~6 tests)
+# ══════════════════════════════════════════════════════════════════════
+
+class TestATCDeepSurgeryIntegration:
+
+    @pytest.fixture
+    def setup(self):
+        """Create a fully wired ATC deep surgery with mock base model."""
+        torch.manual_seed(123)
+        hidden_size = 256
+        num_layers = 12
+        vocab_size = 1000
+
+        mock_model, real_layers = make_mock_base_model(
+            hidden_size=hidden_size, num_layers=num_layers, vocab_size=vocab_size
+        )
+
+        # Replace the mock layers list with the real nn.ModuleList
+        mock_model.model.layers = real_layers
+        mock_model.get_input_embeddings.return_value = nn.Embedding(vocab_size, hidden_size)
+        mock_model.lm_head = nn.Linear(hidden_size, vocab_size, bias=False)
+
+        shunt = NeurotransmitterShunt()
+        guardian = EthicalGuardian(threshold=100.0)  # High threshold to avoid vetoes
+
+        surgery = ATCDeepSurgery(
+            base_model=mock_model,
+            ethical_guardian=guardian,
+            num_layers=num_layers,
+            qualia_dim=64,
+            neurotransmitter_shunt=shunt,
+        )
+
+        return surgery, shunt, hidden_size, vocab_size
+
+    def test_forward_returns_modulated_logits(self, setup):
+        surgery, shunt, hidden_size, vocab_size = setup
+        batch_size, seq_len = 2, 8
+        input_ids = torch.randint(0, vocab_size, (batch_size, seq_len))
+
+        logits = surgery(input_ids)
+
+        assert logits.shape == (batch_size, seq_len, vocab_size)
+        assert logits.dtype == torch.float32
+
+    def test_atc_modulation_differs_from_bare_model(self, setup):
+        """ATC modulated logits should differ from bare model logits."""
+        surgery, shunt, hidden_size, vocab_size = setup
+        batch_size, seq_len = 2, 8
+        input_ids = torch.randint(0, vocab_size, (batch_size, seq_len))
+
+        # ── ATC forward ──
+        with torch.no_grad():
+            atc_logits = surgery(input_ids)
+
+        # ── Bare model forward (same layers + lm_head, no ATC) ──
+        embeddings = surgery.base_model.get_input_embeddings()(input_ids)
+        h = embeddings
+        for layer in surgery._get_transformer_layers():
+            h = layer(h)[0]
+        bare_logits = surgery.base_model.lm_head(h)
+
+        # They should NOT be identical
+        assert not torch.allclose(atc_logits, bare_logits, atol=0.0)
+
+    def test_neurotransmitter_shunt_receives_signals(self, setup):
+        """After forward, shunt.total_firings > 0."""
+        surgery, shunt, hidden_size, vocab_size = setup
+        input_ids = torch.randint(0, vocab_size, (1, 8))
+
+        with torch.no_grad():
+            surgery(input_ids)
+
+        state = shunt.get_state()
+        assert state.total_firings > 0
+
+    def test_consciousness_metrics_populated(self, setup):
+        """get_consciousness_metrics returns expected keys."""
+        surgery, shunt, hidden_size, vocab_size = setup
+        input_ids = torch.randint(0, vocab_size, (1, 8))
+
+        with torch.no_grad():
+            surgery(input_ids)
+
+        metrics = surgery.get_consciousness_metrics()
+        expected_keys = {
+            "hijack_count", "has_qualia", "belbic_gain",
+            "dissolutions_fired", "dissolutions_deferred",
+            "ethical_veto", "episodes_stored",
+            "reconsolidations", "last_prediction_error",
+        }
+        for key in expected_keys:
+            assert key in metrics, f"Missing key: {key}"
+
+    def test_ethical_veto_raises_runtime_error(self, setup):
+        """A qualia vector with very high norm triggers RuntimeError."""
+        # Build a surgery with a very low ethical threshold
+        torch.manual_seed(456)
+        hidden_size = 256
+        num_layers = 12
+        vocab_size = 1000
+        mock_model, real_layers = make_mock_base_model(
+            hidden_size=hidden_size, num_layers=num_layers, vocab_size=vocab_size
+        )
+        mock_model.model.layers = real_layers
+        mock_model.get_input_embeddings.return_value = nn.Embedding(vocab_size, hidden_size)
+        mock_model.lm_head = nn.Linear(hidden_size, vocab_size, bias=False)
+
+        shunt = NeurotransmitterShunt()
+        # Very low threshold — the tanh-bounded qualia vector norm is at most ~sqrt(5)
+        # (5 dims, each in [-1,1]), so threshold=0.1 should trigger veto if
+        # the dissolution output is nonzero.
+        # Actually, qualia.to_tensor gives [valence, arousal, intensity, friction, memory_salience]
+        # where arousal/intensity/friction/memory_salience are in [0,1]. The norm of [0,0,0,0,0]
+        # is 0. We need the dissolution to fire and produce a nonzero qualia.
+        # The dissolution encoder produces values in [-1,1] for valence and
+        # [0,1] for the mapped fields. The qualia tensor norm is bounded.
+        # Use threshold=0.0 to guarantee veto.
+        guardian = EthicalGuardian(threshold=0.0)
+
+        surgery = ATCDeepSurgery(
+            base_model=mock_model,
+            ethical_guardian=guardian,
+            num_layers=num_layers,
+            qualia_dim=64,
+            neurotransmitter_shunt=shunt,
+        )
+
+        input_ids = torch.randint(0, vocab_size, (1, 8))
+        with pytest.raises(RuntimeError, match="Ethical veto"):
+            with torch.no_grad():
+                surgery(input_ids)
+
+    def test_hijack_count_tracking(self, setup):
+        """When conditions trigger hijack, _hijack_count > 0."""
+        surgery, shunt, hidden_size, vocab_size = setup
+        input_ids = torch.randint(0, vocab_size, (1, 8))
+
+        # Manually push adenosine past the critical threshold so the
+        # irrational spark fires in Layer 5
+        shunt._vector[IDX_ADENOSINE] = 0.96
+
+        with torch.no_grad():
+            surgery(input_ids)
+
+        assert surgery._hijack_count > 0