Add initial project configuration and dependencies

- Introduced `pyproject.toml` for project metadata, specifying the name, version, description, and required Python version.
- Listed essential dependencies including `numpy`, `scipy`, `torch`, and others for the project.
- Added `uv.lock` to manage package versions and ensure reproducibility.
- Updated evaluation runner to use semantic field scoring instead of the previous Tensegrity v2 scoring.
- Enhanced the cognitive controller with new hypothesis generation capabilities and session management.
- Implemented a new causal energy framework for model competition based on prediction errors.
- Introduced FHRR-RNS encoding for compositional observation encoding, enhancing semantic processing capabilities.
- Established a unified cognitive engine integrating various components for improved performance and flexibility.

pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "tensegrity"
+version = "0.1.0"
+description = "Non-gradient cognitive architecture (free energy, causal models, Markov blankets)"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "numpy",
+    "scipy",
+    "networkx",
+    "pydantic",
+    "openai",
+    "torch",
+    "transformers",
+    "accelerate",
+    "datasets",
+    "sentence-transformers"
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[build-system]
+requires = ["hatchling>=1.13"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["tensegrity"]

tensegrity/bench/runner.py

@@ -185,8 +185,8 @@ class EvalRunner:
     Runs baseline vs grafted evaluation on any set of tasks.
 
     Modes:
-      "local"   — Uses transformers model + confidence-gated Tensegrity v2 scoring
-      "offline"  — No LLM; baseline = random, grafted = v2 scoring
+      "local"   — Uses transformers model + confidence-gated semantic field scoring
+      "offline"  — No LLM; baseline = random, grafted = field scoring
 
     Local mode blending:
       effective_λ = λ * (1 - LLM_confidence / confidence_gate_threshold)
@@ -246,18 +246,18 @@ class EvalRunner:
         return scores
 
     def _get_tensegrity_scores(self, sample: TaskSample) -> Tuple[List[float], float]:
-        """Run Tensegrity v2 scoring bridge on a sample."""
-        from tensegrity.v2.graft import V2ScoringBridge
-        if not hasattr(self, '_v2_bridge'):
-            self._v2_bridge = V2ScoringBridge(
+        """Run semantic field scoring (ScoringBridge) on a sample."""
+        from tensegrity.engine.scoring import ScoringBridge
+        if not hasattr(self, '_field_scorer'):
+            self._field_scorer = ScoringBridge(
                 obs_dim=256, hidden_dims=[128, 32], 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,
             )
-        self._v2_bridge.reset()
-        return self._v2_bridge.score_choices(sample.prompt, sample.choices)
+        self._field_scorer.reset()
+        return self._field_scorer.score_choices(sample.prompt, sample.choices)
 
     def evaluate_sample(self, sample: TaskSample) -> SampleResult:
         """Evaluate a single sample with confidence-gated blending."""

tensegrity/broca/controller.py

@@ -31,11 +31,15 @@ from tensegrity.broca.schemas import (
     BeliefState,
     CognitiveAction,
     Hypothesis,
+    RelationMention,
 )
 from tensegrity.broca.interface import BrocaInterface
+from tensegrity.causal.from_proposal import build_scm_from_proposal
 
 logger = logging.getLogger(__name__)
 
+IMPLICIT_RELATION_WEIGHT = 0.3
+
 
 class CognitiveController:
     """
@@ -60,7 +64,8 @@ class CognitiveController:
                  broca: Optional[BrocaInterface] = None,
                  n_hypotheses: int = 8,
                  hypothesis_labels: Optional[List[str]] = None,
-                 use_llm: bool = True):
+                 use_llm: bool = True,
+                 enable_hypothesis_generation: bool = False):
         """
         Args:
             agent: TensegrityAgent instance. Created with defaults if None.
@@ -68,8 +73,10 @@ class CognitiveController:
             n_hypotheses: Number of competing hypotheses to maintain
             hypothesis_labels: Labels for the hypothesis space
             use_llm: If False, uses template-based parse/produce (for testing without API)
+            enable_hypothesis_generation: If True and use_llm, may add LLM-proposed SCMs when tension is high
         """
         self.use_llm = use_llm
+        self.enable_hypothesis_generation = enable_hypothesis_generation
         
         # Cognitive substrate
         n_states = n_hypotheses
@@ -121,6 +128,88 @@ class CognitiveController:
             3: "state_conclusion",
         }
     
+    def reset_session(self, hypothesis_labels: List[str]) -> None:
+        """
+        Start a fresh session for an independent item (e.g. one benchmark sample).
+
+        Rebuilds the substrate agent with dimensions matched to the hypothesis
+        count and clears conversational artifacts.
+        """
+        labels = list(hypothesis_labels)
+        if not labels:
+            labels = ["_empty_"]
+        n_hyp = max(len(labels), 2)
+        self.agent = TensegrityAgent(
+            n_states=n_hyp,
+            n_observations=n_hyp * 4,
+            n_actions=4,
+            sensory_dims=n_hyp,
+            sensory_bits=4,
+            context_dim=32,
+            associative_dim=64,
+            planning_horizon=2,
+            precision=4.0,
+        )
+        self.belief_state = BeliefState(
+            turn=0,
+            hypotheses=[],
+            eliminated_hypotheses=[],
+            confirmed_facts=[],
+            open_questions=[],
+            current_tension=1.0,
+            epistemic_urgency=1.0,
+            free_energy=0.0,
+        )
+        self._init_hypotheses(labels)
+        self._conversation.clear()
+    
+    def perceive_only(self, input_text: str) -> Dict[str, Any]:
+        """
+        Parse and run perception + belief update only (no action / no verbalization).
+        """
+        self.belief_state.turn += 1
+        if self.use_llm and self.broca:
+            parsed = self.broca.parse(input_text, context=self._get_parse_context())
+        else:
+            parsed = self._template_parse(input_text)
+        obs_vector = self._observation_to_vector(parsed)
+        perception = self.agent.perceive(obs_vector)
+        self._maybe_inject_causal_hypothesis(perception, input_text)
+        self._update_hypotheses_from_inference(perception, obs_vector)
+        for entity in parsed.entities:
+            fact = (
+                f"[T{self.belief_state.turn}] Observed: {entity.normalized} "
+                f"({entity.entity_type})"
+            )
+            self.belief_state.confirmed_facts.append(fact)
+        for relation in parsed.relations:
+            fact = (
+                f"[T{self.belief_state.turn}] {relation.subject} "
+                f"{relation.predicate} {relation.object}"
+            )
+            if relation.negated:
+                fact = f"NOT({fact})"
+            self.belief_state.confirmed_facts.append(fact)
+        for relation in parsed.implicit_relations:
+            fact = (
+                f"[T{self.belief_state.turn}] (implicit) {relation.subject} "
+                f"{relation.predicate} {relation.object}"
+            )
+            if relation.negated:
+                fact = f"NOT({fact})"
+            self.belief_state.confirmed_facts.append(fact)
+        return {
+            "perception": {
+                "free_energy": perception["free_energy"],
+                "surprise": perception["surprise"],
+                "tension": perception["arena"]["tension"],
+                "epistemic_value": perception["epistemic_value"],
+            },
+            "belief_state": self.belief_state.model_dump(),
+            "parsed_input": parsed.model_dump(),
+            "turn": self.belief_state.turn,
+        }
+    
     def _init_hypotheses(self, labels: List[str]):
         """Initialize the hypothesis space with uniform priors."""
         n = len(labels)
@@ -135,6 +224,63 @@ class CognitiveController:
             for i, label in enumerate(labels)
         ]
     
+    @staticmethod
+    def _apply_relation_evidence(
+        features: np.ndarray,
+        hyp_labels: Dict[str, int],
+        relations: List[RelationMention],
+        weight: float,
+    ) -> None:
+        """Add hypothesis-indexed evidence from typed relations (scaled by weight)."""
+        for relation in relations:
+            subj = relation.subject.lower()
+            obj = relation.object.lower()
+            subj_matches = [i for label, i in hyp_labels.items() if subj in label or label in subj]
+            obj_matches = [i for label, i in hyp_labels.items() if obj in label or label in obj]
+            sign = -1.0 if relation.negated else 1.0
+            w = weight
+            if relation.predicate in ("causes", "enables", "confirms", "is_a", "has_property"):
+                for idx in obj_matches:
+                    features[idx] += 0.8 * sign * w
+                for idx in subj_matches:
+                    features[idx] += 0.4 * sign * w
+            elif relation.predicate in ("prevents", "contradicts"):
+                for idx in obj_matches:
+                    features[idx] -= 0.8 * sign * w
+                for idx in subj_matches:
+                    features[idx] -= 0.3 * sign * w
+    
+    def _maybe_inject_causal_hypothesis(self, perception: Dict[str, Any], input_text: str) -> None:
+        """If causal fit is poor, ask Broca for a new SCM and register it (LLM only)."""
+        if not self.enable_hypothesis_generation or not self.use_llm or not self.broca:
+            return
+        if not hasattr(self.broca, "propose_causal_hypothesis"):
+            return
+        ar = perception.get("arena") or {}
+        if ar.get("tension", 0) < 0.72:
+            return
+        lls = ar.get("log_likelihoods") or {}
+        if lls and max(lls.values()) > -2.0:
+            return
+        try:
+            names = list(self.agent.arena.models.keys())
+            prop = self.broca.propose_causal_hypothesis(input_text[:2000], names)
+            scm = build_scm_from_proposal(prop)
+            if scm.name in self.agent.arena.models:
+                return
+            self.agent.add_causal_model(scm)
+            q = perception["belief_state"]
+            obs_idx = perception["observation_index"]
+            causal_obs: Dict[str, int] = {
+                "state": int(np.argmax(q)),
+                "observation": int(obs_idx),
+            }
+            if "mediated_causal" in self.agent.arena.models:
+                causal_obs["cause"] = int(np.argmax(q))
+            perception["arena"] = self.agent.arena.compete(causal_obs)
+        except Exception as e:
+            logger.warning("Dynamic causal hypothesis skipped: %s", e)
+    
     def _observation_to_vector(self, parsed: ParsedObservation) -> np.ndarray:
         """
         Convert a ParsedObservation into a numeric vector for Tensegrity.
@@ -165,26 +311,10 @@ class CognitiveController:
                     if ename in label or label in ename:
                         features[idx] += 0.5
         
-        for relation in parsed.relations:
-            subj = relation.subject.lower()
-            obj = relation.object.lower()
-            
-            # Find which hypotheses the subject/object refer to
-            subj_matches = [i for label, i in hyp_labels.items() if subj in label or label in subj]
-            obj_matches = [i for label, i in hyp_labels.items() if obj in label or label in obj]
-            
-            sign = -1.0 if relation.negated else 1.0
-            
-            if relation.predicate in ("causes", "enables", "confirms", "is_a", "has_property"):
-                for idx in obj_matches:
-                    features[idx] += 0.8 * sign
-                for idx in subj_matches:
-                    features[idx] += 0.4 * sign
-            elif relation.predicate in ("prevents", "contradicts"):
-                for idx in obj_matches:
-                    features[idx] -= 0.8 * sign
-                for idx in subj_matches:
-                    features[idx] -= 0.3 * sign
+        self._apply_relation_evidence(features, hyp_labels, parsed.relations, weight=1.0)
+        self._apply_relation_evidence(
+            features, hyp_labels, parsed.implicit_relations, weight=IMPLICIT_RELATION_WEIGHT,
+        )
         
         # Linguistic confidence modulates the whole vector
         features *= parsed.confidence_linguistic
@@ -388,6 +518,7 @@ class CognitiveController:
         # === 2. PROCESS (Tensegrity cognition) ===
         obs_vector = self._observation_to_vector(parsed)
         perception = self.agent.perceive(obs_vector)
+        self._maybe_inject_causal_hypothesis(perception, input_text)
         
         # Update hypothesis probabilities from Tensegrity beliefs
         self._update_hypotheses_from_inference(perception, obs_vector)
@@ -403,6 +534,15 @@ class CognitiveController:
                 fact = f"NOT({fact})"
             self.belief_state.confirmed_facts.append(fact)
         
+        for relation in parsed.implicit_relations:
+            fact = (
+                f"[T{self.belief_state.turn}] (implicit) {relation.subject} "
+                f"{relation.predicate} {relation.object}"
+            )
+            if relation.negated:
+                fact = f"NOT({fact})"
+            self.belief_state.confirmed_facts.append(fact)
+        
         # === 3. SELECT ACTION (Tensegrity decides) ===
         action = self._select_cognitive_action(perception)
         
@@ -588,6 +728,7 @@ class CognitiveController:
         return ParsedObservation(
             entities=entities,
             relations=relations,
+            implicit_relations=[],
             is_question=is_question,
             is_assertion=not is_question and not is_command,
             is_command=is_command,

tensegrity/broca/interface.py

@@ -17,7 +17,7 @@ data that doesn't match the schema.
 import os
 import json
 import logging
-from typing import Optional, Type, TypeVar, Union
+from typing import Optional, Type, TypeVar, Union, List
 
 from pydantic import BaseModel
 
@@ -28,6 +28,7 @@ from tensegrity.broca.schemas import (
     QuestionUtterance,
     BeliefState,
     CognitiveAction,
+    ProposedSCM,
 )
 
 logger = logging.getLogger(__name__)
@@ -132,9 +133,12 @@ class BrocaInterface:
             ParsedObservation with typed fields
         """
         system_prompt = (
-            "You are a linguistic parser. Extract structured information from the input. "
-            "Do NOT interpret, evaluate, reason about, or add to the content. "
-            "Extract only what is explicitly stated. "
+            "You are a linguistic parser. Extract structured information from the input.\n"
+            "relations: predicates that are DIRECTLY stated in the text.\n"
+            "implicit_relations: the SAME RelationMention shape for links that are NOT quoted "
+            "but are logically required for the scenario to hold (commonsense bridges only). "
+            "Keep implicit_relations sparse; do not invent unrelated facts.\n"
+            "Do NOT output prose reasoning — only typed fields. "
             "If something is unclear, set confidence_linguistic lower."
         )
         if context:
@@ -148,6 +152,34 @@ class BrocaInterface:
         self._parse_calls += 1
         return self._call_llm(messages, ParsedObservation, self.max_parse_tokens)
     
+    def propose_causal_hypothesis(
+        self,
+        situation_summary: str,
+        existing_model_names: List[str],
+    ) -> ProposedSCM:
+        """
+        Propose a new structural causal model when existing SCMs fit poorly.
+
+        Returns a bounded DAG schema only (no free-form reasoning).
+        """
+        system_prompt = (
+            "You are a causal model designer. Propose ONE small directed acyclic graph "
+            "as variable names and typed edges (causes / prevents / enables). "
+            "Use short snake_case identifiers. At most 12 edges. "
+            "Name must differ from existing model names. Output only the schema fields."
+        )
+        existing = ", ".join(existing_model_names[:24]) if existing_model_names else "(none)"
+        user_content = (
+            f"Existing models: {existing}\n\n"
+            f"Observations / situation:\n{situation_summary[:2400]}"
+        )
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_content},
+        ]
+        self._parse_calls += 1
+        return self._call_llm(messages, ProposedSCM, self.max_parse_tokens)
+    
     def parse_feedback(self, feedback: str, 
                        action_taken: str,
                        hypotheses: list) -> ParsedFeedback:

tensegrity/broca/schemas.py

@@ -43,6 +43,20 @@ class RelationMention(BaseModel):
     negated: bool = False
 
 
+class CausalEdge(BaseModel):
+    """One edge in a proposed structural causal model (SCM)."""
+    source: str = Field(description="Cause or enabling variable name")
+    target: str = Field(description="Effect variable name")
+    mechanism: Literal["causes", "prevents", "enables"]
+
+
+class ProposedSCM(BaseModel):
+    """LLM-proposed SCM as a named DAG plus short description."""
+    name: str = Field(max_length=64, description="Short identifier, suitable for SCM.name")
+    description: str = Field(max_length=512, description="One sentence: what this model claims")
+    edges: List[CausalEdge] = Field(max_length=48, description="Directed edges; must be acyclic")
+
+
 class ParsedObservation(BaseModel):
     """
     Schema for LLM-as-parser: convert natural language into structured observation.
@@ -51,6 +65,13 @@ class ParsedObservation(BaseModel):
     """
     entities: List[EntityMention] = Field(default_factory=list)
     relations: List[RelationMention] = Field(default_factory=list)
+    implicit_relations: List[RelationMention] = Field(
+        default_factory=list,
+        description=(
+            "Typed implications required for consistency with the text but not literally stated; "
+            "use closed predicates only (same vocabulary as relations)."
+        ),
+    )
     is_question: bool = Field(description="Is the input asking for information?")
     is_assertion: bool = Field(description="Is the input stating a fact/claim?")
     is_command: bool = Field(description="Is the input requesting an action?")

tensegrity/causal/from_proposal.py

@@ -0,0 +1,46 @@
+"""
+Build a StructuralCausalModel from a structured LLM proposal (ProposedSCM).
+"""
+
+from __future__ import annotations
+
+import logging
+import networkx as nx
+
+from tensegrity.broca.schemas import ProposedSCM
+from tensegrity.causal.scm import StructuralCausalModel
+
+logger = logging.getLogger(__name__)
+
+
+def build_scm_from_proposal(proposal: ProposedSCM, n_values: int = 4) -> StructuralCausalModel:
+    """
+    Convert a ProposedSCM into a StructuralCausalModel with discrete variables.
+    Drops edges that would create cycles. Variable order follows a topological sort.
+    """
+    G = nx.DiGraph()
+    for e in proposal.edges:
+        G.add_edge(e.source.strip(), e.target.strip())
+
+    if G.number_of_nodes() == 0:
+        logger.warning("ProposedSCM '%s' has no edges; returning empty SCM", proposal.name)
+        scm = StructuralCausalModel(name=proposal.name[:60])
+        scm.add_variable("observation", n_values=n_values, parents=[])
+        return scm
+
+    if not nx.is_directed_acyclic_graph(G):
+        # Greedily remove edges that introduce cycles (reverse insertion order)
+        edges_list = [(e.source.strip(), e.target.strip()) for e in proposal.edges]
+        G.clear()
+        for s, t in edges_list:
+            G.add_edge(s, t)
+            if not nx.is_directed_acyclic_graph(G):
+                G.remove_edge(s, t)
+                logger.debug("Dropped cyclic edge %s -> %s", s, t)
+
+    order = list(nx.topological_sort(G))
+    scm = StructuralCausalModel(name=proposal.name[:60].replace(" ", "_"))
+    for node in order:
+        parents = sorted(G.predecessors(node))
+        scm.add_variable(node, n_values=n_values, parents=parents)
+    return scm

tensegrity/core/agent.py

@@ -28,6 +28,7 @@ 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__)
 
@@ -132,9 +133,20 @@ class TensegrityAgent:
         self._step_count = 0
         self._total_surprise = 0.0
         self._total_free_energy = 0.0
+        self._prev_belief_for_transition: Optional[np.ndarray] = None
         
         # Initialize with default competing models
         self._init_default_models()
+        
+        # Single perceptual substrate: FHRR → NGC → Hopfield (replaces parallel Morton-sense path).
+        self.field = UnifiedField(
+            obs_dim=256,
+            hidden_dims=[128, 32],
+            fhrr_dim=2048,
+            hopfield_beta=0.01,
+            ngc_settle_steps=20,
+            ngc_learning_rate=0.005,
+        )
     
     def _init_default_models(self):
         """
@@ -192,107 +204,71 @@ class TensegrityAgent:
     
     def perceive(self, raw_observation: np.ndarray) -> Dict[str, Any]:
         """
-        Process a raw observation through the full perception pipeline.
-        
-        1. Morton-encode the raw data (Markov blanket sensory boundary)
-        2. Map to observation index
-        3. Run free energy minimization (state inference)
-        4. Update all memory systems
-        5. Run causal arena competition
-        6. Store in episodic memory
-        7. Update associative memory
-        
-        Args:
-            raw_observation: Raw sensory data of any modality.
-                           Shape: (n_points, sensory_dims) or (sensory_dims,)
-        
-        Returns:
-            Perception results including beliefs, surprise, free energy
+        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
-        
-        # === 1. MARKOV BLANKET: Morton encode ===
-        morton_codes = self.blanket.sense(raw_observation)
-        obs_idx = self._morton_to_obs_index(morton_codes)
-        
-        # === 2. INFERENCE ENGINE: Minimize free energy ===
+        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)
+
+        # Deterministic discrete index for generative-model matrices
+        v = np.arange(1, len(obs_vec) + 1, dtype=np.float64)
+        obs_idx = int(np.abs(np.dot(obs_vec, v))) % 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
-        
+
         inference_result = self.engine.step(obs_idx, A, B, C, D, log_A)
-        q_states = inference_result['belief_state']
-        F = inference_result['free_energy']
-        
-        # === 3. EPISTEMIC MEMORY: Bayesian counting update ===
+        q_states = inference_result["belief_state"]
+        F = float(inference_result["free_energy"])
+
         self.epistemic.update_likelihood(obs_idx, q_states)
-        if self.engine.prev_action is not None and self._step_count > 1:
-            # Get previous belief state from episodic memory
-            prev_episodes = self.episodic.get_sequence(
-                self._step_count - 2, self._step_count - 2)
-            if prev_episodes:
-                prev_belief = prev_episodes[0].belief_state
-                self.epistemic.update_transition(
-                    prev_belief, q_states, self.engine.prev_action)
-        
-        # === 4. CAUSAL ARENA: Compete ===
-        # Map observation to causal variable values
+        if (self.engine.prev_action is not None
+                and self._prev_belief_for_transition is not None):
+            self.epistemic.update_transition(
+                self._prev_belief_for_transition, q_states,
+                self.engine.prev_action)
+        self._prev_belief_for_transition = q_states.copy()
+
         causal_obs = {
-            'state': int(np.argmax(q_states)),
-            'observation': obs_idx,
+            "state": int(np.argmax(q_states)),
+            "observation": obs_idx,
         }
-        # Add 'cause' for the mediated model
-        if 'mediated_causal' in self.arena.models:
-            causal_obs['cause'] = int(np.argmax(q_states))  # Best guess
-        
+        if "mediated_causal" in self.arena.models:
+            causal_obs["cause"] = int(np.argmax(q_states))
+
         arena_result = self.arena.compete(causal_obs)
-        
-        # === 5. EPISODIC MEMORY: Encode experience ===
-        episode = self.episodic.encode(
-            observation=raw_observation,
-            morton_code=morton_codes if isinstance(morton_codes, np.ndarray) 
-                       else np.array([morton_codes]),
-            belief_state=q_states,
-            action=self.engine.prev_action,
-            surprise=self.blanket.surprise,
-            free_energy=F,
-            metadata={
-                'obs_idx': obs_idx,
-                'arena_winner': arena_result['winner'],
-                'tension': arena_result['tension'],
-            }
-        )
-        
-        # === 6. ASSOCIATIVE MEMORY: Store pattern ===
-        pattern = self._obs_to_associative_pattern(obs_idx, q_states)
-        self.associative.store(pattern, metadata={
-            'obs_idx': obs_idx,
-            'step': self._step_count,
-            'surprise': self.blanket.surprise,
-        })
-        
-        # === 7. ASSOCIATIVE RETRIEVAL: Pattern completion ===
-        retrieved_pattern, energy = self.associative.retrieve(pattern, return_energy=True)
-        
-        # Track cumulative metrics
-        self._total_surprise += self.blanket.surprise
+
+        morton_codes = np.array([obs_idx], dtype=np.int64)
+        self.blanket.surprise = surprise
+
+        self._total_surprise += surprise
         self._total_free_energy += F
-        
+
         return {
-            'step': self._step_count,
-            'morton_codes': morton_codes,
-            'observation_index': obs_idx,
-            'belief_state': q_states,
-            'free_energy': F,
-            'surprise': self.blanket.surprise,
-            'action': inference_result['action'],
-            'action_confidence': inference_result['action_confidence'],
-            'arena': arena_result,
-            'associative_energy': energy,
-            'epistemic_value': self.engine.epistemic_value,
-            'pragmatic_value': self.engine.pragmatic_value,
+            "step": self._step_count,
+            "morton_codes": morton_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]:

tensegrity/engine/__init__.py

@@ -0,0 +1,18 @@
+"""
+Unified cognitive engine: compositional encoding, predictive coding, unified field,
+semantic scoring, and optional energy-based causal competition.
+"""
+
+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
+from tensegrity.engine.scoring import ScoringBridge, NGCLogitsProcessor

tensegrity/{v2 → engine}/causal_energy.py

@@ -10,13 +10,8 @@ Where:
     pa(v) = parents of v in the causal DAG
 
 Multiple SCMs compete. The model with lowest causal energy provides
-the best explanation. This replaces the v1 causal arena's log-likelihood
-comparison with a unified energy-based comparison.
-
-The causal energy connects to the NGC energy through shared variables:
-if a causal variable maps to an NGC layer's abstract state, then the
-NGC prediction error and the causal prediction error are literally
-the same quantity at different scales of description.
+the best explanation. This complements the log-likelihood CausalArena in ``tensegrity.causal.arena``
+when an energy-based readout of SCM fit is required.
 """
 
 import numpy as np
@@ -81,18 +76,9 @@ class CausalEnergyTerm:
         return mech.cpt[:, config_idx]
 
 
-class CausalArenaV2:
+class EnergyCausalArena:
     """
-    v2 causal arena: SCMs compete via energy, not log-likelihood.
-    
-    Each model is wrapped in a CausalEnergyTerm. The model with
-    lowest energy wins. The tension is the ratio of energies
-    (or equivalently, the softmax distribution over models).
-    
-    This integrates with the unified energy landscape:
-      E_total = E_perception(NGC) + E_memory(Hopfield) + E_causal(arena)
-    
-    Where E_causal = min_k E_causal(M_k) — we use the best model's energy.
+    SCMs compete via prediction-error energy. Lowest energy wins.
     """
     
     def __init__(self, precision: float = 1.0, beta: float = 1.0):

tensegrity/{v2 → engine}/ngc.py

@@ -68,8 +68,14 @@ class PredictiveCodingCircuit:
                  tau: float = 1.0,
                  gamma: float = 0.01,
                  settle_steps: int = 20,
+                 settle_steps_warm: int = 5,
+                 obs_change_threshold: float = 1e-2,
                  learning_rate: float = 0.01,
-                 activation: str = "tanh"):
+                 activation: str = "tanh",
+                 adaptive_precision: bool = True,
+                 precision_momentum: float = 0.9,
+                 precision_min: float = 0.1,
+                 precision_max: float = 100.0):
         """
         Args:
             layer_sizes: [dim_sensory, dim_hidden1, ..., dim_top]
@@ -79,15 +85,26 @@ class PredictiveCodingCircuit:
             tau: Membrane time constant (settling speed)
             gamma: State decay rate (leaky integration)
             settle_steps: How many steps to run before declaring convergence
+            settle_steps_warm: Steps when the observation is nearly unchanged (warm-started z)
+            obs_change_threshold: L2 change above this triggers full settle_steps
             learning_rate: Hebbian learning rate for synaptic updates
             activation: Nonlinearity: "tanh", "relu", "sigmoid", or "linear"
+            adaptive_precision: If True, update precisions from prediction-error variance in learn()
+            precision_momentum: EMA factor for precision updates (higher = slower change)
+            precision_min / precision_max: Clamp learned precisions
         """
         self.n_layers = len(layer_sizes)
         self.layer_sizes = layer_sizes
         self.tau = tau
         self.gamma = gamma
         self.settle_steps = settle_steps
+        self.settle_steps_warm = max(1, int(settle_steps_warm))
+        self.obs_change_threshold = obs_change_threshold
         self.lr = learning_rate
+        self.adaptive_precision = adaptive_precision
+        self.precision_momentum = precision_momentum
+        self.precision_min = precision_min
+        self.precision_max = precision_max
         
         # Activation function
         self._phi, self._phi_deriv = self._get_activation(activation)
@@ -123,6 +140,9 @@ class PredictiveCodingCircuit:
         # Energy tracking
         self.energy_history: List[float] = []
         self.error_history: List[List[float]] = []  # Per-layer error norms
+        
+        # Warm-start: last observation for change detection
+        self._last_obs: Optional[np.ndarray] = None
     
     def _get_activation(self, name: str):
         """Get activation function and its derivative."""
@@ -206,12 +226,6 @@ class PredictiveCodingCircuit:
         Returns:
             Settling diagnostics
         """
-        n_steps = steps or self.settle_steps
-        
-        if not self._initialized:
-            self._init_layers(observation)
-        
-        # Clamp sensory layer
         obs = np.asarray(observation, dtype=np.float64)
         if len(obs) != self.layer_sizes[0]:
             # Project to sensory dimension
@@ -222,6 +236,25 @@ class PredictiveCodingCircuit:
                 padded[:len(obs)] = obs
                 obs = padded
         
+        obs_changed = True
+        if self._last_obs is not None and self._last_obs.shape == obs.shape:
+            if float(np.linalg.norm(obs - self._last_obs)) <= self.obs_change_threshold:
+                obs_changed = False
+        self._last_obs = obs.copy()
+        
+        if steps is not None:
+            n_steps = steps
+        elif not self._initialized:
+            n_steps = self.settle_steps
+        elif obs_changed:
+            n_steps = self.settle_steps
+        else:
+            n_steps = self.settle_steps_warm
+        
+        if not self._initialized:
+            self._init_layers(obs)
+        
+        # Clamp sensory layer
         self.layers[0].z = obs.copy()
         
         energy_trace = []
@@ -295,6 +328,17 @@ class PredictiveCodingCircuit:
         """
         effective_lr = self.lr * modulation
         
+        if self.adaptive_precision and self.layers:
+            for ell in range(self.n_layers):
+                sq_error = float(np.mean(self.layers[ell].error ** 2))
+                target_precision = 1.0 / max(sq_error, 1e-6)
+                mom = self.precision_momentum
+                self.precisions[ell] = mom * self.precisions[ell] + (1.0 - mom) * target_precision
+                self.precisions[ell] = float(
+                    np.clip(self.precisions[ell], self.precision_min, self.precision_max)
+                )
+                self.layers[ell].precision = self.precisions[ell]
+        
         for ell in range(self.n_layers - 1):
             error_below = self.layers[ell].error
             z_above = self._phi(self.layers[ell + 1].z)

tensegrity/{v2/graft.py → engine/scoring.py}

@@ -1,25 +1,12 @@
 """
-v2 Graft: Semantic scoring bridge + NGC logit bias injection.
-
-Scoring bridge (V2ScoringBridge):
-  Three-tier scoring for multiple-choice tasks:
-    1. SENTENCE-LEVEL: sbert cosine(prompt, choice) — strongest semantic signal
-    2. TOKEN-LEVEL: Semantic FHRR compositional similarity
-    3. NGC ENERGY: Hierarchical prediction error after settling
-  
-  All signals z-normalized and combined (1.0/0.3/0.2 weights).
-  Convergence gate abstains when signal has insufficient spread.
-
-NGCLogitsProcessor:
-  Per-decode-step logit bias injection during LLM generation.
-  NGC prediction errors projected into vocabulary space via fixed random matrices.
-  Only emits when NGC energy has converged (graceful fallback otherwise).
+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
 import math
 import logging
+import threading
 
 logger = logging.getLogger(__name__)
 
@@ -37,7 +24,8 @@ class NGCLogitsProcessor:
     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):
+                 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
@@ -45,11 +33,29 @@ class NGCLogitsProcessor:
         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)
+            self._worker = None
     
     def _build_projections(self):
         projections = []
@@ -60,19 +66,17 @@ class NGCLogitsProcessor:
             projections.append(P)
         return projections
     
-    def __call__(self, input_ids, scores):
-        self._step_count += 1
-        ids = input_ids[0].tolist()[-16:]
+    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 scores
+            return None
         obs = self.field._fhrr_to_obs(self.field.encoder.encode_sequence(tokens))
-        settle = self.field.ngc.settle(obs, steps=self.max_settle_steps)
-        self._total_settle_steps += self.max_settle_steps
+        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 scores
+            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
@@ -83,7 +87,46 @@ class NGCLogitsProcessor:
         bias *= self.scale * confidence
         np.clip(bias, -self.max_bias, self.max_bias, out=bias)
         self._emissions += 1
-        return scores + torch.tensor(bias, device=scores.device, dtype=scores.dtype).unsqueeze(0)
+        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
+            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
+        ids = input_ids[0].tolist()[-16:]
+        if self.async_cognitive:
+            self._pending_ids = 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
+            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
+        return scores + torch.tensor(bias_np, device=scores.device, dtype=scores.dtype).unsqueeze(0)
     
     @property
     def statistics(self):
@@ -94,7 +137,7 @@ class NGCLogitsProcessor:
         }
 
 
-class V2ScoringBridge:
+class ScoringBridge:
     """
     Semantic scoring bridge for benchmark evaluation.
     
@@ -107,7 +150,7 @@ class V2ScoringBridge:
                  hopfield_beta=0.05, confidence_threshold=0.15,
                  context_settle_steps=40, choice_settle_steps=25,
                  context_learning_epochs=3):
-        from tensegrity.v2.field import UnifiedField
+        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,

tensegrity/{v2/field.py → engine/unified_field.py}

@@ -1,8 +1,8 @@
 """
 Unified Energy Landscape: One functional to rule them all.
 
-The v1 architecture had four separate components doing four separate kinds
-of energy minimization. This module unifies them into a single energy
+Earlier designs used separate components for separate kinds of energy
+minimization. This module unifies them into a single energy
 functional that decomposes into local terms:
 
     E_total = E_perception + E_memory + E_causal
@@ -29,8 +29,8 @@ import numpy as np
 from typing import Dict, List, Optional, Any, Tuple
 from dataclasses import dataclass
 
-from tensegrity.v2.fhrr import FHRREncoder, bind, bundle, unbind
-from tensegrity.v2.ngc import PredictiveCodingCircuit
+from .fhrr import FHRREncoder, bind, bundle, unbind
+from .ngc import PredictiveCodingCircuit
 
 
 @dataclass
@@ -302,7 +302,7 @@ class UnifiedField:
         """
         What does the system expect to observe next?
         
-        This is the prediction that v1 never made.
+        This is the forward prediction from the settled internal state.
         """
         return self.ngc.predict_observation()
     

tensegrity/graft/logit_bias.py

@@ -30,6 +30,7 @@ The graft implements three principles from the manifold integration:
 """
 
 import math
+import threading
 import numpy as np
 from typing import Dict, List, Optional, Set, Callable, Any
 from dataclasses import dataclass
@@ -84,12 +85,14 @@ class TensegrityLogitsProcessor:
                  suppress_threshold: float = 0.01,
                  entropy_gate: float = 0.85,
                  min_confidence: float = 0.3,
-                 max_bias: float = 8.0):
+                 max_bias: float = 8.0,
+                 async_beliefs: bool = False,
+                 belief_poll_s: float = 0.005):
         """
         Args:
             hypothesis_tokens: {hyp_id: set of token_ids} from VocabularyGrounding
             belief_fn: Callable that returns current posteriors {hyp_id: probability}
-                      This is called at EVERY decode step — must return fresh state.
+                      Sync mode: called each decode step. Async mode: polled in a worker thread.
             vocab_size: LLM vocabulary size
             scale: γ — guidance strength. 0=off, 2.5=moderate, 5.0=strong
             suppress_threshold: P below this → hard -inf suppress
@@ -97,6 +100,8 @@ class TensegrityLogitsProcessor:
                          1.0 = always emit, 0.0 = never emit, 0.85 = emit when fairly certain
             min_confidence: Minimum max-posterior probability to emit any bias
             max_bias: Clamp bias magnitude to prevent numerical issues
+            async_beliefs: If True, belief_fn runs in a daemon thread; __call__ is O(1) bias add
+            belief_poll_s: Sleep between async polls (seconds)
         """
         _ensure_torch()
         
@@ -108,10 +113,20 @@ class TensegrityLogitsProcessor:
         self.entropy_gate = entropy_gate
         self.min_confidence = min_confidence
         self.max_bias = max_bias
+        self.async_beliefs = async_beliefs
+        self.belief_poll_s = belief_poll_s
         
         # State tracking
         self.state = GraftState()
         self._step_count = 0
+        
+        self._bias_lock = threading.Lock()
+        self._latest_bias_np: Optional[np.ndarray] = None
+        self._stop_worker = threading.Event()
+        self._worker: Optional[threading.Thread] = None
+        if self.async_beliefs:
+            self._worker = threading.Thread(target=self._async_belief_worker, daemon=True)
+            self._worker.start()
     
     def _compute_entropy(self, posteriors: Dict[str, float]) -> float:
         """Normalized entropy of the posterior. 0=resolved, 1=uniform."""
@@ -142,37 +157,37 @@ class TensegrityLogitsProcessor:
         
         return self.state.convergence_met
     
-    def __call__(self, input_ids, scores):
-        """
-        Called at every decode step by model.generate().
-        
-        Args:
-            input_ids: (batch_size, seq_len) — generated tokens so far
-            scores: (batch_size, vocab_size) — raw logits before softmax
-        
-        Returns:
-            Modified scores with belief-derived logit biases
-        """
-        self._step_count += 1
-        self.state.step = self._step_count
-        
-        # Read current beliefs from Tensegrity
-        posteriors = self.belief_fn()
-        
+    def close(self):
+        """Stop the background belief worker (async mode)."""
+        self._stop_worker.set()
+        if self._worker is not None:
+            self._worker.join(timeout=2.0)
+            self._worker = None
+    
+    def _async_belief_worker(self):
+        while not self._stop_worker.is_set():
+            try:
+                posteriors = self.belief_fn()
+                bias_np = self._compute_bias_numpy(posteriors)
+            except Exception as e:
+                logger.debug("Async belief worker error: %s", e)
+                bias_np = None
+            with self._bias_lock:
+                self._latest_bias_np = bias_np
+            self._stop_worker.wait(self.belief_poll_s)
+    
+    def _compute_bias_numpy(self, posteriors: Dict[str, float]) -> Optional[np.ndarray]:
+        """Build vocab-sized bias vector on CPU, or None if gated off."""
         if not posteriors:
             self.state.bias_emitted = False
-            return scores
-        
-        # Convergence gate
+            return None
         if not self._should_emit(posteriors):
             self.state.bias_emitted = False
-            return scores
+            return None
         
-        # Compute bias
         N = len(posteriors)
         p_uniform = 1.0 / N
-        
-        bias = torch.zeros(self.vocab_size, device=scores.device, dtype=scores.dtype)
+        bias = np.zeros(self.vocab_size, dtype=np.float64)
         boosted = 0
         suppressed = 0
         max_mag = 0.0
@@ -183,40 +198,59 @@ class TensegrityLogitsProcessor:
                 continue
             
             if prob < self.suppress_threshold:
-                # Hard suppress — eliminated hypothesis
-                b = float('-inf')
                 for tid in token_ids:
                     if 0 <= tid < self.vocab_size:
-                        bias[tid] = float('-inf')
+                        bias[tid] = -np.inf
                         suppressed += 1
             else:
-                # Log-ratio bias: positive when prob > uniform, negative when below
                 b = self.scale * math.log(prob / p_uniform)
-                b = max(-self.max_bias, min(self.max_bias, b))  # Clamp
-                
+                b = max(-self.max_bias, min(self.max_bias, b))
                 for tid in token_ids:
                     if 0 <= tid < self.vocab_size:
-                        if bias[tid] != float('-inf'):  # Don't un-suppress
+                        if not np.isneginf(bias[tid]):
                             bias[tid] += b
                             if b > 0:
                                 boosted += 1
                             max_mag = max(max_mag, abs(b))
         
-        # Scale by confidence — uncertain beliefs emit weaker biases
         max_prob = max(posteriors.values())
         confidence_scale = (max_prob - p_uniform) / (1.0 - p_uniform) if max_prob > p_uniform else 0.0
+        finite = np.isfinite(bias)
+        bias[finite] *= confidence_scale
         
-        # Apply confidence scaling to non-inf biases
-        finite_mask = bias != float('-inf')
-        bias[finite_mask] *= confidence_scale
-        
-        # Update state
         self.state.bias_emitted = True
         self.state.max_bias_magnitude = max_mag * confidence_scale
         self.state.boosted_tokens = boosted
         self.state.suppressed_tokens = suppressed
+        return bias
+    
+    def __call__(self, input_ids, scores):
+        """
+        Called at every decode step by model.generate().
+        
+        Args:
+            input_ids: (batch_size, seq_len) — generated tokens so far
+            scores: (batch_size, vocab_size) — raw logits before softmax
+        
+        Returns:
+            Modified scores with belief-derived logit biases
+        """
+        self._step_count += 1
+        self.state.step = self._step_count
+        
+        if self.async_beliefs:
+            with self._bias_lock:
+                bias_np = None if self._latest_bias_np is None else self._latest_bias_np.copy()
+        else:
+            posteriors = self.belief_fn()
+            bias_np = self._compute_bias_numpy(posteriors)
+        
+        if bias_np is None:
+            self.state.bias_emitted = False
+            return scores
         
-        return scores + bias.unsqueeze(0)  # Broadcast over batch dim
+        bias = torch.tensor(bias_np, device=scores.device, dtype=scores.dtype)
+        return scores + bias.unsqueeze(0)
 
 
 class StaticLogitBiasBuilder:

tensegrity/graft/pipeline.py

@@ -50,8 +50,9 @@ class HybridPipeline:
                  model_name: str = "meta-llama/Llama-3.2-1B-Instruct",
                  mode: str = "local",
                  scale: float = 2.5,
