Sync from GitHub: e2c43430bd73d3ad00b29583505268c8439f1fbb

app.py

@@ -708,6 +708,63 @@ organism.set_concept_extractor(_bitnet_concept_extractor)
 logger.info("NuWave concept helper wired: dual-pass extraction live")
 
 
+# ── Substrate context formatter ───────────────────────────────────
+# Replaces the prior "\n".join(pith_context) lump with explicit type
+# sections so BitNet's attention has structural cues to work with.
+# Group surfaced content by node-kind via ID prefix:
+#   tree_*         → "Related concepts" (concept words from dual-pass)
+#   exp_*          → "Prior questions on this topic" (deposit nodes)
+#   resp_*         → "Prior responses"
+#   concept_narr_* → operational telemetry, omitted from prompt
+#                    (it's substrate self-monitoring, not knowledge)
+#   other          → "Other context"
+# The "Dave Plummer Tempest analog" for LLM presentation: curated
+# typed input vs. raw mush. See feedback_substrate_representation_first.md.
+
+def _format_substrate_context(pith_context, pith_ids=None) -> str:
+    """Return a sectioned substrate-context string for prompt injection."""
+    if not pith_context:
+        return ""
+    if not pith_ids or len(pith_ids) != len(pith_context):
+        # No IDs available — can't section. Fallback to plain join so
+        # callers without _with_ids still produce something usable.
+        return "\n".join(pith_context)
+
+    concepts, questions, responses, other = [], [], [], []
+    for text, pid in zip(pith_context, pith_ids):
+        if not text:
+            continue
+        if pid.startswith("tree_"):
+            concepts.append(text)
+        elif pid.startswith("exp_"):
+            questions.append(text)
+        elif pid.startswith("resp_"):
+            responses.append(text)
+        elif pid.startswith("concept_narr_"):
+            # Operational telemetry — omit from prompt context (Bunyan-shaped
+            # data; legitimate substrate experience but not user knowledge).
+            continue
+        else:
+            other.append(text)
+
+    parts = []
+    if concepts:
+        parts.append(
+            "[Related concepts from substrate:]\n"
+            + "\n".join(f"- {c}" for c in concepts)
+        )
+    if questions:
+        parts.append(
+            "[Prior questions on this topic:]\n"
+            + "\n".join(f"- {q}" for q in questions)
+        )
+    if responses:
+        parts.append("[Prior context:]\n" + "\n".join(responses))
+    if other:
+        parts.append("[Other context:]\n" + "\n".join(f"- {o}" for o in other))
+    return "\n\n".join(parts)
+
+
 # ── Chat Handler ──────────────────────────────────────────────────
 
 def on_send(message, history):
@@ -731,18 +788,16 @@ def on_send(message, history):
     sys_ctx = kiss_string_result.get("system_context", system_prompt)
 
     # ── 4. Pith bucket — extract relevant context from the River ──
-    pith_context = organism.pith_extract(message, max_context=5)
+    pith_context, pith_ids = organism.pith_extract_with_ids(message, max_context=5)
 
     # Pith context REPLACES old message history, not adds to it.
     # The substrate carries what the older messages contained — the model
     # doesn't need both. Recent messages pass verbatim (the model needs
     # immediate context). Older messages are replaced by substrate context.
     if pith_context:
-        substrate_ctx = "\n".join(pith_context)
-        if sys_ctx:
-            sys_ctx = substrate_ctx + "\n\n" + sys_ctx
-        else:
-            sys_ctx = substrate_ctx
+        substrate_ctx = _format_substrate_context(pith_context, pith_ids)
+        if substrate_ctx:
+            sys_ctx = substrate_ctx + "\n\n" + sys_ctx if sys_ctx else substrate_ctx
 
     # Build prompt — Pith context replaces old history
     # Only send recent messages. The substrate carries the rest.
@@ -979,10 +1034,11 @@ def on_benchmark(num_turns):
         sys_ctx = kiss_r.get("system_context", system_prompt)
 
         # Pith Born rule extraction from substrate
-        pith_context = nw_organism.pith_extract(prompt_text, max_context=5)
+        pith_context, pith_ids = nw_organism.pith_extract_with_ids(prompt_text, max_context=5)
         if pith_context:
-            substrate_ctx = "\n".join(pith_context)
-            sys_ctx = substrate_ctx + "\n\n" + sys_ctx if sys_ctx else substrate_ctx
+            substrate_ctx = _format_substrate_context(pith_context, pith_ids)
+            if substrate_ctx:
+                sys_ctx = substrate_ctx + "\n\n" + sys_ctx if sys_ctx else substrate_ctx
 
         # Trim old messages — always, not gated on Pith.
         # The substrate + KISS carry what the older messages contained.
@@ -1230,8 +1286,9 @@ def on_interleaved_benchmark(
         kiss_r = nw_kiss_inst.filter_context(nw_msgs, system_prompt)
         sys_ctx = kiss_r.get("system_context", system_prompt)
         if pith_context:
-            substrate_ctx = "\n".join(pith_context)
-            sys_ctx = substrate_ctx + "\n\n" + sys_ctx if sys_ctx else substrate_ctx
+            substrate_ctx = _format_substrate_context(pith_context, pith_ids)
+            if substrate_ctx:
+                sys_ctx = substrate_ctx + "\n\n" + sys_ctx if sys_ctx else substrate_ctx
 
         recent_window = 6
         recent = nw_msgs[-recent_window:] if len(nw_msgs) > recent_window else nw_msgs

nuwave/organism.py

@@ -1198,6 +1198,50 @@ class NuWaveOrganism:
             summaries.append(' '.join(ordered))
         return summaries
 
+    # ── Type-aware retrieval bias (Phase 2 — representation-first redesign) ──
+    # Inductive bias on what kinds of nodes deserve weight in retrieval
+    # scoring. Bootstrapped to expert weights, decaying toward substrate
+    # authority (1.0 = no bias) as substrate accumulates step_count.
+    # Substrate Authority Pattern applied to retrieval: hand-coded expert
+    # carries the substrate through Apprentice region; STDP + three-factor
+    # learning gradually take over as competence accumulates.
+    #
+    # Per-kind raw biases (Apprentice values; reduce toward 1.0 with decay):
+    #   tree_*         → 1.30  concept words from dual-pass; usually high-value
+    #   exp_*          → 1.00  question deposits; neutral baseline
+    #   resp_*         → 1.10  past responses; slight boost (often informative)
+    #   concept_narr_* → 0.30  operational telemetry; strong suppression
+    #                          (Bunyan-shaped narrative; substrate-self-monitoring)
+    #   other          → 1.00  unknown prefix; neutral
+    #
+    # Expert-decay schedule: linear ramp from full-bias at step_count=0 to
+    # zero-bias (1.0 multiplier for everything) at step_count=COMPETENCE_CEILING.
+    # Default ceiling 50000 is several days of normal Tonic activity — gives
+    # the substrate ample Apprentice time to accumulate outcome experience
+    # before the inductive bias hands off.
+    TYPE_BIAS_RAW = {
+        "tree_": 1.30,
+        "exp_":  1.00,
+        "resp_": 1.10,
+        "concept_narr_": 0.30,
+    }
+    COMPETENCE_CEILING = 50000  # step_count at which expert influence → 0
+
+    def _type_bias_for_node(self, node_id: str) -> float:
+        """Type-bias multiplier with expert decay, per Substrate Authority Pattern."""
+        # Find matching prefix (longest match first)
+        raw = 1.0
+        for prefix in ("concept_narr_", "tree_", "resp_", "exp_"):
+            if node_id.startswith(prefix):
+                raw = self.TYPE_BIAS_RAW[prefix]
+                break
+        # Linear decay: at step 0, expert_weight=1.0; at ceiling, expert_weight=0.0
+        expert_weight = max(0.0, min(1.0,
+            1.0 - self._step_count / max(1, self.COMPETENCE_CEILING),
+        ))
+        # Blend: full expert bias → substrate authority (1.0) over time
+        return 1.0 + (raw - 1.0) * expert_weight
+
     def pith_extract(
         self,
         query: str,
@@ -1266,7 +1310,14 @@ class NuWaveOrganism:
                 effective_amp = max(0.0, min(1.0, amp + self._interference_rate * interference))
 
                 # Born rule: probability ∝ amplitude²
-                born_score = effective_amp * effective_amp
+                # Plus type-aware bias (Substrate Authority Pattern):
+                # apprentice-region inductive bias on node-kind, decaying
+                # toward substrate authority over step_count. Same formula
+                # as surface_extract — applied as a multiplicative factor
+                # so high-amplitude narrative nodes can still be picked
+                # if they're the only thing matching, but get scaled down.
+                type_bias = self._type_bias_for_node(nid)
+                born_score = effective_amp * effective_amp * type_bias
 
                 content = self._node_content.get(nid, '')
                 if content and born_score > 0.001:
@@ -1480,8 +1531,12 @@ class NuWaveOrganism:
 
                 node = nodes_by_id.get(nid)
                 excitability = float(getattr(node, "intrinsic_excitability", 1.0)) if node else 1.0
+                # Type-aware bias (Substrate Authority Pattern): hand-coded
+                # inductive bias on node-kind, decaying toward substrate
+                # authority as step_count accumulates. See _type_bias_for_node.
+                type_bias = self._type_bias_for_node(nid)
 
-                surface_score = sim * latency_boost * excitability
+                surface_score = sim * latency_boost * excitability * type_bias
 
                 content = self._node_content.get(nid, "")
                 if content and surface_score > 0.001: