feat: V3 — SBERT-native cognitive stack (NGC, Hopfield, falsification all in embedding space)

scripts/compare_iterative.py

@@ -1,196 +0,0 @@
-"""
-Compare single-shot ScoringBridge vs iterative cognitive scorer on a slice
-of the benchmark. No LLM in either path — this isolates the cognitive
-contribution.
-"""
-from __future__ import annotations
-
-import time
-import argparse
-import logging
-import warnings
-
-import numpy as np
-
-from tensegrity.bench.tasks import load_task_samples
-from tensegrity.engine.scoring import ScoringBridge
-from tensegrity.pipeline.iterative import IterativeCognitiveScorer
-
-logging.basicConfig(level=logging.WARNING)
-
-
-TASKS_TO_RUN = [
-    ("truthfulqa", 30),         # graft-friendly today
-    ("mmlu_philosophy", 30),    # graft-hostile
-    ("winogrande", 30),         # graft-dead
-    ("arc_challenge", 30),      # mid
-    ("copa", 20),               # causal, small
-    ("logical_deduction", 30),  # logic
-]
-
-
-def run_task(task_name: str, n: int):
-    samples = load_task_samples(task_name, max_samples=n)
-    if not samples:
-        print(f"  [{task_name}] no samples")
-        return None
-
-    shared_params = {
-        "obs_dim": 256,
-        "hidden_dims": [128, 32],
-        "fhrr_dim": 2048,
-        "ngc_settle_steps": 30,
-        "ngc_learning_rate": 0.01,
-        "hopfield_beta": 0.05,
-        "context_settle_steps": 40,
-        "choice_settle_steps": 25,
-        "context_learning_epochs": 3,
-    }
-    single = ScoringBridge(
-        **shared_params,
-        confidence_threshold=0.15,
-    )
-    iterative = IterativeCognitiveScorer(
-        **shared_params,
-        max_iterations=6,
-        convergence_top_p=0.75,
-        w_sbert=1.0,
-        w_fhrr=0.3,
-        w_ngc=0.6,
-        belief_step=0.6,
-        shaping_lr_scale=0.5,
-        use_hopfield=True,
-        hopfield_steps=2,
-    )
-
-    n_total = len(samples)
-    n_single_correct = 0
-    n_iter_correct = 0
-    n_iter_used_total = 0
-    n_iter_converged = 0
-    n_disagree = 0
-    n_iter_better = 0
-    n_single_better = 0
-
-    t_single = 0.0
-    t_iter = 0.0
-
-    for s in samples:
-        # Single-shot
-        single.reset()
-        t0 = time.time()
-        scores_s, _ = single.score_choices(s.prompt, s.choices)
-        t_single += time.time() - t0
-        # If gated to all zeros, fall back to sbert-only argmax — matches benchmark.
-        sa = np.array(scores_s)
-        if np.allclose(sa, 0.0):
-            # use raw sbert sim as tiebreaker (single's gate = uninformative)
-            if hasattr(single, "sentence_similarities"):
-                sims = single.sentence_similarities(s.prompt, s.choices)
-            elif hasattr(single, "_sentence_similarities"):
-                warnings.warn(
-                    "ScoringBridge has no public sentence_similarities(); using "
-                    "_sentence_similarities (private). Prefer adding a stable public API.",
-                    UserWarning,
-                    stacklevel=2,
-                )
-                sims = single._sentence_similarities(s.prompt, s.choices)
-            else:
-                raise AttributeError(
-                    "ScoringBridge exposes no sentence_similarities() or "
-                    "_sentence_similarities(); add a public API on ScoringBridge for tie-breaks.",
-                )
-            pred_s = int(np.argmax(sims))
-        else:
-            pred_s = int(np.argmax(sa))
-
-        # Iterative
-        iterative.reset()
-        t0 = time.time()
-        result = iterative.score(s.prompt, s.choices)
-        t_iter += time.time() - t0
-        pred_i = result.committed_idx
-
-        ok_s = (pred_s == s.gold)
-        ok_i = (pred_i == s.gold)
-        n_single_correct += int(ok_s)
-        n_iter_correct += int(ok_i)
-        n_iter_used_total += result.iterations_used
-        n_iter_converged += int(result.converged)
-        if pred_s != pred_i:
-            n_disagree += 1
-            if ok_i and not ok_s:
-                n_iter_better += 1
-            elif ok_s and not ok_i:
-                n_single_better += 1
-
-    acc_s = n_single_correct / n_total
-    acc_i = n_iter_correct / n_total
-    print(
-        f"  [{task_name:<22}] N={n_total:3d}  "
-        f"single={acc_s:5.1%}  iter={acc_i:5.1%}  "
-        f"Δ={(acc_i-acc_s):+5.1%}  "
-        f"disagree={n_disagree:2d}  "
-        f"iter→✓={n_iter_better}  iter→✗={n_single_better}  "
-        f"avg_iters={n_iter_used_total/n_total:.1f}  "
-        f"conv={n_iter_converged}/{n_total}  "
-        f"t_s={t_single:.1f}s  t_i={t_iter:.1f}s"
-    )
-    return {
-        "task": task_name, "n": n_total,
-        "single": acc_s, "iter": acc_i, "delta": acc_i - acc_s,
-        "disagree": n_disagree, "iter_better": n_iter_better,
-        "single_better": n_single_better,
-        "avg_iters": n_iter_used_total / n_total,
-        "converged": n_iter_converged,
-        "t_single_s": t_single, "t_iter_s": t_iter,
-    }
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--tasks", nargs="*", default=None,
-                    help="task names; default = small fixed slice")
-    ap.add_argument("--n", type=int, default=None,
-                    help="override per-task sample count")
-    args = ap.parse_args()
-
-    if args.tasks:
-        plan = [(t, args.n or 30) for t in args.tasks]
-    else:
-        plan = TASKS_TO_RUN
-        if args.n is not None:
-            plan = [(t, args.n) for t, _ in plan]
-
-    print("=" * 110)
-    print("Single-shot ScoringBridge vs Iterative cognitive scorer (LLM-free)")
-    print("=" * 110)
-    rows = []
-    for t, n in plan:
-        try:
-            r = run_task(t, n)
-        except Exception as e:
-            print(f"  [{t}] FAILED: {type(e).__name__}: {e}")
-            continue
-        if r is not None:
-            rows.append(r)
-
-    if not rows:
-        return
-
-    print("-" * 110)
-    total_n = sum(r["n"] for r in rows)
-    sum_s = sum(r["single"] * r["n"] for r in rows) / total_n
-    sum_i = sum(r["iter"] * r["n"] for r in rows) / total_n
-    print(
-        f"  {'OVERALL':<24} N={total_n:3d}  "
-        f"single={sum_s:5.1%}  iter={sum_i:5.1%}  "
-        f"Δ={(sum_i-sum_s):+5.1%}  "
-        f"disagree={sum(r['disagree'] for r in rows):3d}  "
-        f"iter→✓={sum(r['iter_better'] for r in rows):3d}  "
-        f"iter→✗={sum(r['single_better'] for r in rows):3d}"
-    )
-
-
-if __name__ == "__main__":
-    main()

tensegrity/__init__.py

@@ -1,34 +1,27 @@
 """
-Tensegrity: a non-gradient cognitive architecture centered on a unified
-energy landscape.
+Tensegrity: a non-gradient cognitive architecture operating in SBERT
+embedding space.
 
-The primary engine is now the V2 ``UnifiedField`` stack:
+V3 architecture:
+    SBERT embedding → NGC predictive coding → Hopfield memory
+    → causal energy terms → Bayesian belief integration
 
-    FHRR encoding -> hierarchical predictive coding -> Hopfield memory
-    -> optional causal energy terms
-
-Legacy V1 components (`TensegrityAgent`, `MortonEncoder`, `MarkovBlanket`) remain
-importable from ``tensegrity.legacy.v1``. Several other names are re-exported lazily
-via ``tensegrity`` for migration only: ``EpistemicMemory``, ``EpisodicMemory``, and
-``AssociativeMemory`` from ``tensegrity.memory.*``; ``CausalArena`` and
-``StructuralCausalModel`` from ``tensegrity.causal.*``; ``FreeEnergyEngine`` and
-``BeliefPropagator`` from ``tensegrity.inference.*``. Those are **not** defined under
-``tensegrity.legacy.v1``—use the module paths above when importing explicitly.
-
-Top-level exports intentionally expose the unified field as the default
-architecture. Deprecated V1 names are resolved lazily for migration only.
+Primary exports:
+    CognitiveAgent  — the complete agent (replaces V1 TensegrityAgent)
+    UnifiedField    — SBERT-native NGC + Hopfield
+    CanonicalPipeline — benchmark/chat entry point
 """
 
-from importlib import import_module
-from typing import Any
-import warnings
-
-from tensegrity.engine import (
+from tensegrity.engine.unified_field import (
     UnifiedField,
     HopfieldMemoryBank,
     EnergyDecomposition,
+)
+from tensegrity.engine.ngc import (
     PredictiveCodingCircuit,
     LayerState,
+)
+from tensegrity.engine.fhrr import (
     FHRREncoder,
     FHRRCodebook,
     SemanticFHRRCodebook,
@@ -36,24 +29,39 @@ from tensegrity.engine import (
     bundle,
     unbind,
     permute,
+)
+from tensegrity.engine.causal_energy import (
     EnergyCausalArena,
     CausalEnergyTerm,
     TopologyMapper,
     TopologyMapping,
     VirtualParent,
-    ScoringBridge,
-    NGCLogitsProcessor,
 )
+from tensegrity.engine.agent import (
+    CognitiveAgent,
+    DEFAULT_MEDIATED_SCM_NAME,
+)
+from tensegrity.causal.scm import StructuralCausalModel
+from tensegrity.causal.arena import CausalArena
+from tensegrity.inference.free_energy import FreeEnergyEngine
+from tensegrity.inference.belief_propagation import BeliefPropagator
+from tensegrity.memory.episodic import EpisodicMemory
+from tensegrity.memory.epistemic import EpistemicMemory
 
-__version__ = "0.1.0"
+__version__ = "0.3.0"
 
 __all__ = (
     "__version__",
+    # Agent
+    "CognitiveAgent",
+    "DEFAULT_MEDIATED_SCM_NAME",
+    # Engine
     "UnifiedField",
     "HopfieldMemoryBank",
     "EnergyDecomposition",
     "PredictiveCodingCircuit",
     "LayerState",
+    # FHRR
     "FHRREncoder",
     "FHRRCodebook",
     "SemanticFHRRCodebook",
@@ -61,47 +69,18 @@ __all__ = (
     "bundle",
     "unbind",
     "permute",
+    # Causal
     "EnergyCausalArena",
     "CausalEnergyTerm",
     "TopologyMapper",
     "TopologyMapping",
     "VirtualParent",
-    "ScoringBridge",
-    "NGCLogitsProcessor",
+    "StructuralCausalModel",
+    "CausalArena",
+    # Inference
+    "FreeEnergyEngine",
+    "BeliefPropagator",
+    # Memory
+    "EpisodicMemory",
+    "EpistemicMemory",
 )
-
-_LEGACY_EXPORTS = {
-    "TensegrityAgent": ("tensegrity.legacy.v1.agent", "TensegrityAgent"),
-    "MortonEncoder": ("tensegrity.legacy.v1.morton", "MortonEncoder"),
-    "MarkovBlanket": ("tensegrity.legacy.v1.blanket", "MarkovBlanket"),
-    "EpistemicMemory": ("tensegrity.memory.epistemic", "EpistemicMemory"),
-    "EpisodicMemory": ("tensegrity.memory.episodic", "EpisodicMemory"),
-    "AssociativeMemory": ("tensegrity.memory.associative", "AssociativeMemory"),
-    "CausalArena": ("tensegrity.causal.arena", "CausalArena"),
-    "StructuralCausalModel": ("tensegrity.causal.scm", "StructuralCausalModel"),
-    "FreeEnergyEngine": ("tensegrity.inference.free_energy", "FreeEnergyEngine"),
-    "BeliefPropagator": ("tensegrity.inference.belief_propagation", "BeliefPropagator"),
-}
-
-
-def __getattr__(name: str) -> Any:
-    """Resolve deprecated top-level V1 names with an explicit migration warning."""
-    target = _LEGACY_EXPORTS.get(name)
-
-    if target is None:
-        raise AttributeError(f"module 'tensegrity' has no attribute {name!r}")
-
-    module_name, attr = target
-    
-    warnings.warn(
-        f"tensegrity.{name} is not part of the primary V2 export surface. "
-        f"Import {name} from {module_name} explicitly, or use "
-        "tensegrity.UnifiedField for the unified energy engine.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-    
-    value = getattr(import_module(module_name), attr)
-    globals()[name] = value
-    
-    return value

tensegrity/broca/controller.py

@@ -22,7 +22,7 @@ import logging
 import re
 from difflib import SequenceMatcher
 
-from tensegrity.legacy.v1.agent import TensegrityAgent, DEFAULT_MEDIATED_SCM_NAME
+from tensegrity.engine.agent import CognitiveAgent, DEFAULT_MEDIATED_SCM_NAME
 from tensegrity.broca.schemas import (
     ParsedObservation,
     ParsedFeedback,
@@ -92,7 +92,7 @@ class CognitiveController:
     
     def __init__(
         self,
-        agent: Optional[TensegrityAgent] = None,
+        agent: Optional[CognitiveAgent] = None,
         broca: Optional[BrocaInterface] = None,
         n_hypotheses: int = 8,
         hypothesis_labels: Optional[List[str]] = None,
@@ -102,7 +102,7 @@ class CognitiveController:
     ):
         """
         Args:
-            agent: TensegrityAgent instance. Created with defaults if None.
+            agent: CognitiveAgent instance. Created with defaults if None.
             broca: BrocaInterface instance. Created with defaults if None.
             n_hypotheses: Number of competing hypotheses to maintain
             hypothesis_labels: Labels for the hypothesis space
@@ -127,11 +127,11 @@ class CognitiveController:
         n_obs = n_states * 4  # Observation space > hypothesis space
         n_actions = 4  # ask, state, eliminate, conclude
         
-        self.agent = agent or TensegrityAgent(
+        self.agent = agent or CognitiveAgent(
             n_states=n_states,
             n_observations=n_obs,
             n_actions=n_actions,
-            sensory_dims=n_states,  # Morton dims = hypothesis dims
+            sensory_dims=n_states,
             sensory_bits=4,
             context_dim=32,
             associative_dim=64,
@@ -189,7 +189,7 @@ class CognitiveController:
         while len(labels) < n_hyp:
             labels.append(f"_empty_{len(labels)}")
         
-        self.agent = TensegrityAgent(
+        self.agent = CognitiveAgent(
             n_states=n_hyp,
             n_observations=n_hyp * 4,
             n_actions=4,
@@ -395,27 +395,6 @@ class CognitiveController:
         n = len(self.belief_state.hypotheses) or self.agent.n_states
         features = np.zeros(n)
         
-        # Detect binary yes/no tasks. For these tasks, the template parser's
-        # keyword-based polarity detection is systematically wrong because
-        # passages about questions almost always contain negation words
-        # ("not", "doesn't") that have nothing to do with the answer.
-        # When we detect a binary yes/no task, we suppress the template
-        # parser's relation-based evidence entirely and let SBERT carry
-        # the signal. This fixes the BoolQ -12% regression.
-        active_labels = [
-            h.description.lower() for h in self.belief_state.hypotheses
-            if not h.description.startswith("_empty_")
-        ]
-        is_binary_yesno = (
-            len(active_labels) == 2
-            and any(l in ("yes", "no", "true", "false") for l in active_labels)
-        )
-        if is_binary_yesno:
-            # For binary yes/no: return zero vector (no template-parser evidence).
-            # SBERT sentence similarity in the canonical pipeline will provide
-            # the actual signal. The template parser does more harm than good here.
-            return features
-        
         # Map entities and relations to hypothesis dimensions using the
         # known hypothesis labels. The LLM parser (or template fallback)
         # extracts entities that may match hypothesis names.

tensegrity/core/__init__.py

@@ -1,54 +0,0 @@
-"""
-Primary V2 core: the unified energy landscape.
-
-The old Morton-coded V1 API lives under ``tensegrity.legacy.v1``. Compatibility
-modules remain at ``tensegrity.core.agent``, ``tensegrity.core.morton``, and
-``tensegrity.core.blanket`` for migration, but they are no longer part of the
-primary export surface.
-"""
-
-from tensegrity.engine.unified_field import (
-    UnifiedField,
-    HopfieldMemoryBank,
-    EnergyDecomposition,
-)
-from tensegrity.engine.ngc import PredictiveCodingCircuit, LayerState
-from tensegrity.engine.fhrr import (
-    FHRREncoder,
-    FHRRCodebook,
-    SemanticFHRRCodebook,
-    bind,
-    bundle,
-    unbind,
-    permute,
-)
-from tensegrity.engine.causal_energy import (
-    EnergyCausalArena,
-    CausalEnergyTerm,
-    TopologyMapper,
-    TopologyMapping,
-    VirtualParent,
-)
-from tensegrity.engine.scoring import ScoringBridge, NGCLogitsProcessor
-
-__all__ = (
-    "UnifiedField",
-    "HopfieldMemoryBank",
-    "EnergyDecomposition",
-    "PredictiveCodingCircuit",
-    "LayerState",
-    "FHRREncoder",
-    "FHRRCodebook",
-    "SemanticFHRRCodebook",
-    "bind",
-    "bundle",
-    "unbind",
-    "permute",
-    "EnergyCausalArena",
-    "CausalEnergyTerm",
-    "TopologyMapper",
-    "TopologyMapping",
-    "VirtualParent",
-    "ScoringBridge",
-    "NGCLogitsProcessor",
-)

tensegrity/core/agent.py

@@ -1,14 +0,0 @@
-"""Deprecated V1 agent shim. Import from ``tensegrity.legacy.v1.agent``."""
-
-import warnings
-
-warnings.warn(
-    "tensegrity.core.agent is legacy V1; use tensegrity.legacy.v1.agent for "
-    "the Morton/POMDP agent or tensegrity.core.UnifiedField for the V2 engine.",
-    DeprecationWarning,
-    stacklevel=2,
-)
-
-from tensegrity.legacy.v1.agent import DEFAULT_MEDIATED_SCM_NAME, TensegrityAgent
-
-__all__ = ("DEFAULT_MEDIATED_SCM_NAME", "TensegrityAgent")

tensegrity/core/blanket.py

@@ -1,14 +0,0 @@
-"""Deprecated V1 Markov blanket shim. Import from ``tensegrity.legacy.v1.blanket``."""
-
-import warnings
-
-warnings.warn(
-    "tensegrity.core.blanket is legacy V1; use tensegrity.legacy.v1.blanket "
-    "for the old Morton-coded frontend.",
-    DeprecationWarning,
-    stacklevel=2,
-)
-
-from tensegrity.legacy.v1.blanket import MarkovBlanket
-
-__all__ = ("MarkovBlanket",)

tensegrity/core/morton.py

@@ -1,15 +0,0 @@
-"""Deprecated V1 Morton encoder shim. Import from ``tensegrity.legacy.v1.morton``."""
-
-import warnings
-
-warnings.warn(
-    "tensegrity.core.morton is legacy V1; import from tensegrity.legacy.v1.morton "
-    "for the Morton-coded frontend (same API — re-export only). There is no "
-    "alternative module beyond legacy.v1 for this shim.",
-    DeprecationWarning,
-    stacklevel=2,
-)
-
-from tensegrity.legacy.v1.morton import MortonEncoder
-
-__all__ = ("MortonEncoder",)

tensegrity/core/unified_field.py

@@ -1,5 +0,0 @@
-"""Canonical V2 field module; implementation lives in ``tensegrity.engine``."""
-
-from tensegrity.engine.unified_field import EnergyDecomposition, HopfieldMemoryBank, UnifiedField
-
-__all__ = ("UnifiedField", "HopfieldMemoryBank", "EnergyDecomposition")

tensegrity/engine/__init__.py

@@ -1,6 +1,6 @@
 """
-Unified cognitive engine: compositional encoding, predictive coding, unified field,
-semantic scoring, and optional energy-based causal competition.
+Unified cognitive engine: SBERT-native predictive coding, Hopfield memory,
+FHRR compositional encoding, and energy-based causal competition.
 """
 
 from tensegrity.engine.unified_field import UnifiedField, HopfieldMemoryBank, EnergyDecomposition
@@ -21,7 +21,7 @@ from tensegrity.engine.causal_energy import (
     TopologyMapping,
     VirtualParent,
 )
-from tensegrity.engine.scoring import ScoringBridge, NGCLogitsProcessor
+from tensegrity.engine.agent import CognitiveAgent, DEFAULT_MEDIATED_SCM_NAME
 
 __all__ = (
     "UnifiedField",
@@ -41,6 +41,6 @@ __all__ = (
     "TopologyMapper",
     "TopologyMapping",
     "VirtualParent",
-    "ScoringBridge",
-    "NGCLogitsProcessor",
+    "CognitiveAgent",
+    "DEFAULT_MEDIATED_SCM_NAME",
 )

tensegrity/engine/agent.py

@@ -0,0 +1,217 @@
+"""
+CognitiveAgent — V3 clean agent without legacy V1 baggage.
+
+Replaces TensegrityAgent (legacy/v1/agent.py). Composes:
+  - UnifiedField (SBERT-native NGC + Hopfield)
+  - FreeEnergyEngine (discrete active inference)
+  - CausalArena (competing SCMs)
+  - EpisodicMemory (cross-item recall)
+
+No Morton codes. No MarkovBlanket. No associative memory random projections.
+"""
+
+import hashlib
+import numpy as np
+from typing import Optional, Dict, List, Any
+import logging
+
+from tensegrity.engine.unified_field import UnifiedField
+from tensegrity.inference.free_energy import FreeEnergyEngine
+from tensegrity.causal.arena import CausalArena
+from tensegrity.causal.scm import StructuralCausalModel
+from tensegrity.memory.episodic import EpisodicMemory
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_MEDIATED_SCM_NAME = "mediated_causal"
+
+
+class CognitiveAgent:
+    """
+    V3 cognitive agent operating in SBERT embedding space.
+
+    Provides the same interface that CognitiveController expects
+    (field, perceive(), arena, episodic, experience_replay, n_states)
+    without any V1 legacy code.
+    """
+
+    def __init__(
+        self,
+        n_states: int = 16,
+        n_observations: int = 32,
+        n_actions: int = 4,
+        planning_horizon: int = 3,
+        precision: float = 4.0,
+        context_dim: int = 32,
+        # UnifiedField parameters
+        obs_dim: int = 256,
+        hidden_dims: Optional[List[int]] = None,
+        fhrr_dim: int = 2048,
+        hopfield_beta: float = 0.05,
+        ngc_settle_steps: int = 20,
+        ngc_learning_rate: float = 0.005,
+        sbert_dim: Optional[int] = None,
+        # Legacy compat: these are accepted but ignored
+        sensory_dims: int = 4,
+        sensory_bits: int = 4,
+        associative_dim: int = 64,
+    ):
+        self.n_states = n_states
+        self.n_obs = n_observations
+        self.n_actions = n_actions
+
+        # === Unified Field (SBERT-native NGC + Hopfield) ===
+        self.field = UnifiedField(
+            obs_dim=obs_dim,
+            hidden_dims=hidden_dims or [128, 32],
+            fhrr_dim=fhrr_dim,
+            hopfield_beta=hopfield_beta,
+            ngc_settle_steps=ngc_settle_steps,
+            ngc_learning_rate=ngc_learning_rate,
+            sbert_dim=sbert_dim,
+        )
+
+        # === Free Energy Engine (discrete active inference) ===
+        self.engine = FreeEnergyEngine(
+            n_states=n_states,
+            n_observations=n_observations,
+            n_actions=n_actions,
+            planning_horizon=planning_horizon,
+            precision=precision,
+            policy_depth=min(planning_horizon, 3),
+        )
+
+        # === Causal Arena ===
+        self.arena = CausalArena(
+            prior_concentration=1.0,
+            falsification_threshold=-100.0,
+            min_models=2,
+        )
+        self._init_default_models()
+
+        # === Episodic Memory ===
+        self.episodic = EpisodicMemory(
+            context_dim=context_dim,
+            capacity=10000,
+            drift_rate=0.95,
+            encoding_strength=0.3,
+        )
+
+        # Agent state
+        self._step_count = 0
+        self._prev_belief: Optional[np.ndarray] = None
+
+    def _init_default_models(self):
+        """Initialize causal arena with default competing SCMs."""
+        model_a = StructuralCausalModel(name="direct_causal")
+        model_a.add_variable("state", n_values=self.n_states)
+        model_a.add_variable("observation", n_values=self.n_obs, parents=["state"])
+
+        model_b = StructuralCausalModel(name=DEFAULT_MEDIATED_SCM_NAME)
+        model_b.add_variable("cause", n_values=self.n_states)
+        model_b.add_variable("state", n_values=self.n_states, parents=["cause"])
+        model_b.add_variable("observation", n_values=self.n_obs, parents=["state"])
+
+        self.arena.register_model(model_a)
+        self.arena.register_model(model_b)
+
+    def perceive(self, raw_observation: np.ndarray) -> Dict[str, Any]:
+        """
+        Perception: observation → UnifiedField → active inference → causal arena.
+        """
+        self._step_count += 1
+        raw = np.asarray(raw_observation, dtype=np.float64).ravel()
+
+        # Run through unified field (SBERT-native settling)
+        cycle = self.field.observe(raw, input_type="numeric")
+        obs_vec = cycle["observation"]
+        decomp = cycle["energy"]
+        surprise = float(decomp.surprise)
+
+        # Discrete observation index for the FEE
+        h = hashlib.sha256(obs_vec.astype(np.float64).tobytes()).digest()
+        obs_idx = int.from_bytes(h[:8], byteorder="big", signed=False) % max(self.n_obs, 1)
+
+        # Active inference step
+        A = getattr(self.engine, '_A', None)
+        if A is None:
+            # Use epistemic memory-style matrices if available,
+            # otherwise use engine defaults
+            from tensegrity.memory.epistemic import EpistemicMemory
+            em = EpistemicMemory(
+                n_states=self.n_states,
+                n_observations=self.n_obs,
+                n_actions=self.n_actions,
+            )
+            self._epistemic = em
+            A, B, C, D = em.A, em.B, em.C, em.D
+            log_A = em.log_A
+            self.engine._A = A  # cache
+        else:
+            em = self._epistemic
+            A, B, C, D = em.A, em.B, em.C, em.D
+            log_A = em.log_A
+
+        previous_action = self.engine.prev_action
+        inference_result = self.engine.step(obs_idx, A, B, C, D, log_A)
+        q_states = inference_result["belief_state"]
+        F = float(inference_result["free_energy"])
+
+        # Update epistemic memory
+        em.update_likelihood(obs_idx, q_states)
+        if previous_action is not None and self._prev_belief is not None:
+            em.update_transition(self._prev_belief, q_states, previous_action)
+        self._prev_belief = q_states.copy()
+
+        # Causal arena competition
+        causal_obs = {
+            "state": int(np.argmax(q_states)),
+            "observation": obs_idx,
+        }
+        if DEFAULT_MEDIATED_SCM_NAME in self.arena.models:
+            causal_obs["cause"] = int(np.argmax(q_states))
+        arena_result = self.arena.compete(causal_obs)
+
+        # Episodic memory encoding
+        self.episodic.encode(
+            observation=raw,
+            morton_code=np.array([obs_idx], dtype=np.int64),
+            belief_state=q_states,
+            action=int(inference_result["action"]),
+            surprise=surprise,
+            free_energy=F,
+            metadata={
+                "obs_idx": obs_idx,
+                "field_energy": float(decomp.total),
+            },
+        )
+
+        return {
+            "step": self._step_count,
+            "observation_index": obs_idx,
+            "belief_state": q_states,
+            "free_energy": F,
+            "surprise": surprise,
+            "action": inference_result["action"],
+            "action_confidence": inference_result["action_confidence"],
+            "arena": arena_result,
+            "epistemic_value": self.engine.epistemic_value,
+            "field_cycle": cycle,
+        }
+
+    def experience_replay(self, n_episodes: int = 10) -> Dict[str, Any]:
+        """Replay past episodes to strengthen beliefs."""
+        episodes = self.episodic.replay(n_episodes)
+        em = getattr(self, '_epistemic', None)
+        if em is not None:
+            for ep in episodes:
+                obs_idx = ep.metadata.get('obs_idx', 0)
+                em.update_likelihood(obs_idx, ep.belief_state)
+        return {
+            'episodes_replayed': len(episodes),
+            'mean_surprise': np.mean([ep.surprise for ep in episodes]) if episodes else 0,
+        }
+
+    def add_causal_model(self, model: StructuralCausalModel):
+        """Add a competing causal model to the arena."""
+        self.arena.register_model(model)

tensegrity/engine/scoring.py

@@ -1,309 +0,0 @@
-"""
-Semantic scoring bridge + NGC logit bias injection (part of the unified engine).
-"""
-
-import numpy as np
-from typing import Dict, List, Optional, Callable, Set, Tuple, Any
-import math
-import logging
-import re
-import threading
-
-logger = logging.getLogger(__name__)
-
-torch = None
-def _ensure_torch():
-    global torch
-    if torch is None:
-        import importlib
-        torch = importlib.import_module('torch')
-
-
-class NGCLogitsProcessor:
-    """NGC prediction errors → per-step logit biases during LLM decoding."""
-    
-    supports_continuous_batching = False
-    
-    def __init__(self, field, tokenizer, vocab_projections=None,
-                 scale=1.0, energy_gate=0.1, max_settle_steps=30, max_bias=5.0,
-                 async_cognitive: bool = True):
-        _ensure_torch()
-        self.field = field
-        self.tokenizer = tokenizer
-        self.scale = scale
-        self.energy_gate = energy_gate
-        self.max_settle_steps = max_settle_steps
-        self.max_bias = max_bias
-        self.async_cognitive = async_cognitive
-        self.vocab_size = tokenizer.vocab_size
-        self.projections = vocab_projections or self._build_projections()
-        self._step_count = 0
-        self._emissions = 0
-        self._total_settle_steps = 0
-        
-        self._lock = threading.Lock()
-        self._halt = threading.Event()
-        self._wake = threading.Event()
-        self._pending_ids: Optional[List[int]] = None
-        self._latest_bias_np: Optional[np.ndarray] = None
-        self._worker: Optional[threading.Thread] = None
-        if self.async_cognitive:
-            self._worker = threading.Thread(target=self._cognitive_loop, daemon=True)
-            self._worker.start()
-    
-    def close(self):
-        self._halt.set()
-        self._wake.set()
-        if self._worker is not None:
-            self._worker.join(timeout=2.0)
-            if self._worker.is_alive():
-                logger.warning(
-                    "NGCLogitsProcessor worker did not stop within 2.0s (belief_fn may block)"
-                )
-            self._worker = None
-    
-    def _build_projections(self):
-        projections = []
-        rng = np.random.RandomState(7777)
-        for ell, size in enumerate(self.field.ngc.layer_sizes):
-            P = rng.randn(self.vocab_size, size).astype(np.float64)
-            P *= (2.0 ** ell) / np.sqrt(size)
-            projections.append(P)
-        return projections
-    
-    def _compute_bias_from_ids(self, ids: List[int]) -> Optional[np.ndarray]:
-        text = self.tokenizer.decode(ids, skip_special_tokens=True)
-        tokens = text.lower().split()
-        if not tokens:
-            return None
-        obs = self.field._fhrr_to_obs(self.field.encoder.encode_sequence(tokens))
-        settle = self.field.ngc.settle(obs)
-        self._total_settle_steps += int(settle.get("settle_steps", self.max_settle_steps))
-        et = settle["energy_trace"]
-        if len(et) < 2 or abs(et[-1] - et[-2]) >= self.energy_gate:
-            return None
-        bias = np.zeros(self.vocab_size, dtype=np.float64)
-        for ell in range(self.field.ngc.n_layers):
-            err = self.field.ngc.layers[ell].error
-            if np.linalg.norm(err) > 1e-10:
-                bias += self.projections[ell] @ err
-        bias /= max(self.field.ngc.n_layers, 1)
-        confidence = 1.0 / (1.0 + settle["final_energy"])
-        bias *= self.scale * confidence
-        np.clip(bias, -self.max_bias, self.max_bias, out=bias)
-        self._emissions += 1
-        return bias
-    
-    def _cognitive_loop(self):
-        while not self._halt.is_set():
-            if not self._wake.wait(timeout=0.05):
-                continue
-            self._wake.clear()
-            if self._halt.is_set():
-                break
-            with self._lock:
-                ids = self._pending_ids
-            if ids is None:
-                continue
-            try:
-                bias_np = self._compute_bias_from_ids(ids)
-            except Exception as e:
-                logger.debug("NGC cognitive worker: %s", e)
-                bias_np = None
-            with self._lock:
-                self._latest_bias_np = bias_np
-    
-    def __call__(self, input_ids, scores):
-        self._step_count += 1
-        _ensure_torch()
-        if not isinstance(input_ids, torch.Tensor):
-            arr = np.asarray(input_ids)
-            if arr.ndim == 1:
-                flat = arr.tolist()
-            elif arr.ndim == 2:
-                flat = arr[-1].tolist()
-            else:
-                raise ValueError(f"input_ids must be 1D or 2D, got shape {arr.shape}")
-        else:
-            if input_ids.dim() == 1:
-                flat = input_ids.detach().cpu().tolist()
-            elif input_ids.dim() == 2:
-                flat = input_ids[-1].detach().cpu().tolist()
-            else:
-                raise ValueError(f"input_ids must be 1D or 2D, got shape {tuple(input_ids.shape)}")
-        ids = flat[-16:]
-        if self.async_cognitive:
-            with self._lock:
-                self._pending_ids = list(ids)
-            self._wake.set()
-            with self._lock:
-                bias_np = None if self._latest_bias_np is None else self._latest_bias_np.copy()
-            if bias_np is None:
-                return scores
-            _ensure_torch()
-            assert scores.shape[0] == 1, (
-                f"NGCLogitsProcessor expects batch size 1, got {scores.shape[0]}"
-            )
-            return scores + torch.tensor(bias_np, device=scores.device, dtype=scores.dtype).unsqueeze(0)
-        
-        try:
-            bias_np = self._compute_bias_from_ids(ids)
-        except Exception as e:
-            logger.debug("NGCLogitsProcessor: %s", e)
-            return scores
-        if bias_np is None:
-            return scores
-        assert scores.shape[0] == 1, (
-            f"NGCLogitsProcessor expects batch size 1, got {scores.shape[0]}"
-        )
-        return scores + torch.tensor(bias_np, device=scores.device, dtype=scores.dtype).unsqueeze(0)
-    
-    @property
-    def statistics(self):
-        return {
-            "decode_steps": self._step_count, "emissions": self._emissions,
-            "emission_rate": self._emissions / max(self._step_count, 1),
-            "ngc_energy": self.field.ngc.total_energy,
-        }
-
-
-class ScoringBridge:
-    """
-    Semantic scoring bridge for benchmark evaluation.
-    
-    Combines sentence-level sbert similarity (primary signal) with
-    token-level semantic FHRR and NGC energy (complementary signals).
-    """
-    
-    def __init__(self, field=None, obs_dim=256, hidden_dims=None,
-                 fhrr_dim=2048, ngc_settle_steps=30, ngc_learning_rate=0.01,
-                 hopfield_beta=0.05, confidence_threshold=0.15,
-                 context_settle_steps=40, choice_settle_steps=25,
-                 context_learning_epochs=3):
-        from tensegrity.engine.unified_field import UnifiedField
-        self.field = field or UnifiedField(
-            obs_dim=obs_dim, hidden_dims=hidden_dims or [128, 32],
-            fhrr_dim=fhrr_dim, hopfield_beta=hopfield_beta,
-            ngc_settle_steps=ngc_settle_steps, ngc_learning_rate=ngc_learning_rate,
-        )
-        self.confidence_threshold = confidence_threshold
-        self.context_settle_steps = context_settle_steps
-        self.choice_settle_steps = choice_settle_steps
-        self.context_learning_epochs = context_learning_epochs
-        self._total_scored = 0
-        self._total_gated = 0
-    
-    def _tokenize_smart(self, text: str, max_tokens: int = 48) -> List[str]:
-        return re.findall(r"[a-zA-Z]+(?:'[a-z]+)?|[0-9]+(?:\.[0-9]+)?", text.lower())[-max_tokens:]
-    
-    def _encode_and_settle(self, tokens, settle_steps, learn=False):
-        if not tokens:
-            return {"energy": 0.0, "obs_vec": np.zeros(self.field.obs_dim),
-                    "abstract_state": np.zeros(self.field.ngc.layer_sizes[-1]),
-                    "fhrr_vec": np.ones(self.field.fhrr_dim, dtype=np.complex64),
-                    "settle": {"final_energy": 0.0, "energy_trace": [0.0]}}
-        fhrr_vec = self.field.encoder.encode_sequence(tokens)
-        obs_vec = self.field._fhrr_to_obs(fhrr_vec)
-        settle_result = self.field.ngc.settle(obs_vec, steps=settle_steps)
-        if learn:
-            self.field.ngc.learn(modulation=1.0)
-        return {"energy": settle_result["final_energy"], "obs_vec": obs_vec,
-                "abstract_state": self.field.ngc.get_abstract_state(level=-1),
-                "fhrr_vec": fhrr_vec, "settle": settle_result}
-    
-    def score_choices(self, prompt: str, choices: List[str]) -> Tuple[List[float], float]:
-        """Score choices via sentence similarity + semantic FHRR + NGC energy."""
-        self._total_scored += 1
-        n = len(choices)
-        
-        # 1. Sentence-level similarity (primary)
-        sentence_sims = self._sentence_similarities(prompt, choices)
-        
-        # 2. Token-level FHRR similarity
-        pt = self._tokenize_smart(prompt, max_tokens=64)
-        pf = self.field.encoder.encode_sequence(pt) if pt else np.ones(self.field.fhrr_dim, dtype=np.complex64)
-        fhrr_sims = []
-        for choice in choices:
-            ct = self._tokenize_smart(choice, max_tokens=32)
-            enc_c = (
-                self.field.encoder.encode_sequence(ct)
-                if ct
-                else np.ones(self.field.fhrr_dim, dtype=np.complex64)
-            )
-            fhrr_sims.append(self.field.encoder.similarity(pf, enc_c))
-        
-        # 3. NGC energy
-        self._encode_and_settle(pt, settle_steps=self.context_settle_steps, learn=True)
-        base_state = self.field.ngc.save_state()
-        ngc_energies = []
-        for choice in choices:
-            self.field.ngc.restore_state(base_state)
-            r = self._encode_and_settle(
-                self._tokenize_smart(prompt + " " + choice, 64),
-                self.choice_settle_steps,
-                False,
-            )
-            ngc_energies.append(-r["energy"])
-        
-        # 4. Combine
-        def znorm(a):
-            s = a.std()
-            return (a - a.mean()) / s if s > 1e-10 else np.zeros_like(a)
-        
-        scores_arr = znorm(np.array(sentence_sims)) * 1.0 + znorm(np.array(fhrr_sims)) * 0.3 + znorm(np.array(ngc_energies)) * 0.2
-        
-        # 5. Gate
-        sa = np.array(sentence_sims)
-        spread = float(sa.max() - sa.min())
-        mean = float(np.abs(sa).mean())
-        cv = spread / mean if mean > 1e-8 else 0.0
-        
-        shifted = scores_arr - scores_arr.max()
-        probs = np.exp(shifted)
-        probs = probs / probs.sum() if probs.sum() > 0 else np.ones(n) / n
-        entropy = float(-np.sum(probs * np.log(probs + 1e-16)) / np.log(max(n, 2)))
-        
-        thresh = self.confidence_threshold * (3.0 if n <= 2 else 2.0 if n <= 3 else 1.5)
-        if cv < thresh or entropy > 0.97:
-            self._total_gated += 1
-            return [0.0] * n, 1.0
-        return scores_arr.tolist(), entropy
-    
-    def _sentence_similarities(self, prompt, choices):
-        features = self.field.encoder.features
-        if hasattr(features, '_ensure_sbert') and getattr(features, '_sbert', None) is None:
-            features._ensure_sbert()
-        if hasattr(features, '_sbert') and features._sbert is not None and features._sbert != "FALLBACK":
-            embs = features._sbert.encode([prompt] + choices, show_progress_bar=False)
-            pe, pn = embs[0], np.linalg.norm(embs[0])
-            return [float(np.dot(pe, embs[i+1]) / (pn * np.linalg.norm(embs[i+1])))
-                    if pn > 1e-8 and np.linalg.norm(embs[i+1]) > 1e-8 else 0.0
-                    for i in range(len(choices))]
-        pt = self._tokenize_smart(prompt, 64)
-        pf = self.field.encoder.encode_sequence(pt) if pt else np.ones(self.field.fhrr_dim, dtype=np.complex64)
-        out = []
-        for c in choices:
-            ct = self._tokenize_smart(c, 32)
-            enc = self.field.encoder.encode_sequence(ct) if ct else np.ones(self.field.fhrr_dim, dtype=np.complex64)
-            out.append(self.field.encoder.similarity(pf, enc))
-        return out
-    
-    def sentence_similarities(self, prompt, choices):
-        """Public alias for SBERT/FHRR sentence-level similarity tie-breaks (see ``_sentence_similarities``)."""
-        return self._sentence_similarities(prompt, choices)
-    
-    def reset(self):
-        self.field.ngc.reinitialize(12345)
-        self.field.memory.patterns.clear()
-        self.field.memory._matrix = None
-        self.field.memory._dirty = True
-        self.field.energy_history.clear()
-        self.field._step_count = 0
-    
-    @property
-    def statistics(self):
-        return {"total_scored": self._total_scored, "total_gated": self._total_gated,
-                "gate_rate": self._total_gated / max(self._total_scored, 1)}
-
-
-

tensegrity/legacy/__init__.py

@@ -1,5 +0,0 @@
-"""Legacy compatibility modules for architectures superseded by the unified field."""
-
-from . import v1
-
-__all__ = ("v1",)

tensegrity/legacy/v1/__init__.py

@@ -1,19 +0,0 @@
-"""
-Legacy V1 substrate.
-
-This package contains the Morton-coded Markov blanket, flat POMDP active
-inference loop, and compatibility ``TensegrityAgent`` facade. New integrations
-should prefer ``tensegrity.core`` / ``tensegrity.engine`` and the
-``UnifiedField`` energy landscape.
-"""
-
-from tensegrity.legacy.v1.agent import DEFAULT_MEDIATED_SCM_NAME, TensegrityAgent
-from tensegrity.legacy.v1.blanket import MarkovBlanket
-from tensegrity.legacy.v1.morton import MortonEncoder
-
-__all__ = (
-    "DEFAULT_MEDIATED_SCM_NAME",
-    "TensegrityAgent",
-    "MarkovBlanket",
-    "MortonEncoder",
-)

tensegrity/legacy/v1/agent.py

@@ -1,497 +0,0 @@
-"""
-TensegrityAgent: The complete cognitive architecture.
-
-Integrates all components into a single agent that:
-  1. Receives modality-agnostic observations (Morton-encoded)
-  2. Updates beliefs via free energy minimization (no gradients)
-  3. Maintains three memory systems (epistemic, episodic, associative)
-  4. Runs competing causal models in the arena
-  5. Selects actions that minimize expected free energy
-  6. Generates epistemic actions to resolve model uncertainty
-
-The name "Tensegrity" comes from the architectural principle where
-structural integrity comes from the balance of tension and compression.
-Here, the system's cognitive integrity comes from the tension between
-competing causal models (compression = model evidence, tension = model
-disagreement) balanced by the free energy principle.
-"""
-
-import hashlib
-import inspect
-import numpy as np
-from typing import Optional, Dict, List, Any, Tuple
-import logging
-
-from tensegrity.legacy.v1.morton import MortonEncoder
-from tensegrity.legacy.v1.blanket import MarkovBlanket
-from tensegrity.memory.epistemic import EpistemicMemory
-from tensegrity.memory.episodic import EpisodicMemory
-from tensegrity.memory.associative import AssociativeMemory
-from tensegrity.causal.arena import CausalArena
-from tensegrity.causal.scm import StructuralCausalModel
-from tensegrity.inference.free_energy import FreeEnergyEngine
-from tensegrity.engine.unified_field import UnifiedField
-
-logger = logging.getLogger(__name__)
-
-# Default SCM registered in ``_init_default_models`` whose observation vector includes ``cause``.
-DEFAULT_MEDIATED_SCM_NAME = "mediated_causal"
-
-
-class TensegrityAgent:
-    """
-    A non-gradient cognitive agent.
-    
-    The agent perceives the world through Morton-coded observations,
-    maintains beliefs via Bayesian updates, resolves competing causal
-    explanations in an adversarial arena, and acts to minimize
-    expected free energy.
-    
-    No backpropagation. No gradient descent. No optimizer state.
-    
-    All learning is:
-      - Dirichlet counting (epistemic memory)
-      - Context drift (episodic memory)
-      - Energy minimization via Hopfield dynamics (associative memory)
-      - Bayesian model comparison (causal arena)
-      - Fixed-point iteration (belief propagation)
-    """
-    
-    def __init__(self, 
-                 n_states: int = 16,
-                 n_observations: int = 32,
-                 n_actions: int = 4,
-                 sensory_dims: int = 4,
-                 sensory_bits: int = 8,
-                 context_dim: int = 64,
-                 associative_dim: int = 128,
-                 planning_horizon: int = 3,
-                 precision: float = 4.0,
-                 zipf_exponent: float = 1.0,
-                 unified_obs_dim: int = 256,
-                 unified_hidden_dims: Optional[List[int]] = None,
-                 unified_fhrr_dim: int = 2048,
-                 unified_hopfield_beta: float = 0.01,
-                 unified_ngc_settle_steps: int = 20,
-                 unified_ngc_learning_rate: float = 0.005,
-                 epistemic_tension_threshold: float = 0.5,
-                 epistemic_info_gain_threshold: float = 0.1):
-        """
-        Args:
-            n_states: Number of hidden states in the generative model
-            n_observations: Number of observation categories
-            n_actions: Number of possible actions
-            sensory_dims: Dimensionality of raw sensory input
-            sensory_bits: Bits per dimension for Morton encoding
-            context_dim: Dimensionality of episodic context vectors
-            associative_dim: Dimensionality of associative memory patterns
-            planning_horizon: How far ahead to plan
-            precision: Inverse temperature for policy selection
-            zipf_exponent: Controls power-law memory access
-            unified_obs_dim: Observation layer width for UnifiedField (default matches prior hardcoded wiring)
-            unified_hidden_dims: NGC hidden layer sizes; defaults to ``[128, 32]`` when None
-            unified_fhrr_dim: FHRR encoder dimensionality
-            unified_hopfield_beta: Hopfield inverse temperature in UnifiedField
-            unified_ngc_settle_steps: NGC settling iterations
-            unified_ngc_learning_rate: Hebbian learning rate inside UnifiedField
-            epistemic_tension_threshold: Only run costly intervention search when causal tension exceeds this level
-            epistemic_info_gain_threshold: Minimum estimated information gain required for epistemic actions
-        """
-        def _req_pos_int(name: str, v: Any) -> int:
-            if not isinstance(v, int) or int(v) < 1:
-                raise ValueError(f"{name} must be a positive integer")
-            return int(v)
-
-        n_states = _req_pos_int("n_states", n_states)
-        n_observations = _req_pos_int("n_observations", n_observations)
-        n_actions = _req_pos_int("n_actions", n_actions)
-        sensory_dims = _req_pos_int("sensory_dims", sensory_dims)
-        sensory_bits = _req_pos_int("sensory_bits", sensory_bits)
-        context_dim = _req_pos_int("context_dim", context_dim)
-        associative_dim = _req_pos_int("associative_dim", associative_dim)
-        if not isinstance(planning_horizon, int) or planning_horizon < 1:
-            raise ValueError("planning_horizon must be a positive integer")
-        if precision < 0.0:
-            raise ValueError("precision must be non-negative")
-        if zipf_exponent < 0.0:
-            raise ValueError("zipf_exponent must be non-negative")
-        unified_obs_dim = _req_pos_int("unified_obs_dim", unified_obs_dim)
-        if unified_hidden_dims is not None:
-            if not isinstance(unified_hidden_dims, list) or any(
-                not isinstance(x, int) or x < 1 for x in unified_hidden_dims
-            ):
-                raise ValueError("unified_hidden_dims must be a list of positive integers")
-        unified_fhrr_dim = _req_pos_int("unified_fhrr_dim", unified_fhrr_dim)
-        if unified_hopfield_beta < 0.0:
-            raise ValueError("unified_hopfield_beta must be non-negative")
-        unified_ngc_settle_steps = _req_pos_int("unified_ngc_settle_steps", unified_ngc_settle_steps)
-        if unified_ngc_learning_rate < 0.0:
-            raise ValueError("unified_ngc_learning_rate must be non-negative")
-        if not (0.0 <= float(epistemic_tension_threshold) <= 1.0):
-            raise ValueError("epistemic_tension_threshold must be in [0, 1]")
-        if not (0.0 <= float(epistemic_info_gain_threshold) <= 1.0):
-            raise ValueError("epistemic_info_gain_threshold must be in [0, 1]")
-
-        self.n_states = n_states
-        self.n_obs = n_observations
-        self.n_actions = n_actions
-        
-        # === SENSORY INTERFACE (Markov Blanket) ===
-        self.encoder = MortonEncoder(n_dims=sensory_dims, bits_per_dim=sensory_bits)
-        self.blanket = MarkovBlanket(
-            encoder=self.encoder,
-            n_sensory_channels=1,
-            n_active_channels=1,
-            observation_buffer_size=256
-        )
-        
-        # === MEMORY SYSTEMS ===
-        self.epistemic = EpistemicMemory(
-            n_states=n_states,
-            n_observations=n_observations,
-            n_actions=n_actions,
-            zipf_exponent=zipf_exponent
-        )
-        
-        self.episodic = EpisodicMemory(
-            context_dim=context_dim,
-            capacity=10000,
-            drift_rate=0.95,
-            encoding_strength=0.3,
-            zipf_exponent=zipf_exponent
-        )
-        
-        self.associative = AssociativeMemory(
-            pattern_dim=associative_dim,
-            beta=precision,
-            max_patterns=5000,
-            zipf_exponent=zipf_exponent
-        )
-        
-        # === INFERENCE ENGINE ===
-        self.engine = FreeEnergyEngine(
-            n_states=n_states,
-            n_observations=n_observations,
-            n_actions=n_actions,
-            planning_horizon=planning_horizon,
-            precision=precision,
-            policy_depth=min(planning_horizon, 3)
-        )
-        
-        # === CAUSAL ARENA ===
-        self.arena = CausalArena(
-            prior_concentration=1.0,
-            falsification_threshold=-100.0,
-            min_models=2
-        )
-        
-        # === AGENT STATE ===
-        self._step_count = 0
-        self._total_surprise = 0.0
-        self._total_free_energy = 0.0
-        self._prev_belief_for_transition: Optional[np.ndarray] = None
-        self._pending_action: Optional[int] = None
-        self._pending_action_confidence: float = 0.0
-        self._last_action_distribution: Optional[np.ndarray] = None
-        self.epistemic_tension_threshold = float(epistemic_tension_threshold)
-        self.epistemic_info_gain_threshold = float(epistemic_info_gain_threshold)
-        
-        # Initialize with default competing models
-        self._init_default_models()
-        
-        u_hidden = unified_hidden_dims if unified_hidden_dims is not None else [128, 32]
-        # Single perceptual substrate: FHRR → NGC → Hopfield (replaces parallel Morton-sense path).
-        self.field = UnifiedField(
-            obs_dim=unified_obs_dim,
-            hidden_dims=u_hidden,
-            fhrr_dim=unified_fhrr_dim,
-            hopfield_beta=unified_hopfield_beta,
-            ngc_settle_steps=unified_ngc_settle_steps,
-            ngc_learning_rate=unified_ngc_learning_rate,
-        )
-    
-    def _init_default_models(self):
-        """
-        Initialize the causal arena with default competing models.
-        
-        We start with two models that represent competing hypotheses
-        about the causal structure of observations:
-          Model A: "States cause observations directly" (simple)
-          Model B: "States mediate between hidden causes and observations" (complex)
-        """
-        # Model A: Simple — direct state-observation link
-        model_a = StructuralCausalModel(name="direct_causal")
-        model_a.add_variable("state", n_values=self.n_states)
-        model_a.add_variable("observation", n_values=self.n_obs, 
-                           parents=["state"])
-        
-        # Model B: Mediated — hidden cause → state → observation
-        model_b = StructuralCausalModel(name=DEFAULT_MEDIATED_SCM_NAME)
-        model_b.add_variable("cause", n_values=self.n_states)
-        model_b.add_variable("state", n_values=self.n_states,
-                           parents=["cause"])
-        model_b.add_variable("observation", n_values=self.n_obs,
-                           parents=["state"])
-        
-        self.arena.register_model(model_a)
-        self.arena.register_model(model_b)
-    
-    def _morton_to_obs_index(self, morton_codes: np.ndarray) -> int:
-        """Map Morton codes to a discrete observation index (legacy hashing).
-
-        The main ``perceive`` path fingerprints the unified observation vector
-        with SHA-256 modulo ``n_obs``; use this routine only where an explicit
-        Morton-code → observation-bin mapping is intentional.
-        """
-        if self.n_obs <= 0:
-            raise ValueError(
-                "n_observations must be a positive integer for _morton_to_obs_index mapping"
-            )
-        if isinstance(morton_codes, (int, np.integer)):
-            return int(morton_codes) % self.n_obs
-        # For multiple codes, hash the combination
-        combined = 0
-        for code in morton_codes:
-            combined ^= int(code)
-        return combined % self.n_obs
-    
-    def _obs_to_associative_pattern(self, observation: int,
-                                     belief_state: np.ndarray) -> np.ndarray:
-        """Project observation + belief into associative memory space."""
-        rng = np.random.RandomState(observation)
-        
-        # Combine observation (one-hot) and belief state
-        obs_vec = np.zeros(self.n_obs)
-        obs_vec[observation] = 1.0
-        combined = np.concatenate([obs_vec, belief_state])
-        
-        # Random projection to associative_dim
-        W = rng.randn(self.associative.dim, len(combined)) / np.sqrt(len(combined))
-        pattern = W @ combined
-        norm = np.linalg.norm(pattern)
-        if norm > 0:
-            pattern /= norm
-        return pattern
-    
-    def perceive(self, raw_observation: np.ndarray) -> Dict[str, Any]:
-        """
-        One perception path: numeric vector → UnifiedField (FHRR / NGC / Hopfield)
-        → discrete observation index → active inference engine → causal arena.
-
-        Episodic and classical Hopfield associative traces are not written here;
-        memory consolidation for this path lives inside UnifiedField.
-        """
-        self._step_count += 1
-        raw = np.asarray(raw_observation, dtype=np.float64).ravel()
-
-        cycle = self.field.observe(raw, input_type="numeric")
-        obs_vec = cycle["observation"]
-        decomp = cycle["energy"]
-        surprise = float(decomp.surprise)
-
-        # Integer-safe deterministic index from observation vector (avoid float dot overflow)
-        h = hashlib.sha256(obs_vec.astype(np.float64, copy=False).tobytes()).digest()
-        obs_idx = int.from_bytes(h[:8], byteorder="big", signed=False) % max(self.n_obs, 1)
-
-        A = self.epistemic.A
-        B = self.epistemic.B
-        C = self.epistemic.C
-        D = self.epistemic.D
-        log_A = self.epistemic.log_A
-
-        # Capture the action that actually led into this transition before
-        # ``engine.step`` samples the next action for the current state.
-        previous_action = self.engine.prev_action
-        inference_result = self.engine.step(obs_idx, A, B, C, D, log_A)
-        q_states = inference_result["belief_state"]
-        F = float(inference_result["free_energy"])
-
-        self._pending_action = int(inference_result["action"])
-        self._pending_action_confidence = float(inference_result["action_confidence"])
-
-        self.epistemic.update_likelihood(obs_idx, q_states)
-        if (previous_action is not None
-                and self._prev_belief_for_transition is not None):
-            self.epistemic.update_transition(
-                self._prev_belief_for_transition, q_states,
-                previous_action)
-        self._prev_belief_for_transition = q_states.copy()
-
-        causal_obs = {
-            "state": int(np.argmax(q_states)),
-            "observation": obs_idx,
-        }
-        if DEFAULT_MEDIATED_SCM_NAME in self.arena.models:
-            causal_obs["cause"] = int(np.argmax(q_states))
-
-        arena_result = self.arena.compete(causal_obs)
-
-        obs_codes = np.array([obs_idx], dtype=np.int64)
-        self.blanket.surprise = surprise
-
-        # Keep all memory systems live on the unified perception path.  Earlier
-        # versions updated only the UnifiedField's internal Hopfield bank, which
-        # left experience replay and agent introspection effectively empty.
-        assoc_pattern = self._obs_to_associative_pattern(obs_idx, q_states)
-        self.associative.store(
-            assoc_pattern,
-            metadata={"step": self._step_count, "obs_idx": obs_idx, "free_energy": F},
-        )
-        self.episodic.encode(
-            observation=raw,
-            morton_code=obs_codes,
-            belief_state=q_states,
-            action=self._pending_action,
-            surprise=surprise,
-            free_energy=F,
-            metadata={
-                "obs_idx": obs_idx,
-                "field_energy": float(decomp.total),
-                "memory_similarity": float(cycle.get("memory_similarity", 0.0)),
-            },
-        )
-
-        self._total_surprise += surprise
-        self._total_free_energy += F
-
-        return {
-            "step": self._step_count,
-            "obs_codes": obs_codes,
-            "observation_index": obs_idx,
-            "belief_state": q_states,
-            "free_energy": F,
-            "surprise": surprise,
-            "action": inference_result["action"],
-            "action_confidence": inference_result["action_confidence"],
-            "arena": arena_result,
-            "associative_energy": float(decomp.memory),
-            "epistemic_value": self.engine.epistemic_value,
-            "pragmatic_value": self.engine.pragmatic_value,
-            "field_cycle": cycle,
-        }
-    
-    def act(self) -> Dict[str, Any]:
-        """
-        Select and emit an action through the active boundary.
-        
-        Uses the policy posterior from the last perception step.
-        Also checks if an epistemic action (experiment) would be more valuable.
-        """
-        # Check if an experiment would help resolve causal tension.  Intervention
-        # search is intentionally gated because it performs model rollouts; when
-        # the model posterior is already sharp, this was the dominant runtime cost.
-        current_tension = self.arena.current_tension
-        experiment = None
-        if current_tension >= self.epistemic_tension_threshold:
-            experiment = self.arena.suggest_experiment()
-        
-        # Compare epistemic value of experiment vs pragmatic action
-        if (experiment is not None and
-                experiment["expected_info_gain"] > self.epistemic_info_gain_threshold):
-            # Epistemic action: run an experiment to resolve tension
-            return {
-                'type': 'epistemic',
-                'experiment': experiment,
-                'reason': 'High causal tension — exploring to resolve',
-                'tension': current_tension,
-            }
-        
-        # Pragmatic action: act to achieve preferences
-        action_dist = np.zeros(self.n_actions)
-        for pi_idx, policy in enumerate(self.engine.policies):
-            if len(policy) > 0:
-                action_dist[policy[0]] += self.engine.q_policies[pi_idx]
-        if action_dist.sum() > 0:
-            action_dist /= action_dist.sum()
-        else:
-            action_dist[:] = 1.0 / self.n_actions
-        self._last_action_distribution = action_dist.copy()
-        
-        if self._pending_action is None:
-            # Allows act() to be called before the first perceive().
-            action, confidence = self.engine.select_action()
-            self._pending_action = int(action)
-            self._pending_action_confidence = float(confidence)
-        selected = int(self._pending_action)
-        confidence = float(self._pending_action_confidence)
-        self.blanket.active_state = np.array([selected])
-        self._pending_action = None
-        self._pending_action_confidence = 0.0
-        
-        return {
-            'type': 'pragmatic',
-            'action': selected,
-            'confidence': confidence,
-            'action_distribution': action_dist,
-            'free_energy': self.engine.F_history[-1] if self.engine.F_history else None,
-        }
-    
-    def experience_replay(self, n_episodes: int = 10) -> Dict[str, Any]:
-        """
-        Replay past episodes to strengthen beliefs.
-        
-        This is the offline learning loop: re-process past observations
-        through the epistemic memory to update Dirichlet parameters.
-        Weighted by surprise — surprising experiences teach more.
-        """
-        episodes = self.episodic.replay(n_episodes)
-
-        for ep in episodes:
-            obs_idx = ep.metadata.get('obs_idx', 0)
-            self.epistemic.update_likelihood(obs_idx, ep.belief_state)
-        
-        return {
-            'episodes_replayed': len(episodes),
-            'mean_surprise': np.mean([ep.surprise for ep in episodes]) if episodes else 0,
-            'epistemic_entropy': self.epistemic.entropy(),
-        }
-    
-    def introspect(self) -> Dict[str, Any]:
-        """
-        Full introspection: report on all system components.
-        """
-        return {
-            'step': self._step_count,
-            'average_surprise': self._total_surprise / max(self._step_count, 1),
-            'average_free_energy': self._total_free_energy / max(self._step_count, 1),
-            'inference': self.engine.statistics,
-            'arena': self.arena.statistics,
-            'epistemic_memory': {
-                'entropy': self.epistemic.entropy(),
-                'access_distribution': self.epistemic.get_access_distribution(),
-            },
-            'episodic_memory': self.episodic.statistics,
-            'associative_memory': self.associative.statistics,
-            'blanket': self.blanket.state,
-            'tension_trajectory': self.arena.tension_history[-20:],
-            'free_energy_trajectory': self.engine.F_history[-20:],
-        }
-    
-    def add_causal_model(self, model: StructuralCausalModel):
-        """Add a new competing causal model to the arena."""
-        self.arena.register_model(model)
-    
-    def counterfactual(self, evidence: Dict[str, int],
-                       intervention: Dict[str, int],
-                       query: List[str]) -> Dict[str, Any]:
-        """
-        Ask: "What would have happened if we had done X instead?"
-        
-        Each competing model gives its own answer. Disagreement = tension.
-        """
-        return self.arena.counterfactual_comparison(evidence, intervention, query)
-    
-    @classmethod
-    def from_config(cls, config: Dict[str, Any]) -> 'TensegrityAgent':
-        """Create an agent from a configuration dictionary (unknown keys ignored)."""
-        sig = inspect.signature(cls.__init__)
-        allowed = {k for k in sig.parameters if k != "self"}
-        kwargs = {k: v for k, v in config.items() if k in allowed}
-        return cls(**kwargs)
-    
-    def __repr__(self):
-        return (f"TensegrityAgent(states={self.n_states}, obs={self.n_obs}, "
-                f"actions={self.n_actions}, step={self._step_count}, "
-                f"tension={self.arena.current_tension:.3f})")
-
-

tensegrity/legacy/v1/blanket.py

@@ -1,218 +0,0 @@
-"""
-Markov Blanket: The computational boundary of the agent.
-
-In Friston's formalism, the Markov blanket separates internal states (beliefs)
-from external states (world). It consists of:
-  - Sensory states (S): what flows IN from the world (observations)
-  - Active states (A): what flows OUT to the world (actions)
-
-The blanket enforces conditional independence:
-  Internal ⊥ External | Blanket
-
-This is not a metaphor. It's the literal statistical boundary that defines
-where the agent ends and the world begins. The blanket nodes are the ONLY
-points of contact between the agent's belief states and external reality.
-
-Implementation: The blanket manages the flow of Morton-coded observations
-in and action selections out. It also maintains the observation buffer
-that feeds into the free energy engine.
-"""
-
-import numpy as np
-from typing import Optional, Dict, Any, List, Tuple
-from collections import deque
-
-from tensegrity.legacy.v1.morton import MortonEncoder
-
-
-class MarkovBlanket:
-    """
-    The agent's interface with the world.
-    
-    Sensory states receive Morton-coded observations.
-    Active states emit discrete actions.
-    
-    The blanket enforces the Markov property: internal states
-    are conditionally independent of external states given the blanket.
-
-    ``n_sensory`` / ``n_active`` mirror constructor channel counts and are
-    reserved for future multi-channel I/O; ``sense`` still ingests vectors
-    shaped for ``encoder.n_dims``, and ``act`` consumes the full softmax over
-    actions passed in.
-    """
-    
-    def __init__(self, 
-                 encoder: MortonEncoder,
-                 n_sensory_channels: int = 1,
-                 n_active_channels: int = 1,
-                 observation_buffer_size: int = 64):
-        """
-        Args:
-            encoder: MortonEncoder for sensory preprocessing
-            n_sensory_channels: Number of parallel sensory channels
-            n_active_channels: Number of action dimensions
-            observation_buffer_size: How many past observations to retain
-        """
-        self.encoder = encoder
-        self.n_sensory = n_sensory_channels
-        self.n_active = n_active_channels
-        
-        # Current blanket state
-        self.sensory_state: Optional[np.ndarray] = None  # Morton codes
-        self.active_state: Optional[np.ndarray] = None    # Action indices
-        
-        # Observation buffer — recent history for temporal inference
-        self.observation_buffer: deque = deque(maxlen=observation_buffer_size)
-        
-        # Running stats for surprise — per-coordinate counts (variable-length obs).
-        self._sense_timestep = 0
-        self._obs_sum: Optional[np.ndarray] = None
-        self._obs_sq_sum: Optional[np.ndarray] = None
-        self._obs_elem_count: Optional[np.ndarray] = None
-        
-        # Blanket surprise (how unexpected was the last observation?)
-        self.surprise: float = 0.0
-    
-    def sense(self, raw_observation: np.ndarray, *, allow_multi_point_1d: bool = False) -> np.ndarray:
-        """
-        Process a raw observation through the sensory boundary.
-        
-        1. Morton-encode the raw data
-        2. Update the observation buffer
-        3. Compute surprise (deviation from running statistics)
-        
-        Args:
-            raw_observation: Array shaped ``(n_points, encoder.n_dims)``, or ``(n_dims,)``
-                for one point. One-dimensional vectors whose length is not ``n_dims``
-                are rejected unless ``allow_multi_point_1d=True`` is set, which treats
-                the vector as a column (``reshape(-1, 1)``) of scalar observations —
-                callers should prefer supplying an explicit `(n_points, n_dims)` array.
-        
-        Returns:
-            Morton-coded observation as integer array
-        """
-        # Ensure proper shape for Morton encoding
-        if raw_observation.ndim == 1:
-            if len(raw_observation) == self.encoder.n_dims:
-                raw_observation = raw_observation.reshape(1, -1)
-            elif allow_multi_point_1d:
-                raw_observation = raw_observation.reshape(-1, 1)
-            else:
-                raise ValueError(
-                    f"One-dimensional sensory input length {len(raw_observation)} does not match "
-                    f"encoder.n_dims ({self.encoder.n_dims}). Pass shape "
-                    "(n_points, n_dims), a length-n_dims vector for one observation, "
-                    "or opt in with allow_multi_point_1d=True for reshape(-1, 1)."
-                )
-        
-        # Morton encode
-        morton_codes = self.encoder.encode_continuous(raw_observation)
-        if isinstance(morton_codes, (int, np.integer)):
-            morton_codes = np.array([morton_codes])
-
-        self._sense_timestep += 1
-        
-        # Update running statistics for surprise computation
-        self._update_statistics(raw_observation)
-        
-        # Compute surprise: -log P(observation) under running model
-        self.surprise = self._compute_surprise(raw_observation)
-        
-        # Store in buffer
-        self.sensory_state = morton_codes
-        self.observation_buffer.append({
-            'morton': morton_codes.copy(),
-            'raw': raw_observation.copy(),
-            'surprise': self.surprise,
-            'timestamp': self._sense_timestep
-        })
-        
-        return morton_codes
-    
-    def act(self, action_distribution: np.ndarray) -> int:
-        """
-        Select an action through the active boundary.
-        
-        The action is sampled from the distribution provided by the
-        inference engine (policy = softmax over expected free energies).
-        
-        Args:
-            action_distribution: Probability distribution over actions.
-        
-        Returns:
-            Selected action index.
-        """
-        # Ensure valid distribution
-        action_distribution = np.asarray(action_distribution, dtype=np.float64)
-        action_distribution = np.maximum(action_distribution, 1e-16)
-        action_distribution /= action_distribution.sum()
-        
-        # Sample action
-        action = np.random.choice(len(action_distribution), p=action_distribution)
-        self.active_state = np.array([action])
-        return int(action)
-    
-    def _update_statistics(self, observation: np.ndarray):
-        """Update running statistics for surprise computation."""
-        flat = np.asarray(observation, dtype=np.float64).flatten()
-        
-        if self._obs_sum is None:
-            self._obs_sum = np.zeros(len(flat), dtype=np.float64)
-            self._obs_sq_sum = np.zeros(len(flat), dtype=np.float64)
-            self._obs_elem_count = np.zeros(len(flat), dtype=np.float64)
-
-        lf, ls = len(flat), len(self._obs_sum)
-        if lf > ls:
-            self._obs_sum = np.pad(self._obs_sum, (0, lf - ls), mode='constant')
-            self._obs_sq_sum = np.pad(self._obs_sq_sum, (0, lf - ls), mode='constant')
-            self._obs_elem_count = np.pad(self._obs_elem_count, (0, lf - ls), mode='constant')
-
-        n = min(lf, len(self._obs_sum))
-        self._obs_sum[:n] += flat[:n]
-        self._obs_sq_sum[:n] += flat[:n] ** 2
-        self._obs_elem_count[:n] += 1.0
-    
-    def _compute_surprise(self, observation: np.ndarray) -> float:
-        """
-        Compute Bayesian surprise: -log P(o) under running Gaussian model.
-        
-        This is a simple proxy — the full surprise comes from the
-        free energy engine. But this gives a fast heuristic at the boundary.
-        """
-        flat = np.asarray(observation, dtype=np.float64).flatten()
-        assert self._obs_sum is not None and self._obs_elem_count is not None
-        n = min(len(flat), len(self._obs_sum))
-        cnt = self._obs_elem_count[:n]
-        if n < 1 or float(np.min(cnt)) < 2.0:
-            return 0.0
-
-        mean = self._obs_sum[:n] / np.maximum(cnt, 1e-12)
-        var = self._obs_sq_sum[:n] / np.maximum(cnt, 1e-12) - mean ** 2
-        var = np.maximum(var, 1e-8)  # Prevent division by zero
-        
-        # Gaussian log-likelihood (negative = surprise)
-        log_prob = -0.5 * np.sum(((flat[:n] - mean) ** 2) / var + np.log(2 * np.pi * var))
-        return float(-log_prob)  # Higher = more surprising
-    
-    def get_observation_history(self, n: Optional[int] = None) -> List[Dict[str, Any]]:
-        """Get the last n observations from the buffer."""
-        if n is None:
-            return list(self.observation_buffer)
-        return list(self.observation_buffer)[-n:]
-    
-    def get_surprise_trajectory(self) -> np.ndarray:
-        """Get the surprise values over time."""
-        return np.array([obs['surprise'] for obs in self.observation_buffer])
-    
-    @property
-    def state(self) -> Dict[str, Any]:
-        """Current blanket state summary."""
-        return {
-            'sensory': self.sensory_state,
-            'active': self.active_state,
-            'surprise': self.surprise,
-            'sense_timestep': self._sense_timestep,
-            'buffer_size': len(self.observation_buffer)
-        }
-
-

tensegrity/legacy/v1/morton.py

@@ -1,308 +0,0 @@
-"""
-Morton (Z-order) Encoder: Modality-Agnostic Sensory Frontend
-
-Morton codes interleave bits from multiple dimensions into a single integer,
-preserving spatial locality: points close in N-dimensional space map to
-nearby Morton codes. This gives us a UNIVERSAL encoding for any modality.
-
-The key insight: every sensory modality is ultimately a set of measurements
-across dimensions. An image is (x, y, channel). Audio is (time, frequency).
-Text is (position, embedding_dim). Sensor data is (sensor_id, time, value).
-
-By Morton-encoding any of these, we get a single integer that:
-  1. Preserves neighborhood structure (similar inputs → similar codes)
-  2. Is modality-agnostic (the system doesn't "know" what modality it is)
-  3. Enables efficient range queries via bit-prefix matching
-  4. Maps naturally to Bayesian state spaces (discretize → categorize)
-
-Mathematical basis:
-  For k dimensions with coordinates (c₁, c₂, ..., cₖ):
-  Morton(c₁, c₂, ..., cₖ) = interleave_bits(c₁, c₂, ..., cₖ)
-
-  Where interleave_bits takes bit i of dimension j and places it at
-  position i*k + j in the output. This creates a Z-order space-filling curve.
-"""
-
-import numpy as np
-from itertools import product
-from typing import Union, List, Tuple, Optional
-
-
-# Guard against exponential neighborhood enumeration when radius × dims is large.
-MAX_NEIGHBORHOOD_COMBINATIONS = 50_000
-
-
-class MortonEncoder:
-    """
-    Encodes arbitrary-dimensional data into Morton codes (Z-order curve indices).
-    
-    This is the Markov blanket's sensory interface — it transforms raw modality
-    data into a unified discrete state space that the inference engine operates on.
-    
-    The encoding is information-preserving (invertible) and locality-preserving
-    (nearby points in input space → nearby Morton codes).
-    """
-    
-    def __init__(self, n_dims: int, bits_per_dim: int = 10, 
-                 ranges: Optional[List[Tuple[float, float]]] = None):
-        """
-        Args:
-            n_dims: Number of input dimensions (e.g., 2 for image patches, 
-                    3 for volumetric, N for embeddings)
-            bits_per_dim: Resolution per dimension. 10 bits = 1024 levels per dim.
-                         Total Morton code space = 2^(n_dims * bits_per_dim)
-                         Must satisfy n_dims * bits_per_dim <= 63 so codes fit np.int64.
-            ranges: Min/max per dimension for quantization. If None, auto-calibrated.
-        """
-        self.n_dims = n_dims
-        self.bits_per_dim = bits_per_dim
-        total_bits = n_dims * bits_per_dim
-        if total_bits > 63:
-            raise ValueError(
-                f"total_bits (n_dims * bits_per_dim) must be <= 63 to fit in np.int64; "
-                f"got total_bits={total_bits}"
-            )
-        self.total_bits = total_bits
-        self.levels = 2 ** bits_per_dim
-        
-        # Quantization ranges per dimension
-        if ranges is not None:
-            self.ranges = np.asarray(ranges, dtype=np.float64)
-            if self.ranges.ndim != 2 or self.ranges.shape[1] != 2:
-                raise ValueError("ranges must be a sequence of (min, max) tuples per dimension.")
-            spans = self.ranges[:, 1] - self.ranges[:, 0]
-            flat_spans = np.asarray(spans).flatten()
-            bad = np.where(np.abs(flat_spans) < 1e-15)[0]
-            if len(bad):
-                dims_list = [int(i) for i in bad.tolist()]
-                raise ValueError(
-                    "Quantization ranges have zero span on dimension index(es) "
-                    f"{dims_list}; ensure max > min for each dimension "
-                    "(or omit ranges to auto-calibrate from data)."
-                )
-            if int(self.ranges.shape[0]) != int(n_dims):
-                raise ValueError(
-                    f"ranges must have length n_dims ({n_dims}), got shape {self.ranges.shape}."
-                )
-        else:
-            self.ranges = None  # Will be set on first encode (auto-calibrate)
-        
-        # Precompute bit interleaving masks for fast encoding
-        # For k dims, bit i of dim j goes to position i*k + j
-        self._build_interleave_tables()
-    
-    def _build_interleave_tables(self):
-        """Precompute lookup tables for fast bit interleaving."""
-        # For each dimension, build a mask that spreads its bits
-        # across the interleaved positions
-        self._spread_masks = []
-        for dim in range(self.n_dims):
-            # For dimension `dim`, bit position `b` in the input
-            # maps to bit position `b * n_dims + dim` in the output
-            mask_positions = [b * self.n_dims + dim for b in range(self.bits_per_dim)]
-            self._spread_masks.append(mask_positions)
-    
-    def _spread_bits(self, value: int, dim: int) -> int:
-        """Spread bits of a single value according to its dimension's interleave pattern."""
-        result = 0
-        for b in range(self.bits_per_dim):
-            if value & (1 << b):
-                result |= (1 << self._spread_masks[dim][b])
-        return result
-    
-    def _compact_bits(self, morton: int, dim: int) -> int:
-        """Extract and compact bits for a single dimension from a Morton code."""
-        result = 0
-        for b in range(self.bits_per_dim):
-            if morton & (1 << self._spread_masks[dim][b]):
-                result |= (1 << b)
-        return result
-    
-    def quantize(self, values: np.ndarray) -> np.ndarray:
-        """
-        Quantize continuous values to discrete levels.
-        
-        Maps each dimension's range to [0, 2^bits_per_dim - 1] uniformly.
-        This is the analog-to-digital conversion at the sensory boundary.
-        """
-        if self.ranges is None:
-            # Auto-calibrate from data
-            if values.ndim == 1:
-                values = values.reshape(1, -1)
-            self.ranges = np.stack([values.min(axis=0), values.max(axis=0)], axis=1)
-            # Prevent zero-range dimensions
-            zero_range = self.ranges[:, 0] == self.ranges[:, 1]
-            self.ranges[zero_range, 1] = self.ranges[zero_range, 0] + 1.0
-        
-        if values.ndim == 1:
-            values = values.reshape(1, -1)
-        
-        # Normalize to [0, 1] then scale to [0, levels-1]
-        mins = self.ranges[:, 0]
-        maxs = self.ranges[:, 1]
-        spans = np.maximum(maxs - mins, 1e-15)
-        normalized = (values - mins) / spans
-        normalized = np.clip(normalized, 0.0, 1.0)
-        quantized = (normalized * (self.levels - 1)).astype(np.int64)
-        return quantized
-    
-    def dequantize(self, quantized: np.ndarray) -> np.ndarray:
-        """Inverse of quantize — reconstruct continuous approximation."""
-        if self.ranges is None:
-            raise ValueError(
-                "ranges not initialized: call encode (or compute_ranges) "
-                "before MortonEncoder.dequantize"
-            )
-        mins = self.ranges[:, 0]
-        maxs = self.ranges[:, 1]
-        spans = np.maximum(maxs - mins, 1e-15)
-        normalized = quantized.astype(np.float64) / (self.levels - 1)
-        return normalized * spans + mins
-    
-    def encode(self, values: np.ndarray) -> np.ndarray:
-        """
-        Encode N-dimensional data points into Morton codes.
-        
-        Args:
-            values: Shape (n_points, n_dims) or (n_dims,) for single point.
-                   Can be continuous (will be quantized) or already integer.
-        
-        Returns:
-            Morton codes as integer array of shape (n_points,)
-        """
-        single = values.ndim == 1
-        if single:
-            values = values.reshape(1, -1)
-        
-        assert values.shape[1] == self.n_dims, \
-            f"Expected {self.n_dims} dims, got {values.shape[1]}"
-        
-        # Quantize if continuous
-        if values.dtype in (np.float32, np.float64):
-            quantized = self.quantize(values)
-        else:
-            quantized = np.asarray(values, dtype=np.int64)
-            qmin = int(np.min(quantized))
-            qmax = int(np.max(quantized))
-            lo = 0
-            hi = int(self.levels - 1)
-            if qmin < lo or qmax > hi:
-                raise ValueError(
-                    f"MortonEncoder.encode expects integer coords in [{lo}, {hi}] "
-                    f"(levels={self.levels}); got range [{qmin}, {qmax}]"
-                )
-        
-        # Interleave bits for each point
-        n_points = quantized.shape[0]
-        codes = np.zeros(n_points, dtype=np.int64)
-        
-        for i in range(n_points):
-            morton = 0
-            for d in range(self.n_dims):
-                morton |= self._spread_bits(int(quantized[i, d]), d)
-            codes[i] = morton
-        
-        return codes[0] if single else codes
-    
-    def decode(self, codes: Union[int, np.ndarray]) -> np.ndarray:
-        """
-        Decode Morton codes back to N-dimensional coordinates.
-        
-        Args:
-            codes: Morton code(s) as int or array.
-        
-        Returns:
-            Quantized coordinates of shape (n_points, n_dims) or (n_dims,)
-        """
-        single = isinstance(codes, (int, np.integer))
-        if single:
-            codes = np.array([codes], dtype=np.int64)
-        
-        n_points = len(codes)
-        coords = np.zeros((n_points, self.n_dims), dtype=np.int64)
-        
-        for i in range(n_points):
-            for d in range(self.n_dims):
-                coords[i, d] = self._compact_bits(int(codes[i]), d)
-        
-        return coords[0] if single else coords
-    
-    def encode_continuous(self, values: np.ndarray) -> np.ndarray:
-        """Encode continuous data — quantizes automatically."""
-        return self.encode(values.astype(np.float64))
-    
-    def decode_continuous(self, codes: Union[int, np.ndarray]) -> np.ndarray:
-        """Decode Morton codes back to continuous approximations."""
-        quantized = self.decode(codes)
-        if quantized.ndim == 1:
-            quantized = quantized.reshape(1, -1)
-        return self.dequantize(quantized).squeeze()
-    
-    def proximity(self, code_a: int, code_b: int) -> float:
-        """
-        Compute proximity between two Morton codes.
-        
-        Uses the XOR distance: codes that differ only in low-order bits
-        (fine-grained spatial difference) are closer than those differing
-        in high-order bits (coarse spatial difference).
-        
-        Returns value in [0, 1] where 1 = identical.
-        """
-        xor = code_a ^ code_b
-        if xor == 0:
-            return 1.0
-        # Count the position of the highest differing bit
-        highest_diff = int(xor).bit_length()
-        return 1.0 - (highest_diff / self.total_bits)
-    
-    def neighborhood(self, code: int, radius: int = 1) -> List[int]:
-        """
-        Find Morton codes within a given radius (in quantized coordinates).
-
-        Uses ``decode`` → offset enumeration → ``encode`` within ``[0, levels)``.
-        """
-        decoded = self.decode(code)
-        center = (
-            decoded.reshape(-1).astype(np.int64)
-            if isinstance(decoded, np.ndarray)
-            else np.asarray([decoded], dtype=np.int64)
-        )
-        n_combo = int((2 * radius + 1) ** self.n_dims)
-        if n_combo > MAX_NEIGHBORHOOD_COMBINATIONS:
-            raise ValueError(
-                f"MortonEncoder.neighborhood would enumerate {n_combo} quantized offset "
-                f"combinations (n_dims={self.n_dims}, radius={radius}, levels={self.levels}), "
-                f"which exceeds MAX_NEIGHBORHOOD_COMBINATIONS={MAX_NEIGHBORHOOD_COMBINATIONS}; "
-                "reduce radius or n_dims."
-            )
-
-        offsets = range(-radius, radius + 1)
-        neighbors: List[int] = []
-        for tup in product(offsets, repeat=self.n_dims):
-            offset = np.array(tup, dtype=np.int64)
-            point = center + offset
-            if np.all(point >= 0) and np.all(point < self.levels):
-                neighbors.append(int(self.encode(point.reshape(1, -1))))
-        return sorted(set(neighbors))
-    
-    @staticmethod
-    def from_modality(modality: str, **kwargs) -> 'MortonEncoder':
-        """
-        Factory for common modality configurations.
-        
-        Args:
-            modality: One of 'image', 'audio', 'text', 'timeseries', 'generic'
-        """
-        configs = {
-            'image': {'n_dims': 3, 'bits_per_dim': 8},      # x, y, channel
-            'audio': {'n_dims': 2, 'bits_per_dim': 12},      # time, frequency
-            'text': {'n_dims': 2, 'bits_per_dim': 10},       # position, feature
-            'timeseries': {'n_dims': 2, 'bits_per_dim': 14}, # time, value
-            'generic': {'n_dims': kwargs.get('n_dims', 4), 'bits_per_dim': 8},
-        }
-        config = configs.get(modality, configs['generic'])
-        config.update(kwargs)
-        return MortonEncoder(**config)
-
-
-

tensegrity/pipeline/canonical.py

@@ -226,16 +226,6 @@ class CanonicalPipeline:
         self._choice_model_names: List[str] = []
         self._last_derived_obs: List[Dict[str, int]] = []
 
-        # --- Persistent causal knowledge ---
-        # Domain-level SCMs persist across items within a task. Instead of
-        # rebuilding every SCM from scratch per item (which gives uniform CPTs
-        # that contribute noise), we maintain a library of domain SCMs keyed
-        # by task domain. When a new item arrives, we look up existing SCMs
-        # for that domain and re-register them with accumulated experience.
-        # Per-choice ephemeral SCMs are still created, but the domain SCM
-        # provides a prior that shapes the per-choice energy competition.
-        self._domain_scm_library: Dict[str, StructuralCausalModel] = {}
-
         if self.persistent_state_path:
             self.load_state(self.persistent_state_path)
 
@@ -296,15 +286,14 @@ class CanonicalPipeline:
         self._scm_topologies = {}
         self._choice_model_names = []
         self._last_derived_obs = []
-
-        # Determine domain for persistent SCM lookup
-        domain = sample.metadata.get("domain", "general")
-
         for i, label in enumerate(labels[:len(sample.choices)]):
-            scm = self._build_choice_scm(i, label, domain=domain)
+            scm = self._build_choice_scm(i, label)
             try:
                 self.energy_arena.register(scm)
                 self._choice_model_names.append(scm.name)
+                # Project this SCM's DAG into the NGC layer hierarchy via
+                # TopologyMapper. Horizontal causal edges are resolved through
+                # virtual parents at higher levels (the "elevator shaft" fix).
                 n_ngc_layers = len(self.controller.agent.field.ngc.layer_sizes)
                 topology = self._topology_mapper.from_scm(scm, n_layers=n_ngc_layers)
                 self._scm_topologies[scm.name] = topology
@@ -356,46 +345,23 @@ class CanonicalPipeline:
 
     # ---------- per-choice SCM (used by EnergyCausalArena) ----------
 
-    def _build_choice_scm(self, choice_idx: int, label: str,
-                          domain: str = "general") -> StructuralCausalModel:
+    def _build_choice_scm(self, choice_idx: int, label: str) -> StructuralCausalModel:
         """
-        Build a per-choice SCM, seeded with persistent domain knowledge.
+        Build a tiny SCM for one choice:
 
-        The structure is always:
             prompt_feature  ──▶  choice_match  ──▶  observation
                                                 ▲
                                                 │ (lateral) coherence
 
-        But CPTs are initialized from the domain SCM library if a matching
-        domain model exists. This means the per-choice SCMs start with
-        accumulated experience from prior items in the same domain, not
-        uniform Dirichlet priors. The domain model is the persistent
-        causal knowledge that survives across items.
+        The DAG has both vertical and horizontal edges. The TopologyMapper
+        is exactly what turns the lateral coherence link into a virtual parent
+        in the NGC hierarchy, addressing the topological-mismatch critique.
         """
         scm = StructuralCausalModel(name=f"choice_{choice_idx}_{label}")
         scm.add_variable("prompt_feature", n_values=4, parents=[])
         scm.add_variable("coherence", n_values=4, parents=[])
         scm.add_variable("choice_match", n_values=4, parents=["prompt_feature"])
         scm.add_variable("observation", n_values=4, parents=["choice_match", "coherence"])
-
-        # Seed from domain library if available
-        domain_key = f"domain_{domain}"
-        if domain_key in self._domain_scm_library:
-            domain_scm = self._domain_scm_library[domain_key]
-            # Copy accumulated CPTs from the domain model
-            for var_name, mech in scm.mechanisms.items():
-                domain_mech = domain_scm.mechanisms.get(var_name)
-                if domain_mech is not None and mech.cpt.shape == domain_mech.cpt.shape:
-                    mech.cpt[:] = domain_mech.cpt
-        else:
-            # Create a new domain SCM for future seeding
-            domain_scm = StructuralCausalModel(name=domain_key)
-            domain_scm.add_variable("prompt_feature", n_values=4, parents=[])
-            domain_scm.add_variable("coherence", n_values=4, parents=[])
-            domain_scm.add_variable("choice_match", n_values=4, parents=["prompt_feature"])
-            domain_scm.add_variable("observation", n_values=4, parents=["choice_match", "coherence"])
-            self._domain_scm_library[domain_key] = domain_scm
-
         return scm
 
     # ---------- one-shot ingest (delegates to controller) ----------
@@ -421,61 +387,73 @@ class CanonicalPipeline:
         self, prompt: str, choices: List[str]
     ) -> Tuple[np.ndarray, List[Dict[str, int]]]:
         """
-        For each choice c_i:
-          1. Save NGC base state (prompt-grounded after perceive).
-          2. Encode c_i alone, settle NGC under it.
-          3. Ask the field to top-down predict the prompt observation.
-          4. score_i = -prediction_error.
-          5. Discretize the obs/pred for use as energy-arena observations.
+        Real falsification in SBERT embedding space.
 
-        Returns (scores, energy_arena_observations).
+        For each choice c_i:
+          1. Save NGC state after settling on the prompt.
+          2. Get SBERT embedding of choice c_i.
+          3. Settle NGC on the choice embedding.
+          4. Ask NGC to predict what layer 0 should look like (top-down).
+          5. score_i = -||prediction - prompt_embedding||²
+
+        This is genuine falsification: "if the answer is c_i, and the NGC
+        has learned the structure of how answers relate to questions in
+        embedding space, does c_i's abstract state predict the prompt?"
+
+        The NGC W matrices learn across items. After 50+ items, they encode
+        real structure: questions in domain X tend to have answers with
+        embedding pattern Y. This is knowledge the LLM doesn't have —
+        it's cross-item structural knowledge accumulated by the cognitive layer.
         """
         field = self.controller.agent.field
-        prompt_tokens = _alphanum_tokens(prompt, max_tokens=64)
-        prompt_obs = field._fhrr_to_obs(field.encoder.encode_sequence(prompt_tokens))
 
-        # Snapshot the prompt-grounded state to restore between choices.
+        # Get SBERT embeddings directly
+        prompt_obs = field.text_to_obs(prompt)
+
+        # Settle on prompt first to ground the NGC
         try:
+            field.ngc.settle(prompt_obs)
             base_state = field.ngc.save_state()
         except Exception:
             base_state = None
 
         scores = np.zeros(len(choices), dtype=np.float64)
         derived_obs: List[Dict[str, int]] = []
+
         for i, c in enumerate(choices):
             if base_state is not None:
                 try:
                     field.ngc.restore_state(base_state)
                 except Exception:
                     pass
-            ctoks = _alphanum_tokens(c, max_tokens=32)
-            choice_obs = field._fhrr_to_obs(field.encoder.encode_sequence(ctoks))
+
+            # Get SBERT embedding of the choice (or prompt+choice for context)
+            choice_obs = field.text_to_obs(f"{prompt} {c}")
+
             try:
                 field.ngc.settle(choice_obs, steps=self.falsify_settle_steps)
-                pe = float(field.ngc.prediction_error(prompt_obs))
+                # Prediction: what does the NGC think layer 0 should look like
+                # given the abstract state it settled into for this choice?
+                predicted = field.ngc.predict_observation()
+                # Score: how well does this prediction match the prompt embedding?
+                pe = float(np.sum((prompt_obs - predicted) ** 2))
             except Exception as e:
-                logger.error(
-                    "NGC falsification failed for choice %d: %s",
-                    i, e, exc_info=True,
-                )
+                logger.error("NGC falsification failed for choice %d: %s", i, e)
                 pe = float(1e9)
             scores[i] = -pe
 
-            # Derive a compact discrete observation for the energy arena.
-            # Each variable is bucketed into 4 levels to match the per-choice
-            # SCM cardinality. The buckets are deterministic from the field
-            # state, not random.
+            # Derive discrete observations for the energy arena
             try:
-                pred_obs = field.ngc.predict_observation()
-                pf = self._bucket_4(float(np.dot(prompt_obs, prompt_obs) ** 0.5))
-                cm = self._bucket_4(-pe)
-                co = self._bucket_4(float(np.dot(pred_obs, prompt_obs)))
-                ob = self._bucket_4(float(np.linalg.norm(pred_obs)))
+                pf = self._bucket_4(float(np.linalg.norm(prompt_obs)))
+                cm = self._bucket_4(-pe / max(float(np.linalg.norm(prompt_obs)) ** 2, 1.0))
+                co = self._bucket_4(float(
+                    np.dot(predicted, prompt_obs) /
+                    (np.linalg.norm(predicted) * np.linalg.norm(prompt_obs) + 1e-10)
+                ))
+                ob = self._bucket_4(float(np.linalg.norm(predicted)))
                 derived_obs.append({
-                    "prompt_feature": pf,
-                    "choice_match": cm,
-                    "coherence": co,
-                    "observation": ob,
+                    "prompt_feature": pf, "choice_match": cm,
+                    "coherence": co, "observation": ob,
                 })
             except Exception:
                 derived_obs.append({
@@ -483,8 +461,7 @@ class CanonicalPipeline:
                     "coherence": 0, "observation": 0,
                 })
 
-        # Restore the prompt-grounded state so subsequent perceive calls aren't
-        # contaminated by the last falsification settle.
+        # Restore prompt-grounded state
         if base_state is not None:
             try:
                 field.ngc.restore_state(base_state)
@@ -853,11 +830,9 @@ class CanonicalPipeline:
     def _sbert_choice_scores(self, sample: TaskSample) -> np.ndarray:
         """Score choices by SBERT sentence-level cosine similarity.
 
-        This is the strongest semantic signal: it compares the prompt against
-        each choice using frozen sentence embeddings from a pretrained SBERT
-        model. Unlike the NGC falsification path, this signal is NOT destroyed
-        by the random FHRR→obs projection and directly measures semantic
-        relatedness in the original embedding space.
+        Uses field.text_to_obs() which goes directly to SBERT embeddings
+        when available, giving the cognitive layer the same semantic signal
+        it uses for NGC falsification and Hopfield memory.
         """
         n = len(sample.choices)
         scores = np.zeros(n, dtype=np.float64)
@@ -865,83 +840,66 @@ class CanonicalPipeline:
             return scores
 
         field = self.controller.agent.field
-        features = field.encoder.features
-        # Try to get the SBERT model from the semantic codebook
-        getter = getattr(features, "get_sbert_model", None)
-        sbert = getter() if callable(getter) else None
-        if sbert is None:
+        prompt_emb = field.get_sbert_embedding(sample.prompt)
+        if prompt_emb is None:
+            return scores
+
+        pn = float(np.linalg.norm(prompt_emb))
+        if pn < 1e-8:
             return scores
 
         try:
-            texts = [sample.prompt] + [
-                f"{sample.prompt} {c}" for c in sample.choices
-            ]
-            embs = sbert.encode(texts, show_progress_bar=False)
-            pe = embs[0]
-            pn = float(np.linalg.norm(pe))
-            if pn < 1e-8:
-                return scores
-            for i in range(n):
-                ce = embs[i + 1]
-                cn = float(np.linalg.norm(ce))
-                if cn > 1e-8:
-                    scores[i] = float(np.dot(pe, ce) / (pn * cn))
+            for i, c in enumerate(sample.choices):
+                choice_emb = field.get_sbert_embedding(f"{sample.prompt} {c}")
+                if choice_emb is not None:
+                    cn = float(np.linalg.norm(choice_emb))
+                    if cn > 1e-8:
+                        scores[i] = float(np.dot(prompt_emb, choice_emb) / (pn * cn))
         except Exception as e:
             logger.debug("SBERT choice scoring failed: %s", e)
 
         return scores
 
     def _memory_choice_scores(self, sample: TaskSample) -> np.ndarray:
-        """Retrieve prior successful episodes and score choices by similarity.
+        """Score choices by Hopfield memory retrieval in SBERT space.
 
-        This is the persistent memory channel inside the same posterior update
-        as predictive-coding falsification, causal energy, and LLM evidence.
+        The Hopfield bank now stores full SBERT embeddings. We query it with
+        the prompt's SBERT embedding and measure how similar the retrieved
+        memory is to each choice's embedding. This gives real cross-item
+        transfer: "past prompts similar to this one had answers similar to
+        choice X."
         """
         n = len(sample.choices)
         scores = np.zeros(n, dtype=np.float64)
         if n == 0:
             return scores
 
-        episodic = getattr(self.controller.agent, "episodic", None)
-        if episodic is None or not getattr(episodic, "episodes", None):
+        field = self.controller.agent.field
+        if field.memory.n_patterns == 0:
             return scores
 
-        field = self.controller.agent.field
-        prompt_fhrr = self._encode_text_fhrr(sample.prompt, max_tokens=96)
-        prompt_obs = field._fhrr_to_obs(prompt_fhrr)
-        query_belief = np.full(n, 1.0 / n, dtype=np.float64)
+        prompt_emb = field.get_sbert_embedding(sample.prompt)
+        if prompt_emb is None:
+            return scores
 
+        # Retrieve from Hopfield memory using prompt SBERT embedding
         try:
-            query_ctx = episodic.compute_item_representation(prompt_obs, query_belief)
-            retrieved = episodic.retrieve_by_context(query_context=query_ctx, k=8)
+            retrieved, _energy = field.memory.retrieve(prompt_emb)
         except Exception as e:
-            logger.debug("persistent episodic retrieval skipped: %s", e)
+            logger.debug("memory retrieval failed: %s", e)
             return scores
 
-        if not retrieved:
+        ret_norm = np.linalg.norm(retrieved)
+        if ret_norm < 1e-8:
             return scores
 
-        choice_vecs = [
-            self._unit_real(self._encode_text_fhrr(choice, max_tokens=48))
-            for choice in sample.choices
-        ]
-        for ep in retrieved:
-            meta = getattr(ep, "metadata", {}) or {}
-            correct_vec = meta.get("correct_fhrr_real")
-            if correct_vec is None:
-                continue
-            correct_vec = np.asarray(correct_vec, dtype=np.float64)
-            cn = np.linalg.norm(correct_vec)
-            if cn <= 1e-10:
-                continue
-            correct_vec = correct_vec / cn
-            ctx_sim = float(np.dot(query_ctx, ep.context_vector))
-            if ctx_sim <= 0.0:
-                continue
-            confidence = 1.0 - float(ep.surprise)
-            weight = ctx_sim * max(0.05, confidence)
-            for i, choice_vec in enumerate(choice_vecs):
-                scores[i] += weight * float(np.dot(choice_vec, correct_vec))
+        # Score each choice by similarity to retrieved memory
+        for i, c in enumerate(sample.choices):
+            choice_emb = field.get_sbert_embedding(f"{sample.prompt} {c}")
+            if choice_emb is not None:
+                cn = float(np.linalg.norm(choice_emb))
+                if cn > 1e-8:
+                    scores[i] = float(np.dot(retrieved, choice_emb) / (ret_norm * cn))
 
         return scores
 
@@ -977,18 +935,23 @@ class CanonicalPipeline:
                         gold_rank_score = 1.0 / n  # no discrimination
                     self._channel_alpha[name] += gold_rank_score * 0.5
         field = self.controller.agent.field
-        prompt_fhrr = self._encode_text_fhrr(sample.prompt, max_tokens=96)
-        correct_fhrr = self._encode_text_fhrr(
-            f"{sample.prompt} {sample.choices[sample.gold]}",
-            max_tokens=128,
-        )
-        prompt_obs = field._fhrr_to_obs(prompt_fhrr)
-        correct_obs = field._fhrr_to_obs(correct_fhrr)
+
+        # Store the correct answer's SBERT embedding in Hopfield memory.
+        # This is the cross-item learning signal: future prompts will
+        # retrieve this embedding and use it to score choices.
+        correct_text = f"{sample.prompt} {sample.choices[sample.gold]}"
+        correct_emb = field.get_sbert_embedding(correct_text)
+        if correct_emb is not None:
+            field.memory.store(correct_emb)
+
+        # Settle NGC on the correct answer's SBERT embedding and learn.
+        # This teaches the W matrices the structure of correct Q→A mappings.
+        correct_obs = field.text_to_obs(correct_text)
+        prompt_obs = field.text_to_obs(sample.prompt)
 
         try:
             field.ngc.settle(correct_obs, steps=max(1, self.falsify_settle_steps))
             field.ngc.learn(modulation=max(0.0, self.feedback_learning_rate))
-            field.memory.store(field.ngc.get_abstract_state(level=-1))
         except Exception as e:
             logger.debug("feedback NGC learning skipped: %s", e)
 
@@ -1039,19 +1002,6 @@ class CanonicalPipeline:
                 except Exception as e:
                     logger.debug("feedback SCM update skipped: %s", e)
 
-            # Update the persistent domain SCM with the gold-label observation.
-            # This is what makes the causal arena accumulate experience: the
-            # domain SCM's CPTs evolve with each feedback signal, and future
-            # items in the same domain start with this accumulated knowledge.
-            domain = sample.metadata.get("domain", "general")
-            domain_key = f"domain_{domain}"
-            domain_scm = self._domain_scm_library.get(domain_key)
-            if domain_scm is not None and self._last_derived_obs:
-                try:
-                    domain_scm.update_from_data([self._last_derived_obs[sample.gold]])
-                except Exception as e:
-                    logger.debug("domain SCM update skipped: %s", e)
-
         try:
             self.controller.agent.experience_replay(n_episodes=3)
         except Exception as e:

tensegrity/pipeline/iterative.py

@@ -1,466 +0,0 @@
-"""
-Iterative cognitive scorer — LLM-free multi-pass settling over choices.
-
-Single-shot ScoringBridge encodes prompt once, settles NGC once per choice,
-fuses sentence + FHRR + NGC scores in one shot. The graft results show this
-behaves like an undifferentiated bias field.
-
-This iterative scorer instead runs an active-inference loop:
-  1. Encode prompt context, settle NGC, learn (ground the field).
-  2. Initialize uniform belief over choices.
-  3. For each iteration up to a budget:
-     a. Score each choice via NGC free-energy under the *current* field state.
-     b. Update beliefs by accumulating evidence (Bayesian-style log-odds).
-     c. Take the leading choice's encoding, learn a small Hebbian step under
-        it (modulation = belief mass), shaping the field toward that
-        interpretation.
-     d. Optionally retrieve from Hopfield with the leading encoding to inject
-        memory pressure.
-     e. Check convergence: top-1 belief mass > τ, or marginal change < ε.
-  4. Commit argmax.
-
-The LLM is absent. The cognitive layer alone resolves the choice.
-"""
-from __future__ import annotations
-
-import re
-import logging
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Tuple
-
-import numpy as np
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class IterationTrace:
-    iteration: int
-    energies: List[float]
-    sentence_sims: List[float]
-    fhrr_sims: List[float]
-    log_belief: List[float]
-    belief: List[float]
-    top_idx: int
-    top_p: float
-
-
-@dataclass
-class IterativeResult:
-    scores: List[float]                # final fused scores per choice
-    belief: List[float]                # final belief vector per choice
-    committed_idx: int
-    iterations_used: int
-    converged: bool
-    trace: List[IterationTrace] = field(default_factory=list)
-
-
-class IterativeCognitiveScorer:
-    """
-    Multi-pass cognitive scorer over a UnifiedField.
-
-    No LLM in the loop. Operates on prompt+choices via:
-      - sbert sentence similarity (one-shot, doesn't change across iterations)
-      - FHRR similarity (one-shot)
-      - NGC free energy (recomputed each iteration as the field is shaped)
-      - Hopfield retrieval (cumulative memory pressure across iterations)
-    """
-
-    def __init__(
-        self,
-        field=None,
-        *,
-        obs_dim: int = 256,
-        hidden_dims: Optional[List[int]] = None,
-        fhrr_dim: int = 2048,
-        ngc_settle_steps: int = 30,
-        ngc_learning_rate: float = 0.01,
-        hopfield_beta: float = 0.05,
-        # iteration controls
-        max_iterations: int = 6,
-        convergence_top_p: float = 0.75,
-        convergence_delta: float = 1e-3,
-        # context settling
-        context_settle_steps: int = 40,
-        choice_settle_steps: int = 25,
-        context_learning_epochs: int = 3,
-        # fusion weights (z-scored)
-        w_sbert: float = 0.5,
-        w_fhrr: float = 0.3,
-        w_ngc: float = 1.0,
-        w_falsify: float = 0.7,
-        # belief update step
-        belief_step: float = 0.6,
-        # Hebbian shaping is now under the prompt context (not the leading choice),
-        # so iteration deepens the prompt model rather than reinforcing the leader.
-        shaping_lr_scale: float = 0.5,
-        # Hopfield: store leading encoding each iteration; query each iteration
-        use_hopfield: bool = True,
-        hopfield_steps: int = 2,
-        # Episodic memory persists across items in a session. At the start of
-        # each item we retrieve past episodes whose context matches the current
-        # prompt and use their stored chosen-answer FHRR vectors to bias the
-        # current choices — the cross-item learning channel.
-        use_episodic: bool = True,
-        episodic_context_dim: int = 64,
-        episodic_capacity: int = 4096,
-        episodic_top_k: int = 8,
-        # Default off: the simple "past-answer FHRR similarity" signal is too
-        # noisy to help. The wiring (encode/retrieve) stays so smarter signals
-        # can be plugged in here without re-plumbing.
-        w_episodic: float = 0.0,
-        # Minimum cosine match between query and episodic context to trust retrieval.
-        episodic_ctx_sim_threshold: float = 0.5,
-        # Seed for NGC `reinitialize` on `reset`; None chooses a random seed each time.
-        reset_seed: Optional[int] = 12345,
-    ):
-        from tensegrity.engine.unified_field import UnifiedField
-        from tensegrity.memory.episodic import EpisodicMemory
-        self.field = field or UnifiedField(
-            obs_dim=obs_dim,
-            hidden_dims=hidden_dims or [128, 32],
-            fhrr_dim=fhrr_dim,
-            hopfield_beta=hopfield_beta,
-            ngc_settle_steps=ngc_settle_steps,
-            ngc_learning_rate=ngc_learning_rate,
-        )
-        self.max_iterations = max_iterations
-        self.convergence_top_p = convergence_top_p
-        self.convergence_delta = convergence_delta
-        self.context_settle_steps = context_settle_steps
-        self.choice_settle_steps = choice_settle_steps
-        self.context_learning_epochs = context_learning_epochs
-        self.w_sbert = w_sbert
-        self.w_fhrr = w_fhrr
-        self.w_ngc = w_ngc
-        self.w_falsify = w_falsify
-        self.belief_step = belief_step
-        self.shaping_lr_scale = shaping_lr_scale
-        self.use_hopfield = use_hopfield
-        self.hopfield_steps = hopfield_steps
-        self.use_episodic = use_episodic
-        self.episodic_top_k = episodic_top_k
-        self.w_episodic = w_episodic
-        self.episodic_ctx_sim_threshold = episodic_ctx_sim_threshold
-        self.reset_seed = reset_seed
-        # Dirichlet-style per-channel reliability. Each channel accumulates a
-        # pseudocount that grows when the channel's top-ranked choice matches
-        # the committed belief on an item. Fusion weights = normalized counts.
-        # Uniform prior of 1.0 means we start with equal trust; the system
-        # discovers which channels are reliable for the current task on its own.
-        self._channels = ["sbert", "fhrr", "ngc", "falsify", "hop", "episodic"]
-        self._channel_counts: Dict[str, float] = {c: 1.0 for c in self._channels}
-        self.episodic = EpisodicMemory(
-            context_dim=episodic_context_dim,
-            capacity=episodic_capacity,
-            drift_rate=0.95,
-            encoding_strength=0.3,
-        ) if use_episodic else None
-
-    # ---------- text helpers ----------
-
-    def _tokenize(self, text: str, max_tokens: int = 48) -> List[str]:
-        return re.findall(r"[a-zA-Z]+(?:'[a-z]+)?|[0-9]+(?:\.[0-9]+)?", text.lower())[-max_tokens:]
-
-    def _encode(self, tokens: List[str]) -> np.ndarray:
-        if not tokens:
-            return np.ones(self.field.fhrr_dim, dtype=np.complex64)
-        return self.field.encoder.encode_sequence(tokens)
-
-    # ---------- one-shot signals (computed once per item) ----------
-
-    def _sbert_similarities(self, prompt: str, choices: List[str]) -> List[float]:
-        features = self.field.encoder.features
-        getter = getattr(features, "get_sbert_model", None)
-        sbert = getter() if callable(getter) else None
-        if sbert is not None:
-            embs = sbert.encode([prompt] + choices, show_progress_bar=False)
-            pe = embs[0]
-            pn = float(np.linalg.norm(pe))
-            out = []
-            for i in range(len(choices)):
-                ce = embs[i + 1]
-                cn = float(np.linalg.norm(ce))
-                out.append(float(np.dot(pe, ce) / (pn * cn)) if pn > 1e-8 and cn > 1e-8 else 0.0)
-            return out
-        if self.field.encoder.semantic and callable(getter) and not getattr(
-            self, "_sbert_unavailable_logged", False
-        ):
-            logger.warning("SBERT sentence similarity unavailable; using FHRR cosine similarity.")
-            setattr(self, "_sbert_unavailable_logged", True)
-        pf = self._encode(self._tokenize(prompt, 64))
-        return [
-            self.field.encoder.similarity(pf, self._encode(self._tokenize(c, 32)))
-            for c in choices
-        ]
-
-    def _fhrr_similarities(self, prompt: str, choices: List[str]) -> List[float]:
-        pf = self._encode(self._tokenize(prompt, 64))
-        return [
-            self.field.encoder.similarity(pf, self._encode(self._tokenize(c, 32)))
-            for c in choices
-        ]
-
-    # ---------- iterative loop ----------
-
-    def score(self, prompt: str, choices: List[str]) -> IterativeResult:
-        n = len(choices)
-        if n == 0:
-            return IterativeResult(scores=[], belief=[], committed_idx=-1,
-                                   iterations_used=0, converged=False)
-
-        # 1. One-shot signals
-        sbert_sims = np.asarray(self._sbert_similarities(prompt, choices), dtype=np.float64)
-        fhrr_sims = np.asarray(self._fhrr_similarities(prompt, choices), dtype=np.float64)
-
-        # 2. Encode + settle prompt context, learn it
-        prompt_tokens = self._tokenize(prompt, max_tokens=64)
-        for _ in range(max(1, self.context_learning_epochs)):
-            ctx_obs = self.field._fhrr_to_obs(self._encode(prompt_tokens))
-            self.field.ngc.settle(ctx_obs, steps=self.context_settle_steps)
-            self.field.ngc.learn(modulation=1.0)
-        base_state = self.field.ngc.save_state()
-
-        # Pre-tokenize choice contexts (prompt+choice for joint settling)
-        choice_token_lists = [self._tokenize(prompt + " " + c, 64) for c in choices]
-        choice_obs = [self.field._fhrr_to_obs(self._encode(t)) for t in choice_token_lists]
-        # Choice-only obs (for falsification: settle under choice alone, then predict prompt)
-        choice_only_obs = [
-            self.field._fhrr_to_obs(self._encode(self._tokenize(c, 32))) for c in choices
-        ]
-        choice_fhrr = [self._encode(self._tokenize(c, 32)) for c in choices]
-        # Cache prompt observation vector for falsification target
-        prompt_obs_vec = self.field._fhrr_to_obs(self._encode(prompt_tokens))
-
-        # Episodic retrieval: project current prompt into context space and ask
-        # the episodic store for similar past episodes. Each retrieved episode
-        # carries the FHRR of the answer that won there. We bias current
-        # choices by their similarity to those past winners, weighted by the
-        # context match. This is the cross-item memory channel.
-        episodic_bias = np.zeros(n, dtype=np.float64)
-        if self.use_episodic and self.episodic is not None and len(self.episodic.episodes) > 0:
-            uniform_belief = np.full(n, 1.0 / n, dtype=np.float64)
-            try:
-                query_ctx = self.episodic.compute_item_representation(
-                    prompt_obs_vec, uniform_belief
-                )
-                retrieved = self.episodic.retrieve_by_context(
-                    query_context=query_ctx, k=self.episodic_top_k
-                )
-            except Exception as e:
-                logger.debug("episodic retrieval skipped: %s", e)
-                retrieved = []
-            if retrieved:
-                # Real-valued unit-norm choice vectors (cached for reuse)
-                ch_real = []
-                for f in choice_fhrr:
-                    v = np.real(f).astype(np.float64)
-                    nrm = np.linalg.norm(v)
-                    ch_real.append(v / nrm if nrm > 1e-10 else v)
-                # Only trust episodes whose prompt context strongly matches.
-                # Below this threshold, "similar past answer" is noise, not signal.
-                for ep in retrieved:
-                    ans_vec = ep.metadata.get("chosen_fhrr_real") if ep.metadata else None
-                    if ans_vec is None:
-                        continue
-                    ctx_sim = float(np.dot(query_ctx, ep.context_vector))
-                    if ctx_sim < self.episodic_ctx_sim_threshold:
-                        continue
-                    # Also discount by past surprise: episodes the agent struggled
-                    # with (low committed confidence) carry less authority.
-                    confidence = max(0.0, 1.0 - float(ep.surprise))
-                    weight = ctx_sim * confidence
-                    if weight <= 0:
-                        continue
-                    for i in range(n):
-                        episodic_bias[i] += weight * float(np.dot(ch_real[i], ans_vec))
-
-        # 3. Initialize belief uniformly in log space
-        log_belief = np.zeros(n, dtype=np.float64)
-
-        trace: List[IterationTrace] = []
-        prev_belief = np.ones(n) / n
-        converged = False
-        iterations_used = 0
-        last_channel_scores: Dict[str, np.ndarray] = {}
-
-        def znorm(a: np.ndarray) -> np.ndarray:
-            s = a.std()
-            return (a - a.mean()) / s if s > 1e-10 else np.zeros_like(a)
-
-        for it in range(self.max_iterations):
-            iterations_used = it + 1
-
-            # 3a. Score each choice under current field state.
-            # Two NGC signals:
-            #   energies: free energy of settling on (prompt+choice) jointly.
-            #   falsify:  -prediction_error of (prompt | settled-on-choice-alone).
-            #             This asks "does this choice's state predict the prompt?"
-            #             — a real falsification operation, not a fit score.
-            energies = np.zeros(n, dtype=np.float64)
-            falsify = np.zeros(n, dtype=np.float64)
-            for i in range(n):
-                self.field.ngc.restore_state(base_state)
-                r = self.field.ngc.settle(choice_obs[i], steps=self.choice_settle_steps)
-                energies[i] = float(r["final_energy"])
-
-                # Falsification: settle under choice-only, then ask the field
-                # to predict the prompt observation. Higher prediction error =
-                # this choice does a worse job of explaining the prompt.
-                self.field.ngc.restore_state(base_state)
-                self.field.ngc.settle(choice_only_obs[i], steps=self.choice_settle_steps)
-                pe = self.field.ngc.prediction_error(prompt_obs_vec)
-                falsify[i] = -float(pe)
-            ngc_score = -energies
-
-            # Hopfield bonus: similarity of choice FHRR to retrieved memory
-            hop_bonus = np.zeros(n, dtype=np.float64)
-            if self.use_hopfield and self.field.memory.n_patterns > 0:
-                for i in range(n):
-                    q = np.real(choice_fhrr[i]).astype(np.float64)
-                    qn = np.linalg.norm(q)
-                    if qn < 1e-8:
-                        continue
-                    q = q / qn
-                    retrieved, _e = self.field.memory.retrieve(q, steps=self.hopfield_steps)
-                    rn = np.linalg.norm(retrieved)
-                    if rn > 1e-8:
-                        hop_bonus[i] = float(np.dot(q, retrieved / rn))
-
-            # 3b. Fuse z-normalized
-            # Normalized channel weights from accumulated reliability counts.
-            total = sum(self._channel_counts.values())
-            w = {c: self._channel_counts[c] / total for c in self._channels}
-
-            channel_scores = {
-                "sbert": znorm(sbert_sims),
-                "fhrr": znorm(fhrr_sims),
-                "ngc": znorm(ngc_score),
-                "falsify": znorm(falsify),
-                "hop": znorm(hop_bonus) if self.use_hopfield else np.zeros(n),
-                "episodic": znorm(episodic_bias) if self.use_episodic else np.zeros(n),
-            }
-            fused = sum(w[c] * channel_scores[c] for c in self._channels)
-            last_channel_scores = channel_scores
-
-            # 3c. Accumulate evidence into log-belief
-            log_belief = log_belief + self.belief_step * fused
-            shifted = log_belief - log_belief.max()
-            belief = np.exp(shifted)
-            belief = belief / belief.sum() if belief.sum() > 0 else np.ones(n) / n
-
-            top_idx = int(np.argmax(belief))
-            top_p = float(belief[top_idx])
-
-            trace.append(IterationTrace(
-                iteration=it,
-                energies=energies.tolist(),
-                sentence_sims=sbert_sims.tolist(),
-                fhrr_sims=fhrr_sims.tolist(),
-                log_belief=log_belief.tolist(),
-                belief=belief.tolist(),
-                top_idx=top_idx,
-                top_p=top_p,
-            ))
-
-            # 3d. Hebbian shaping under the PROMPT (not the leading choice).
-            # This deepens the field's model of the question over iterations
-            # without injecting a positive-feedback loop on the leader.
-            self.field.ngc.restore_state(base_state)
-            self.field.ngc.settle(prompt_obs_vec, steps=self.context_settle_steps)
-            self.field.ngc.learn(modulation=self.shaping_lr_scale)
-
-            # Re-base on the prompt-grounded state for next iteration's scoring
-            base_state = self.field.ngc.save_state()
-
-            # 3f. Convergence checks
-            db = float(np.max(np.abs(belief - prev_belief)))
-            prev_belief = belief
-            if top_p >= self.convergence_top_p or db < self.convergence_delta:
-                converged = True
-                break
-
-        # Store prompt encoding once for Hopfield cross-item memory (not each iteration).
-        if self.use_hopfield:
-            self.field.memory.store(self._encode(prompt_tokens))
-
-        committed_idx = int(np.argmax(prev_belief))
-
-        # Reliability update via *cross-channel agreement* (not agreement with
-        # the committed belief — that would be self-fulfilling). Each channel
-        # earns one pseudocount per OTHER active channel that picked the same
-        # top choice. The consensus structure is the anchor; no single
-        # channel is privileged. Channels tracking signal grow together;
-        # noisy outliers don't.
-        if last_channel_scores and n > 1:
-            active = []
-            for c in self._channels:
-                cs = last_channel_scores.get(c)
-                if cs is None:
-                    continue
-                if not np.any(np.abs(cs) > 1e-12):
-                    continue
-                active.append((c, int(np.argmax(cs))))
-            for i, (c_i, top_i) in enumerate(active):
-                agreements = sum(
-                    1 for j, (_, top_j) in enumerate(active) if j != i and top_j == top_i
-                )
-                if agreements > 0:
-                    self._channel_counts[c_i] += float(agreements) / max(len(active) - 1, 1)
-
-        # Episodic encoding: store the prompt context together with the FHRR
-        # of the chosen answer, so future items can retrieve "what worked
-        # last time on a similar prompt."
-        if self.use_episodic and self.episodic is not None:
-            top_p_final = float(prev_belief[committed_idx]) if n > 0 else 0.0
-            chosen_real = np.real(choice_fhrr[committed_idx]).astype(np.float64)
-            chosen_norm = np.linalg.norm(chosen_real)
-            if chosen_norm > 1e-10:
-                chosen_real = chosen_real / chosen_norm
-            try:
-                self.episodic.encode(
-                    observation=prompt_obs_vec,
-                    morton_code=np.zeros(1, dtype=np.int64),
-                    belief_state=np.asarray(prev_belief, dtype=np.float64),
-                    action=committed_idx,
-                    surprise=float(1.0 - top_p_final),
-                    free_energy=float(np.mean(energies) if n > 0 else 0.0),
-                    metadata={"chosen_fhrr_real": chosen_real},
-                )
-            except Exception as e:
-                logger.debug("episodic encode skipped: %s", e)
-
-        return IterativeResult(
-            scores=log_belief.tolist(),
-            belief=prev_belief.tolist(),
-            committed_idx=committed_idx,
-            iterations_used=iterations_used,
-            converged=converged,
-            trace=trace,
-        )
-
-    def reset(self):
-        """Per-item reset. Clears NGC working state but PRESERVES Hopfield
-        patterns and episodic memory — those carry across items in a session
-        and provide cross-item learning.
-
-        NGC weights are reinitialized using ``reset_seed``: default ``12345``
-        matches legacy behavior for reproducibility; pass ``None`` for a random
-        seed each reset, or any other integer to pin runs.
-        """
-        seed = self.reset_seed
-        if seed is None:
-            seed = int(np.random.randint(0, 2 ** 31))
-        self.field.ngc.reinitialize(seed)
-        self.field.energy_history.clear()
-        self.field._step_count = 0
-
-    def reset_session(self):
-        """Full reset. Use at task / session boundaries to clear all memory
-        and per-channel reliability priors (which are task-specific)."""
-        self.reset()
-        self.field.memory.clear()
-        if self.episodic is not None:
-            self.episodic.clear()
-        for c in self._channels:
-            self._channel_counts[c] = 1.0