-                 entropy_gate: float = 0.85,
-                 suppress_threshold: float = 0.01):
+        entropy_gate: float = 0.85,
+        suppress_threshold: float = 0.01,
+        async_graft: bool = True):
         """
         Args:
             hypothesis_labels: List of hypothesis names
@@ -64,6 +65,7 @@ class HybridPipeline:
             scale: Logit bias magnitude
             entropy_gate: Convergence threshold for bias emission
             suppress_threshold: Below this probability → hard suppress
+            async_graft: Local mode only — poll beliefs in a background thread for non-blocking decode
         """
         self.hypothesis_labels = hypothesis_labels
         self.model_name = model_name
@@ -71,6 +73,7 @@ class HybridPipeline:
         self.scale = scale
         self.entropy_gate = entropy_gate
         self.suppress_threshold = suppress_threshold
+        self.async_graft = async_graft
         
         # Initialize cognitive controller (template mode — no LLM for parsing)
         self.controller = CognitiveController(
@@ -125,6 +128,7 @@ class HybridPipeline:
             scale=self.scale,
             suppress_threshold=self.suppress_threshold,
             entropy_gate=self.entropy_gate,
+            async_beliefs=self.async_graft,
         )
         
         logger.info(f"Vocabulary grounding coverage: {self._grounding.coverage()}")

tensegrity/memory/associative.py

@@ -46,7 +46,9 @@ class AssociativeMemory:
     
     def __init__(self, pattern_dim: int, beta: float = 1.0,
                  max_patterns: int = 10000, convergence_steps: int = 5,
-                 zipf_exponent: float = 1.0):
+                 zipf_exponent: float = 1.0,
+                 access_decay: float = 0.99,
+                 decay_every_n_retrieves: int = 50):
         """
         Args:
             pattern_dim: Dimensionality of stored patterns
@@ -55,12 +57,16 @@ class AssociativeMemory:
             max_patterns: Maximum number of stored patterns
             convergence_steps: Number of iterative updates for retrieval
             zipf_exponent: Controls power-law weighting of pattern importance
+            access_decay: Multiplicative decay applied to access counts periodically
+            decay_every_n_retrieves: Invoke decay every N retrieve() calls (0 = never)
         """
         self.dim = pattern_dim
         self.beta = beta
         self.max_patterns = max_patterns
         self.convergence_steps = convergence_steps
         self.zipf_s = zipf_exponent
+        self.access_decay = access_decay
+        self.decay_every_n_retrieves = decay_every_n_retrieves
         
         # Pattern storage matrix X ∈ ℝ^(dim × n_patterns)
         self.patterns: List[np.ndarray] = []
@@ -69,7 +75,17 @@ class AssociativeMemory:
         
         # Pattern metadata (labels, timestamps, access counts)
         self._metadata: List[Dict[str, Any]] = []
-        self._access_counts: List[int] = []
+        self._access_counts: List[float] = []
+        self._retrieve_calls = 0
+    
+    def clear(self):
+        """Drop all stored patterns (new episode)."""
+        self.patterns.clear()
+        self._metadata.clear()
+        self._access_counts.clear()
+        self._pattern_matrix = None
+        self._dirty = True
+        self._retrieve_calls = 0
     
     def store(self, pattern: np.ndarray, metadata: Optional[Dict] = None) -> int:
         """
@@ -97,7 +113,7 @@ class AssociativeMemory:
         idx = len(self.patterns)
         self.patterns.append(pattern.copy())
         self._metadata.append(metadata or {})
-        self._access_counts.append(0)
+        self._access_counts.append(0.0)
         self._dirty = True
         
         # Capacity management
@@ -127,6 +143,10 @@ class AssociativeMemory:
         if not self.patterns:
             return (np.zeros(self.dim), float('inf')) if return_energy else np.zeros(self.dim)
         
+        self._retrieve_calls += 1
+        if self.decay_every_n_retrieves > 0 and self._retrieve_calls % self.decay_every_n_retrieves == 0:
+            self._decay_access_counts()
+        
         self._ensure_matrix()
         
         # Normalize query
@@ -199,6 +219,10 @@ class AssociativeMemory:
         if not self.patterns:
             return np.zeros(self.dim), np.array([])
         
+        self._retrieve_calls += 1
+        if self.decay_every_n_retrieves > 0 and self._retrieve_calls % self.decay_every_n_retrieves == 0:
+            self._decay_access_counts()
+        
         self._ensure_matrix()
         
         query = np.asarray(query, dtype=np.float64).flatten()
@@ -229,6 +253,12 @@ class AssociativeMemory:
                       self.beta * similarities.max()
         return float(-log_sum_exp / self.beta + 0.5 * np.dot(xi, xi))
     
+    def _decay_access_counts(self):
+        """Reduce access counts so stale dominance slowly evaporates."""
+        if not self._access_counts:
+            return
+        self._access_counts = [float(c) * self.access_decay for c in self._access_counts]
+    
     def _zipf_weights(self) -> np.ndarray:
         """
         Compute Zipf weights based on access frequency.
@@ -237,7 +267,7 @@ class AssociativeMemory:
         This creates a self-reinforcing power law: popular patterns
         become more accessible, rare patterns fade.
         """
-        counts = np.array(self._access_counts, dtype=np.float64) + 1.0
+        counts = np.maximum(self._access_counts, 0.0) + 1.0
         # Rank by access count (descending)
         ranks = np.argsort(np.argsort(-counts)) + 1  # 1-indexed ranks
         # Zipf weight: 1/rank^s
@@ -284,7 +314,7 @@ class AssociativeMemory:
             'n_patterns': len(self.patterns),
             'total_accesses': int(accesses.sum()),
             'mean_access': float(accesses.mean()),
-            'max_access': int(accesses.max()),
+            'max_access': float(accesses.max()),
             'beta': self.beta,
             'dimension': self.dim,
         }

tensegrity/memory/episodic.py

@@ -96,6 +96,15 @@ class EpisodicMemory:
         
         self._timestep = 0
     
+    def clear(self):
+        """Reset store for a new independent episode (e.g. next benchmark item)."""
+        self.context = np.random.randn(self.context_dim)
+        self.context /= np.linalg.norm(self.context)
+        self.episodes.clear()
+        self._morton_index.clear()
+        self._surprise_heap.clear()
+        self._timestep = 0
+    
     def _compute_item_representation(self, observation: np.ndarray,
                                      belief_state: np.ndarray) -> np.ndarray:
         """

tensegrity/pipeline/__init__.py

@@ -0,0 +1,5 @@
+"""Single full-stack Tensegrity execution path (controller + semantic field scoring)."""
+
+from tensegrity.pipeline.canonical import CanonicalPipeline
+
+__all__ = ["CanonicalPipeline"]

tensegrity/pipeline/canonical.py

@@ -0,0 +1,129 @@
+"""
+Canonical Tensegrity pipeline — one code path for benchmarks and generation.
+
+Composes:
+  • CognitiveController + TensegrityAgent (Broca parse, free-energy inference,
+    causal arena, dynamic SCM injection when enabled)
+  • ScoringBridge (FHRR + NGC + Hopfield scoring for multiple-choice items)
+
+Benchmark mode scores each option by fusing LLM log-probabilities with this
+stack. Hybrid generation can reuse the same controller for logit grafting.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+
+from tensegrity.broca.controller import CognitiveController
+from tensegrity.bench.tasks import TaskSample
+from tensegrity.engine.scoring import ScoringBridge
+
+logger = logging.getLogger(__name__)
+
+
+class CanonicalPipeline:
+    """
+    Full cognitive stack shared by benchmarks and the hybrid graft path.
+
+    For each MC item: reset controller + field scorer state, ingest the prompt,
+    score choices with ScoringBridge, fuse hypothesis posterior with field scores.
+    """
+
+    def __init__(
+        self,
+        hypothesis_labels: List[str],
+        *,
+        use_llm_broca: bool = False,
+        enable_hypothesis_generation: bool = False,
+        model_name: str = "meta-llama/Llama-3.2-1B-Instruct",
+        belief_blend: float = 0.35,
+        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,
+        confidence_threshold: float = 0.15,
+        context_settle_steps: int = 40,
+        choice_settle_steps: int = 25,
+        context_learning_epochs: int = 3,
+    ):
+        self.model_name = model_name
+        self.belief_blend = belief_blend
+        self.controller = CognitiveController(
+            n_hypotheses=max(len(hypothesis_labels), 2),
+            hypothesis_labels=hypothesis_labels,
+            use_llm=use_llm_broca,
+            enable_hypothesis_generation=enable_hypothesis_generation,
+        )
+        self.scoring = ScoringBridge(
+            obs_dim=obs_dim,
+            hidden_dims=hidden_dims or [128, 32],
+            fhrr_dim=fhrr_dim,
+            ngc_settle_steps=ngc_settle_steps,
+            ngc_learning_rate=ngc_learning_rate,
+            hopfield_beta=hopfield_beta,
+            confidence_threshold=confidence_threshold,
+            context_settle_steps=context_settle_steps,
+            choice_settle_steps=choice_settle_steps,
+            context_learning_epochs=context_learning_epochs,
+        )
+
+    def reset_for_multichoice(self, sample: TaskSample) -> None:
+        """I.I.D. benchmark item: fresh agent memories / arena and field scorer."""
+        labels = list(sample.choices)
+        if not labels:
+            labels = ["_empty_"]
+        self.controller.reset_session(labels)
+        self.scoring.reset()
+
+    def ingest_prompt(self, prompt: str) -> Dict[str, Any]:
+        """Parse + perceive (+ optional causal hypothesis); no verbalization."""
+        return self.controller.perceive_only(prompt)
+
+    def score_multichoice(self, sample: TaskSample) -> Tuple[List[float], float, Dict[str, Any]]:
+        """
+        Run the full stack on one TaskSample.
+
+        Returns:
+            combined_scores: fused list for argmax over choices
+            gate_entropy: scorer gate entropy
+            diagnostics: raw components for debugging / logging
+        """
+        self.reset_for_multichoice(sample)
+        ing = self.ingest_prompt(sample.prompt)
+        field_scores, entropy = self.scoring.score_choices(sample.prompt, sample.choices)
+        field_arr = np.asarray(field_scores, dtype=np.float64)
+        agent_probs = self._agent_choice_posterior(len(sample.choices))
+        combined = self._fuse_field_and_hypotheses(field_arr, agent_probs)
+        return (
+            combined.tolist(),
+            float(entropy),
+            {
+                "field_scores": field_scores,
+                "agent_probs": agent_probs.tolist(),
+                "perception_tension": ing.get("perception", {}).get("tension"),
+                "free_energy": ing.get("perception", {}).get("free_energy"),
+            },
+        )
+
+    def _agent_choice_posterior(self, n_choices: int) -> np.ndarray:
+        hs = self.controller.belief_state.hypotheses
+        if len(hs) != n_choices:
+            return np.ones(n_choices, dtype=np.float64) / max(n_choices, 1)
+        p = np.array([float(h.probability) for h in hs], dtype=np.float64)
+        s = p.sum()
+        if s <= 0:
+            return np.ones(n_choices, dtype=np.float64) / n_choices
+        return p / s
+
+    def _fuse_field_and_hypotheses(self, field: np.ndarray, agent_probs: np.ndarray) -> np.ndarray:
+        if field.shape != agent_probs.shape:
+            return field
+        zf = (field - field.mean()) / (field.std() + 1e-8)
+        a = np.log(agent_probs + 1e-12)
+        za = (a - a.mean()) / (a.std() + 1e-8)
+        return zf + self.belief_blend * za

tensegrity/v2/__init__.py

@@ -1,30 +0,0 @@
-"""
-Tensegrity v2: Unified Energy Architecture.
-
-The v2 architecture replaces v1's flat inference with:
-  - FHRR-RNS encoding (compositional hypervectors with semantic grounding)
-  - NGC predictive coding (hierarchical prediction errors, replaces flat POMDP)
-  - Unified energy landscape (perception + memory + causal in one functional)
-  - CausalArenaV2 (energy-based model competition, replaces log-likelihood arena)
-  - Sentence-level semantic scoring via sentence-transformers
-
-Public API:
-  UnifiedField     — The main cognitive engine (FHRR → NGC → Hopfield → Causal)
-  V2ScoringBridge  — Bridge to benchmark harness (scores choices by semantic similarity + NGC energy)
-  NGCLogitsProcessor — LogitsProcessor for LLM generation grafting
-  CausalArenaV2    — Energy-based causal model competition
-  FHRREncoder      — Compositional hypervector encoder (semantic=True by default)
-  SemanticFHRRCodebook — FHRR codebook grounded in sentence-transformer embeddings
-  PredictiveCodingCircuit — Hierarchical NGC circuit
-"""
-
-__version__ = "0.2.0"
-
-from tensegrity.v2.field import UnifiedField, HopfieldMemoryBank, EnergyDecomposition
-from tensegrity.v2.ngc import PredictiveCodingCircuit, LayerState
-from tensegrity.v2.fhrr import (
-    FHRREncoder, FHRRCodebook, SemanticFHRRCodebook,
-    bind, bundle, unbind, permute,
-)
-from tensegrity.v2.causal_energy import CausalArenaV2, CausalEnergyTerm
-from tensegrity.v2.graft import V2ScoringBridge, NGCLogitsProcessor

tests/test_async_graft.py

@@ -0,0 +1,130 @@
+"""
+Tests for asynchronous logit grafting and NGC warm-start settling.
+"""
+
+import os
+import sys
+import time
+
+import numpy as np
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if ROOT not in sys.path:
+    sys.path.insert(0, ROOT)
+
+
+def _load_module(name: str, relpath: str):
+    import importlib.util
+
+    path = os.path.join(ROOT, relpath)
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    assert spec.loader is not None
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def test_ngc_warm_start_fewer_steps():
+    mod = _load_module("tensegrity_engine_ngc_test", os.path.join("tensegrity", "engine", "ngc.py"))
+    PredictiveCodingCircuit = mod.PredictiveCodingCircuit
+
+    ngc = PredictiveCodingCircuit(
+        layer_sizes=[16, 8, 4],
+        settle_steps=30,
+        settle_steps_warm=4,
+        obs_change_threshold=1e-6,
+        adaptive_precision=False,
+    )
+    pattern = np.random.RandomState(0).randn(16)
+    full = ngc.settle(pattern)
+    assert full["settle_steps"] == 30
+    warm = ngc.settle(pattern)
+    assert warm["settle_steps"] == 4
+
+
+def test_async_beliefs_processor_matches_sync():
+    try:
+        import torch
+    except ImportError:
+        return
+
+    mod = _load_module("logit_bias_test", os.path.join("tensegrity", "graft", "logit_bias.py"))
+    TensegrityLogitsProcessor = mod.TensegrityLogitsProcessor
+
+    hypothesis_tokens = {"up": {10, 11}, "down": {20, 21}}
+    posteriors = {"up": 0.88, "down": 0.12}
+
+    def belief_fn():
+        return posteriors
+
+    sync = TensegrityLogitsProcessor(
+        hypothesis_tokens=hypothesis_tokens,
+        belief_fn=belief_fn,
+        vocab_size=128,
+        entropy_gate=0.95,
+        min_confidence=0.2,
+        async_beliefs=False,
+    )
+    async_p = TensegrityLogitsProcessor(
+        hypothesis_tokens=hypothesis_tokens,
+        belief_fn=belief_fn,
+        vocab_size=128,
+        entropy_gate=0.95,
+        min_confidence=0.2,
+        async_beliefs=True,
+        belief_poll_s=0.002,
+    )
+    time.sleep(0.05)
+    fake_ids = torch.zeros(1, 3, dtype=torch.long)
+    scores = torch.randn(1, 128)
+    out_sync = sync(fake_ids, scores.clone())
+    out_async = async_p(fake_ids, scores.clone())
+    async_p.close()
+    if async_p.state.bias_emitted and sync.state.bias_emitted:
+        assert torch.allclose(out_sync, out_async, atol=1e-5)
+
+
+def test_associative_access_decay():
+    mod = _load_module("associative_test", os.path.join("tensegrity", "memory", "associative.py"))
+    AssociativeMemory = mod.AssociativeMemory
+
+    mem = AssociativeMemory(
+        pattern_dim=8,
+        beta=1.0,
+        decay_every_n_retrieves=1,
+        access_decay=0.5,
+        max_patterns=100,
+    )
+    mem.store(np.array([1.0, 0, 0, 0, 0, 0, 0, 0]))
+    mem.retrieve(np.array([1.0, 0, 0, 0, 0, 0, 0, 0]))
+    assert mem._access_counts[0] >= 1.0
+    mem._decay_access_counts()
+    assert mem._access_counts[0] < 1.0
+
+
+def test_build_scm_from_proposal():
+    try:
+        import networkx  # noqa: F401
+    except ImportError:
+        return
+    from tensegrity.broca.schemas import ProposedSCM, CausalEdge
+    from tensegrity.causal.from_proposal import build_scm_from_proposal
+
+    p = ProposedSCM(
+        name="test_model",
+        description="x drives y",
+        edges=[
+            CausalEdge(source="x", target="y", mechanism="causes"),
+            CausalEdge(source="y", target="z", mechanism="enables"),
+        ],
+    )
+    scm = build_scm_from_proposal(p)
+    assert "x" in scm.variables and "z" in scm.variables
+
+
+if __name__ == "__main__":
+    test_ngc_warm_start_fewer_steps()
+    test_async_beliefs_processor_matches_sync()
+    test_associative_access_decay()
+    test_build_scm_from_proposal()
+    print("ok")

tests/{test_v2.py → test_engine.py}

@@ -1,5 +1,5 @@
 """
