Sync from GitHub: 500d328a89ae2aee6e3c4971d12c2c008ae336c4

app.py

@@ -1243,150 +1243,20 @@ def on_interleaved_benchmark(
         nw_msgs.append({"role": "assistant", "content": resp_nw})
         nw_organism.record_outcome(prompt_text, resp_nw, success=True)
 
-        # ── Phase 2: scoped multi-channel feedback (2026-04-26) ──
-        # record_outcome already fired GLOBAL success reward (strength=2.0
-        # × 3 cycles). This block adds SCOPED signal-modulated reward on
-        # the retrieved nodes so the substrate can learn WHICH retrievals
-        # actually contributed to outcomes — not just that this turn was
-        # successful overall.
-        #
-        # Per Josh's directive ("put it all in, the substrate can learn
-        # from it"), three signals fire per turn — substrate's three-
-        # factor learning correlates eligibility traces with each:
-        #   1. Per-node response-similarity — was this content related
-        #      to the answer we generated?
-        #   2. Per-node query-similarity — was this content relevant
-        #      to the question?
-        #   3. Collective tokens-saved (scoped to entire pith set) —
-        #      did the surfacing as a whole help compress the prompt?
-        #
-        # Stimulate-then-step before reward is the canonical inject_reward
-        # pattern. surface_extract used write_mode=False, leaving no
-        # eligibility traces; we re-fire the pith nodes here briefly so
-        # traces form, then scoped reward modulates them.
-        # Phase 2 (revised 2026-04-27 after Runs 19-20 showed actively-
-        # harmful behavior). Two bugs in the prior implementation, fixed
-        # here:
-        #
-        #   Bug 1 (DROPPED): Channel 3 (collective tokens-saved penalty)
-        #     applied uniformly to all pith nodes. When NuWave used more
-        #     tokens than baseline, it depressed legitimate retrieval
-        #     pathways (high-prior-weight question nodes) faster than
-        #     marginal noise (low-prior-weight narrative nodes), inverting
-        #     the intended effect. Tokens-saved is a turn-level signal
-        #     with no per-node attribution — feeding it as a scoped
-        #     penalty was a wrong signal-to-scope binding. Removed.
-        #
-        #   Bug 2 (FIXED): stimulate(current=1.5) + step() left residual
-        #     voltage on stimulated nodes that bled into the next turn's
-        #     surface_extract, biasing retrieval toward the very nodes
-        #     Phase 2 was trying to selectively reward. Replaced with
-        #     prime_and_propagate(write_mode=True), the canonical method
-        #     for forming eligibility traces — bounded propagation,
-        #     designed for plasticity, used by Tonic's heuristic
-        #     ouroboros and by canonical surface_extract patterns.
-        #
-        # Telemetry is now surfaced INTO the per-turn result dict as
-        # phase2_diag, visible in the JSON output rather than only in
-        # runtime logs (Josh: "you set this up, that's your department").
-        _phase2_diag = {"fired": False, "reason": None}
-        try:
-            if pith_ids and resp_nw and nw_organism._graph is not None:
-                _rewards_before = getattr(
-                    nw_organism._graph, "_total_rewards_injected", 0,
-                )
-
-                _resp_emb = np.asarray(
-                    nw_organism._embed_fn(resp_nw), dtype=np.float32,
-                )
-                _resp_n = _resp_emb / (np.linalg.norm(_resp_emb) + 1e-8)
-                _query_emb = np.asarray(
-                    nw_organism._embed_fn(prompt_text), dtype=np.float32,
-                )
-                _query_n = _query_emb / (np.linalg.norm(_query_emb) + 1e-8)
-
-                _per_node_strengths = []
-
-                with nw_organism._graph_lock:
-                    # Use prime_and_propagate(write_mode=True) — the
-                    # canonical trace-forming method. Bounded propagation
-                    # means voltages don't leak into next turn, and
-                    # write_mode enables STDP plasticity from the activity.
-                    _seeds = [
-                        _pid for _pid in pith_ids
-                        if _pid in nw_organism._graph.nodes
-                    ]
-                    if _seeds:
-                        _prop_result = nw_organism._graph.prime_and_propagate(
-                            node_ids=_seeds,
-                            currents=[1.0] * len(_seeds),
-                            steps=3,
-                            write_mode=True,
-                        )
-                        _fired_count = (
-                            len(_prop_result.fired_nodes)
-                            if hasattr(_prop_result, "fired_nodes")
-                            else 0
-                        )
-
-                        # Per-node similarity rewards. Channel 3 (collective
-                        # tokens-saved) DELETED — see bug analysis above.
-                        for _pid in pith_ids:
-                            _node_emb = nw_organism._embeddings.get(_pid)
-                            if _node_emb is None:
-                                continue
-                            _node_n = _node_emb / (
-                                np.linalg.norm(_node_emb) + 1e-8
-                            )
-                            _strength_resp = max(-1.0, min(
-                                1.0,
-                                (float(np.dot(_node_n, _resp_n)) - 0.3) * 2.0,
-                            ))
-                            _strength_query = max(-1.0, min(
-                                1.0,
-                                (float(np.dot(_node_n, _query_n)) - 0.3) * 2.0,
-                            ))
-                            nw_organism._graph.inject_reward(
-                                strength=_strength_resp, scope={_pid},
-                            )
-                            nw_organism._graph.inject_reward(
-                                strength=_strength_query, scope={_pid},
-                            )
-                            _per_node_strengths.append({
-                                "id": _pid,
-                                "resp_sim": round(_strength_resp, 3),
-                                "query_sim": round(_strength_query, 3),
-                            })
-
-                        # Consolidate — two step()s let STDP propagate
-                        # the rewarded eligibility traces into actual
-                        # weight changes.
-                        for _ in range(2):
-                            nw_organism._graph.step()
-                    else:
-                        _fired_count = 0
-
-                _rewards_after = getattr(
-                    nw_organism._graph, "_total_rewards_injected", 0,
-                )
-                _phase2_diag = {
-                    "fired": True,
-                    "seeds": len(_seeds) if _seeds else 0,
-                    "fired_count_post_pap": _fired_count,
-                    "rewards_injected_delta": _rewards_after - _rewards_before,
-                    "per_node_strengths": _per_node_strengths,
-                }
-        except Exception as exc:
-            # Promoted from debug → warning. Surface in JSON so we don't
-            # need runtime logs to see what's happening.
-            logger.warning(
-                "Phase 2 feedback loop FAILED on turn %d: %s: %s",
-                i + 1, type(exc).__name__, exc,
-            )
-            _phase2_diag = {
-                "fired": False,
-                "reason": f"{type(exc).__name__}: {exc}",
-            }
+        # Phase 2 (scoped multi-channel substrate feedback) was attempted
+        # in commits 468fd09, ab0fdd3, e4dd297 then removed 2026-04-27.
+        # The architectural idea (substrate-feedback-via-inject_reward) is
+        # canonical Substrate Authority Pattern and remains correct, but
+        # all three implementations had bugs that made them either no-op
+        # or actively harmful: stimulate residual voltage created positive
+        # feedback loops, Channel 3 collective penalty had wrong signal-
+        # to-scope binding, prime_and_propagate(currents=1.0) didn't fire
+        # seeds, and concurrent-modification races crashed 3/8 turns.
+        # See feedback_substrate_representation_first.md — Phase 2 redesign
+        # is deferred until representation work (discover_hyperedges hook,
+        # type-aware retrieval scoring with expert decay) gives the
+        # substrate the structural inductive biases that make relevance
+        # learnable in the first place.
 
         # Drain the concept queue before the next turn — makes tree
         # extraction synchronous for benchmark reproducibility. Without
@@ -1458,7 +1328,6 @@ def on_interleaved_benchmark(
             "ignition_size":   len(ignition_sets[i]),
             "pith_ids":        list(pith_ids),
             "surfaced_context": _surfaced_context,
-            "phase2_diag":     _phase2_diag,
             "trees":           trees_for_turn,
             "raw_extractor_output": raw_output,
             "extractor_elapsed_s": extractor_elapsed,

nuwave/organism.py

@@ -916,6 +916,33 @@ class NuWaveOrganism:
             self._last_active_ts = time.time()
             with self._graph_lock:
                 step_result = self._graph.step()
+
+                # Hand fired nodes to the canonical hyperedge discovery
+                # primitive. discover_hyperedges() is built into NG's
+                # neuro_foundation.py but is host-driven — the substrate
+                # API is host-agnostic and doesn't auto-call discovery
+                # from inside step(). NuWave is the host for this graph,
+                # so we hand it the freshly-fired set every step. The
+                # method tracks co-fire patterns over he_discovery_window
+                # (config default 10 timesteps); creates a hyperedge when
+                # a fired pattern hits he_discovery_min_co_fires (5) and
+                # has at least he_discovery_min_nodes (3) members. All
+                # config knobs already in place from Phase 1's graph
+                # config block. Non-zero return = newly discovered HEs.
+                # Wrapped in try/except — discovery failure must not
+                # break the step() lifecycle for the rest of the organism.
+                fired_for_discovery = list(
+                    getattr(step_result, "fired_node_ids", []) or []
+                )
+                if len(fired_for_discovery) >= 3:
+                    try:
+                        self._graph.discover_hyperedges(fired_for_discovery)
+                    except Exception as exc:
+                        logger.debug(
+                            "discover_hyperedges raised: %s: %s",
+                            type(exc).__name__, exc,
+                        )
+
             self._step_result = step_result
             self._step_count += 1