-Test Tensegrity v2: unified energy landscape.
+Tests for the unified cognitive engine: FHRR, NGC, and UnifiedField.
 """
 
 import sys
@@ -14,7 +14,7 @@ def test_fhrr_encoding():
     print("TEST 1: FHRR-RNS Compositional Encoding")
     print("=" * 60)
     
-    from tensegrity.v2.fhrr import FHRREncoder, bind, unbind, bundle
+    from tensegrity.engine.fhrr import FHRREncoder, bind, unbind, bundle
     
     enc = FHRREncoder(dim=2048)
     
@@ -61,12 +61,12 @@ def test_fhrr_encoding():
     print(f"  ✓ Same sequences more similar than different ones")
     
     # Test numeric vector encoding (modality-agnostic)
-    v1 = enc.encode_numeric_vector(np.array([1.0, 2.0, 3.0]))
-    v2 = enc.encode_numeric_vector(np.array([1.0, 2.0, 3.1]))
-    v3 = enc.encode_numeric_vector(np.array([9.0, 8.0, 7.0]))
+    v_base = enc.encode_numeric_vector(np.array([1.0, 2.0, 3.0]))
+    v_near = enc.encode_numeric_vector(np.array([1.0, 2.0, 3.1]))
+    v_far = enc.encode_numeric_vector(np.array([9.0, 8.0, 7.0]))
     
-    print(f"\n  sim([1,2,3], [1,2,3.1]) = {enc.similarity(v1, v2):.4f}")
-    print(f"  sim([1,2,3], [9,8,7])   = {enc.similarity(v1, v3):.4f}")
+    print(f"\n  sim([1,2,3], [1,2,3.1]) = {enc.similarity(v_base, v_near):.4f}")
+    print(f"  sim([1,2,3], [9,8,7])   = {enc.similarity(v_base, v_far):.4f}")
     print(f"  ✓ Numeric vectors: similar inputs → similar encodings")
     
     return True
@@ -78,7 +78,7 @@ def test_predictive_coding():
     print("TEST 2: Hierarchical Predictive Coding (NGC)")
     print("=" * 60)
     
-    from tensegrity.v2.ngc import PredictiveCodingCircuit
+    from tensegrity.engine.ngc import PredictiveCodingCircuit
     
     # 3-layer hierarchy: 64 → 32 → 8
     ngc = PredictiveCodingCircuit(
@@ -133,7 +133,6 @@ def test_predictive_coding():
     
     # THE KEY TEST: the system now PREDICTS its input
     predicted = ngc.predict_observation()
-    actual = pattern_a  # Last odd epoch was pattern_b, so next should predict pattern_a-ish
     residual = np.linalg.norm(predicted)
     print(f"\n  Prediction norm: {residual:.4f} (>0 means the system has learned to predict)")
     assert residual > 0.01, "System should generate non-trivial predictions"
@@ -149,7 +148,7 @@ def test_unified_field():
     print("TEST 3: Unified Energy Landscape")
     print("=" * 60)
     
-    from tensegrity.v2.field import UnifiedField
+    from tensegrity.engine.unified_field import UnifiedField
     
     field = UnifiedField(
         obs_dim=128,
@@ -216,8 +215,8 @@ def main():
     ]
     
     print("\n" + "█" * 60)
-    print("  TENSEGRITY v2: Unified Energy Architecture")
-    print("  FHRR-RNS × Predictive Coding × Hopfield Memory")
+    print("  Tensegrity engine: unified energy architecture")
+    print("  FHRR-RNS × Predictive Coding × Hopfield memory")
     print("█" * 60)
     
     results = []

tests/test_needle.py

@@ -1,5 +1,5 @@
 """
-Needle-in-Lies Test: Can v2's NGC detect the true statement among contradictions?
+Needle-in-Lies Test: Can NGC detect the true statement among contradictions?
 
 The test:
   - One true statement ("The key is under the oak table")
@@ -28,9 +28,9 @@ sys.path.insert(0, '/app')
 import numpy as np
 np.random.seed(42)
 
-from tensegrity.v2.fhrr import FHRREncoder, bind, bundle, unbind
-from tensegrity.v2.ngc import PredictiveCodingCircuit
-from tensegrity.v2.field import UnifiedField, HopfieldMemoryBank
+from tensegrity.engine.fhrr import FHRREncoder, bind, bundle, unbind
+from tensegrity.engine.ngc import PredictiveCodingCircuit
+from tensegrity.engine.unified_field import UnifiedField, HopfieldMemoryBank
 
 
 def make_needle_scenario(n_lies: int = 13):

tests/{test_v2_bench.py → test_scoring_bench.py}

@@ -1,5 +1,5 @@
 """
-Test v2 scoring bridge against benchmarks.
+Integration tests: ScoringBridge on benchmark samples and energy causal arena.
 """
 import sys
 sys.path.insert(0, '/app')
@@ -7,16 +7,16 @@ import numpy as np
 np.random.seed(42)
 
 
-def test_v2_scoring():
-    """Test v2 NGC-based scoring on benchmark samples."""
+def test_scoring_bridge_on_tasks():
+    """ScoringBridge on a small slice of benchmark tasks."""
     print("=" * 60)
-    print("TEST: v2 NGC Scoring vs v1 Baseline on Sample Tasks")
+    print("TEST: semantic field scoring on sample tasks")
     print("=" * 60)
     
-    from tensegrity.v2.graft import V2ScoringBridge
+    from tensegrity.engine.scoring import ScoringBridge
     from tensegrity.bench.tasks import load_task_samples
     
-    bridge = V2ScoringBridge(obs_dim=128, hidden_dims=[64, 16])
+    bridge = ScoringBridge(obs_dim=128, hidden_dims=[64, 16])
     
     tasks = ["copa", "sciq", "arc_challenge"]
     
@@ -41,18 +41,18 @@ def test_v2_scoring():
         acc = correct / max(total, 1)
         print(f"\n  {task_name}: {correct}/{total} = {acc:.1%}")
     
-    print(f"\n  ✓ v2 scoring bridge functional")
+    print(f"\n  ✓ ScoringBridge functional")
     return True
 
 
-def test_causal_energy():
-    """Test the causal energy term."""
+def test_causal_energy_arena():
+    """Energy-based causal model competition."""
     print("\n" + "=" * 60)
-    print("TEST: Causal Energy Arena v2")
+    print("TEST: energy-based causal arena")
     print("=" * 60)
     
     from tensegrity.causal.scm import StructuralCausalModel
-    from tensegrity.v2.causal_energy import CausalArenaV2
+    from tensegrity.engine.causal_energy import EnergyCausalArena
     
     # Two competing models
     m_correct = StructuralCausalModel("correct")
@@ -68,7 +68,7 @@ def test_causal_energy():
     m_correct.update_from_data(data)
     m_wrong.update_from_data(data)
     
-    arena = CausalArenaV2(precision=1.0, beta=2.0)
+    arena = EnergyCausalArena(precision=1.0, beta=2.0)
     arena.register(m_correct)
     arena.register(m_wrong)
     
@@ -89,18 +89,18 @@ def test_causal_energy():
     print(f"  Last energies: {last_result['energies']}")
     print(f"  Last posteriors: {last_result['posteriors']}")
     
-    print(f"  ✓ Causal energy arena functional")
+    print(f"  ✓ Energy causal arena functional")
     return True
 
 
 if __name__ == "__main__":
     tests = [
-        ("v2 Scoring", test_v2_scoring),
-        ("Causal Energy", test_causal_energy),
+        ("Scoring bridge", test_scoring_bridge_on_tasks),
+        ("Causal energy", test_causal_energy_arena),
     ]
     
     print("\n" + "█" * 60)
-    print("  v2 Integration Tests")
+    print("  Scoring + causal energy integration")
     print("█" * 60)
     
     for name, fn in tests: