@hviana/sema 0.4.1 → 0.4.3

package/dist/src/ingest-cache.js

@@ -34,6 +34,8 @@
 import { deposit, dispatchIngest, ingestOne as depositOne, } from "./mind/learning.js";
 import { bindSeat, companySignature } from "./sema.js";
 import { BoundedMap } from "./store.js";
+import { invalidateStructuralCaches } from "./mind/traverse.js";
+import { invalidateJunctionCache } from "./mind/junction.js";
 /**
  * An ingest cache layered over a Mind.
  *
@@ -82,6 +84,8 @@ export class CachedIngest {
     }
     // ── public API ────────────────────────────────────────────────────────
     async ingest(input, second) {
+        invalidateStructuralCaches(this.mind);
+        invalidateJunctionCache(this.mind);
         // One shape-reading for both ingest paths — see {@link dispatchIngest}.
         return dispatchIngest(input, second, (i) => this.ingestOne(i), (a, b) => this.ingestPair(a, b));
     }

package/dist/src/meter.d.ts

@@ -129,6 +129,11 @@ export declare class Meter {
     /** Nodes popped by those ascents, against their √N·W budget — the counter
      *  that shows whether the walks are deciding early or burning the budget. */
     junctionPops: number;
+    /** Arbitrary byte spans whose distributional company was VSA-bundled from
+     *  existing episode halos. */
+    spanHalos: number;
+    /** Canonical W-windows examined while composing those span halos. */
+    spanHaloWindows: number;
     /** `lightestDerivation` searches started. */
     searches: number;
     /** Chart items popped by those searches. */

package/dist/src/meter.js

@@ -122,6 +122,11 @@ export class Meter {
     /** Nodes popped by those ascents, against their √N·W budget — the counter
      *  that shows whether the walks are deciding early or burning the budget. */
     junctionPops = 0;
+    /** Arbitrary byte spans whose distributional company was VSA-bundled from
+     *  existing episode halos. */
+    spanHalos = 0;
+    /** Canonical W-windows examined while composing those span halos. */
+    spanHaloWindows = 0;
     /** `lightestDerivation` searches started. */
     searches = 0;
     /** Chart items popped by those searches. */

package/dist/src/mind/attention.js

@@ -1509,6 +1509,16 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo, td) {
     // the same container (or a sub-container of it) twice.
     const consumed = new Set();
     let probes = 0;
+    // Once atoms themselves are hubs (N > W²), the cross-region analysis gets
+    // one k·W walk allowance per evidence tier. Without a shared allowance,
+    // each of k candidate pairs spends the full corpus-derived budget and a
+    // cumulative dialogue multiplies bounded work into tens of seconds. Small
+    // corpora retain exhaustive exact traversal: below this same scale the
+    // budget would be smaller than the structures the tests deliberately build.
+    const marketScale = k * ctx.space.maxGroup;
+    const corpusScale = N > marketScale ** 3;
+    const exactBudget = corpusScale ? { n: k * ctx.space.maxGroup } : undefined;
+    const synonymBudget = corpusScale ? { n: k * ctx.space.maxGroup } : undefined;
     for (let a = 0; a < cand.length && probes < k; a++) {
         if (consumed.has(cand[a]))
             continue;
@@ -1521,6 +1531,13 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo, td) {
                 continue;
             if (ra.end >= rb.start)
                 continue; // overlap or adjacent — nothing between
+            // In a cumulative conversation, an old↔old interaction cannot explain
+            // the user turn currently being answered; it was already available
+            // before that turn existed. Keep old↔current pairs (the current turn may
+            // refer to a prior answer), but do not repeatedly spend the junction
+            // budget recomposing two regions wholly before the current boundary.
+            if (ctx.currentTurnStart > 0 && rb.end <= ctx.currentTurnStart)
+                continue;
             // Candidates strictly BETWEEN ra and rb (cand is sorted by start, so
             // that is exactly cand[a+1 .. b-1]) that already cast their OWN vote —
             // genuine, individually-corroborated evidence about what fills the gap
@@ -1587,7 +1604,7 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo, td) {
             // ladder rung repeats a halo ANN query an earlier rung already paid for.
             const sides = await loadJunctionSynonymSides(ctx, left, right);
             let tier = "exact";
-            let containers = junctionContainersFrom(ctx, left, right, cap, seedsOf(cand[a]), seedsOf(cand[b]), undefined, true);
+            let containers = junctionContainersFrom(ctx, left, right, cap, seedsOf(cand[a]), seedsOf(cand[b]), exactBudget, true);
             if (probe) {
                 probe.exact = {
                     attempted: true,
@@ -1598,7 +1615,7 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo, td) {
                 // Tiers 2-4 — synonym containers (junctionSynonyms itself runs
                 // single-synonym first, falling to double-synonym only when
                 // single-synonym found nothing — see junction.ts).
-                const syn = await junctionSynonyms(ctx, left, right, maxInterior, true, sides);
+                const syn = await junctionSynonyms(ctx, left, right, maxInterior, true, sides, synonymBudget);
                 if (probe) {
                     const singleAttempted = sides.leftSiblings.length > 0 ||
                         sides.rightSiblings.length > 0;

package/dist/src/mind/bridge.js

@@ -26,11 +26,11 @@
 //     them reused across ≥ 2 containers (the same "≥ 2 structural parents"
 //     bar propagateSuffixes gates suffix inheritance with).  An untrained
 //     word ("deadliest") has no stored windows and can never substitute.
-//   • GEOMETRIC IDENTITY — the two spans' own perceived gists must clear
-//     conceptThreshold(D), the same "same concept" bar haloSiblings and
-//     articulation already gate on.  This is what separates a synonym pair
-//     the fold geometry genuinely identifies ("biggest"~"largest", sharing
-//     most of their bytes and their role) from an arbitrary co-frame word.
+//   • GRADED IDENTITY — lexical geometry is tried first at
+//     conceptThreshold(D). Differently-spelled forms fall through to VSA
+//     company: their stored W-window occurrences ascend to learned episodes,
+//     whose bundled halos must clear significanceBar(D), the same
+//     distributional-evidence bar used by analogyStrength.
 //
 // A candidate context is accepted when its aligned-plus-substituted spans
 // DOMINATE the query (the same half-dominance predicate used throughout)
@@ -41,9 +41,9 @@
 //
 // COST: nothing on any answering path — the bridge runs only where the
 // alternative was silence.  There it pays O(|query|) content-hash probes
-// (the propagateSuffixes trick), at most W anchor climbs and hubBound
-// candidate reads, and one O(|query|·|candidate|)-bounded alignment each —
-// all capped by existing derived bounds (W, chainReach, hubBound).
+// (the propagateSuffixes trick), at most W anchor climbs and
+// 2·recallQueryK candidate reads, and one
+// O(|query|·|candidate|)-bounded alignment each.
 //
 // FIXED WRONG-ANSWER GAP (found and closed 2026-07-20): a proper-noun swap
 // could pass both derived gates above and voice a WRONG fact.  Live case:
@@ -90,12 +90,14 @@
 //     boiling-point and lowercase-France bridge wins are unaffected; full
 //     suite green (358/358).
 import { cosine } from "../vec.js";
-import { conceptThreshold, dominates } from "../geometry.js";
+import { conceptThreshold, dominates, significanceBar } from "../geometry.js";
 import { bytesEqual, indexOf } from "../bytes.js";
 import { foldTree, perceive, read } from "./primitives.js";
 import { chainReach, leafIdRun } from "./canonical.js";
 import { corpusN, edgeAncestors, hubBound, sharedReachMemo, } from "./traverse.js";
 import { rItem, rNode } from "./trace.js";
+import { junctionContainersFrom } from "./junction.js";
+import { spanHalo } from "./match.js";
 /** True when some query byte-range left UNACCOUNTED by `spans` contains a
  *  STORED window — content the store has seen that the proposed reading
  *  simply ignores.  The IGNORED-KNOWN principle: a span may be dismissed
@@ -238,8 +240,33 @@ async function bridgeImpl(ctx, query, proposed) {
         return null;
     const bound = hubBound(ctx);
     const N = corpusN(ctx);
+    const marketScale = ctx.cfg.recallQueryK * W;
+    const candidateCap = N <= marketScale ** 3 ? bound : 2 * ctx.cfg.recallQueryK;
     const bar = conceptThreshold(ctx.store.D);
+    const synonymBar = significanceBar(ctx.store.D);
     const reachCap = chainReach(W);
+    const diagnostics = ctx.trace
+        ? {
+            anchors: 0,
+            picked: 0,
+            proposed: 0,
+            structuralProposed: 0,
+            proposedGrounded: 0,
+            synonymChecks: 0,
+            bestSynonym: 0,
+            climbed: 0,
+            phraseScale: 0,
+            seeded: 0,
+            aligned: 0,
+            structurallyValid: 0,
+            coverageValid: 0,
+            identityValid: 0,
+            knownContentValid: 0,
+            bestCovered: 0,
+            bestRank: -1,
+            closest: [],
+        }
+        : null;
     // PHRASE-SCALE CANDIDATE CAP — the same |content|·W bound the weave
     // (pipeline-mechanism.ts), the cross-region junction ladder's
     // `maxInterior`, and structural resonance's `maxSiblingBytes` all apply,
@@ -296,8 +323,12 @@ async function bridgeImpl(ctx, query, proposed) {
             continue;
         anchors.push({ off: o, id, rarity });
     }
-    if (anchors.length === 0)
+    if (diagnostics)
+        diagnostics.anchors = anchors.length;
+    if (anchors.length === 0) {
+        ctx.trace?.step("substitutionBridge", [rItem(query, "query")], [], "no stored query window can anchor a corroborated substitution", undefined, diagnostics);
         return null;
+    }
     // CORROBORATION (see the module-level doc) over the precomputed window
     // facts: the query span [qs,qe) attests when every full W-window inside
     // it is a stored flat form and at least one is reused across ≥ 2
@@ -359,22 +390,42 @@ async function bridgeImpl(ctx, query, proposed) {
     const explainedSpan = (bytes, from, to) => {
         if (to - from < W)
             return true;
-        for (let o = from; o + W <= to; o++) {
-            const ids = leafIdRun(ctx, bytes, o, o + W);
-            if (ids === null)
-                return false;
-            const wid = ctx.store.findBranch(ids);
-            if (wid === null)
-                return false;
-            const r = edgeAncestors(ctx, wid, N, reachMemo);
-            if (r.saturated)
-                continue; // in too many places to discriminate
-            if (r.roots.length === 0)
-                return false; // reaches nothing: novel content
-            if (!dominates(r.contextsReached, N))
+        const common = (start, end) => {
+            if (end - start < W)
                 return false;
+            for (let o = start; o + W <= end; o++) {
+                const ids = leafIdRun(ctx, bytes, o, o + W);
+                if (ids === null)
+                    return false;
+                const wid = ctx.store.findBranch(ids);
+                if (wid === null)
+                    return false;
+                const r = edgeAncestors(ctx, wid, N, reachMemo);
+                if (r.saturated)
+                    continue; // in too many places to discriminate
+                if (r.roots.length === 0)
+                    return false; // reaches nothing: novel content
+                if (!dominates(r.contextsReached, N))
+                    return false;
+            }
+            return true;
+        };
+        if (common(from, to))
+            return true;
+        // Alignment may attach the shared delimiter to either side of an inserted
+        // phrase. Up to W-1 boundary bytes are below the fold's identity scale;
+        // classify the phrase by a full-window interior core when one exists.
+        // This does not erase a short discriminative insertion: "heavy" still
+        // leaves the full `heav`/`eavy` windows for the corpus-global test.
+        for (let left = 0; left < W; left++) {
+            for (let right = 0; right < W; right++) {
+                if (left + right === 0 || left + right >= W)
+                    continue;
+                if (common(from + left, to - right))
+                    return true;
+            }
         }
-        return true;
+        return false;
     };
     anchors.sort((a, b) => a.rarity - b.rarity);
     // Up to W anchors, at least one window apart — the quantum's own count.
@@ -386,6 +437,8 @@ async function bridgeImpl(ctx, query, proposed) {
             continue;
         picked.push(a);
     }
+    if (diagnostics)
+        diagnostics.picked = picked.length;
     // 2. Candidate trained contexts.  Two proposal channels, one verifier:
     //    (a) the caller's PROPOSED hits — recall's whole-query resonance
     //    ranking, the retrieval structure built to surface near-paraphrase
@@ -395,20 +448,50 @@ async function bridgeImpl(ctx, query, proposed) {
     //    candidate passes the same byte-exact alignment and gates below.
     const seen = new Set();
     const candidates = [];
-    // Proposal channel — carries its caller's own bound (recall's resonance
-    // k), so it neither consumes the climb's hub budget (on a small corpus
-    // √N is a handful and the proposals would crowd the climb out entirely)
-    // nor lets per-candidate byte work grow past that bound.  A proposal may
-    // be a FLAT content twin whose continuation edge lives on the
-    // fold-shaped deposit node with the same bytes — the same twin split
-    // canonResolve bridges by re-folding (primitives.ts) — but the re-fold
-    // (a full perceive of the candidate's bytes) is paid only for proposals
-    // that could align at all: alignment can only seed at a picked anchor
-    // window occurring literally in the candidate (measured: unconditional
-    // re-folds multiplied the refusal-path latency several-fold).
-    // FIRST TOUCH of the caller's proposals — past every gate that could have
-    // refused without them (see substitutionBridge's doc).
-    for (const sid of await proposed()) {
+    // Exact co-occurrence proposes contexts the whole-form ANN can miss when a
+    // short insertion shifts every later fold boundary. The byte alignment below
+    // remains the decider. All pairs share one candidateCap·W junction
+    // allowance, ordered
+    // by their rarest side and then span: a rare content window joined to a
+    // distant frame boundary discriminates a whole question better than two
+    // neighbouring rare windows inside the same word.
+    if (query.length <= 2 * reachCap) {
+        const pairs = [];
+        for (let i = 0; i < picked.length; i++) {
+            for (let j = i + 1; j < picked.length; j++) {
+                pairs.push([picked[i], picked[j]]);
+            }
+        }
+        pairs.sort((a, b) => Math.min(a[0].rarity, a[1].rarity) -
+            Math.min(b[0].rarity, b[1].rarity) ||
+            Math.abs(b[0].off - b[1].off) - Math.abs(a[0].off - a[1].off) ||
+            a[0].rarity + a[1].rarity - b[0].rarity - b[1].rarity);
+        const structuralBudget = {
+            n: chainReach(W) * W * ctx.cfg.recallQueryK,
+        };
+        for (const [left, right] of pairs.slice(0, W)) {
+            const found = junctionContainersFrom(ctx, query.subarray(left.off, left.off + W), query.subarray(right.off, right.off + W), capBytes, [left.id], [right.id], structuralBudget, true);
+            for (const hit of found) {
+                if (candidates.length >= candidateCap)
+                    break;
+                if (seen.has(hit.id) || !ctx.store.hasNext(hit.id))
+                    continue;
+                seen.add(hit.id);
+                candidates.push(hit.id);
+                if (diagnostics)
+                    diagnostics.structuralProposed++;
+            }
+        }
+    }
+    // Once exact structural proposals fill the shared cap, no caller proposal
+    // can enter the verifier. Do not evaluate the lazy ANN thunk merely to
+    // discard every result at the loop's first guard.
+    const proposedIds = candidates.length < candidateCap ? await proposed() : [];
+    if (diagnostics)
+        diagnostics.proposed = proposedIds.length;
+    for (const sid of proposedIds) {
+        if (candidates.length >= candidateCap)
+            break;
         if (seen.has(sid))
             continue;
         seen.add(sid);
@@ -429,15 +512,28 @@ async function bridgeImpl(ctx, query, proposed) {
             seen.add(use);
         }
         candidates.push(use);
+        if (diagnostics)
+            diagnostics.proposedGrounded++;
     }
+    // Proposal channel — carries its caller's own bound (recall's resonance
+    // k), sharing the 2·recallQueryK candidate allowance
+    // with the structural and climb channels. A proposal may
+    // be a FLAT content twin whose continuation edge lives on the
+    // fold-shaped deposit node with the same bytes — the same twin split
+    // canonResolve bridges by re-folding (primitives.ts) — but the re-fold
+    // (a full perceive of the candidate's bytes) is paid only for proposals
+    // that could align at all: alignment can only seed at a picked anchor
+    // window occurring literally in the candidate (measured: unconditional
+    // re-folds multiplied the refusal-path latency several-fold).
+    // FIRST TOUCH of the caller's proposals — past every gate that could have
+    // refused without them (see substitutionBridge's doc).
     // Climb channel — edge-bearing ancestors only, decided by the indexed
     // O(1) hasNext; no byte is read here (the climb visits hundreds of
     // roots, and reading each was measured to dominate the refusal path).
-    const proposedCount = candidates.length;
     for (const a of picked) {
-        const reach = edgeAncestors(ctx, a.id, N);
+        const reach = edgeAncestors(ctx, a.id, N, reachMemo);
         for (const sid of reach.roots) {
-            if (candidates.length - proposedCount >= bound)
+            if (candidates.length >= candidateCap)
                 break;
             if (seen.has(sid))
                 continue;
@@ -445,20 +541,42 @@ async function bridgeImpl(ctx, query, proposed) {
             if (!ctx.store.hasNext(sid))
                 continue;
             candidates.push(sid);
+            if (diagnostics)
+                diagnostics.climbed++;
         }
-        if (candidates.length - proposedCount >= bound)
+        if (candidates.length >= candidateCap)
             break;
     }
     // 3. Align each candidate; gate its mismatches; keep the best.
     // Over-cap candidates are dropped here rather than earlier: the climb
     // channel deliberately reads no bytes while collecting (the climb visits
     // hundreds of roots), so this is where its proposals are first sized.
-    const allBytes = new Map();
-    for (const sid of candidates) {
+    //
+    // Candidate bytes are read LAZILY — on first access during the seed
+    // check — not eagerly for every collected id.  On a 325K-context store
+    // the climb channel alone can propose hundreds of edge-bearing ancestors
+    // (hubBound = 571), most of which will never contain a picked anchor
+    // window and would be discarded at the seed check without their bytes
+    // ever being consulted.  Eager reads for 500+ candidates each traversing
+    // the DAG (profiled at 12K node records and 73KB of bytes read per
+    // refusing query) is the dominant remaining bridge cost after the ANN
+    // gate.  A Map stays available for the frame-unanimity scan below, which
+    // only needs bytes of candidates that actually seeded.
+    const seededBytes = new Map();
+    /** Read a candidate's bytes once; cache for the seed check AND for the
+     *  frame-unanimity scan that follows alignment.  Returns null when the
+     *  candidate exceeds the phrase-scale cap or has no content. */
+    const bytesOfCandidate = (sid) => {
+        const hit = seededBytes.get(sid);
+        if (hit !== undefined)
+            return hit;
         const b = candidateBytes(sid);
         if (b !== null)
-            allBytes.set(sid, b);
-    }
+            seededBytes.set(sid, b);
+        return b;
+    };
+    if (diagnostics)
+        diagnostics.phraseScale = seededBytes.size;
     // FRAME UNANIMITY: a substitution U → C inside the frame (Lf, Rf) is
     // groundable only when the collected candidates — the store's own sample
     // of contexts sharing the query's content — are unanimous about the
@@ -477,7 +595,7 @@ async function bridgeImpl(ctx, query, proposed) {
     // the substitution was accepted).  "Unanimous" must mean the store's own
     // instances agree, which requires at least one instance to consult.
     const unanimous = (u, c, lf, rf) => {
-        for (const bytes of allBytes.values()) {
+        for (const bytes of seededBytes.values()) {
             let from = 0;
             for (;;) {
                 const i = indexOf(bytes, lf, from);
@@ -509,9 +627,15 @@ async function bridgeImpl(ctx, query, proposed) {
     // check — verified live).
     let best = null;
     let bestAccounted = 0;
-    for (const sid of candidates) {
-        const cBytes = allBytes.get(sid);
-        if (cBytes === undefined)
+    const queryHaloMemo = new Map();
+    const candidateHaloMemo = new Map();
+    for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) {
+        const sid = candidates[candidateIndex];
+        // Read bytes lazily — most climb-proposed candidates have no picked
+        // anchor window and will never pass the seed check below, so their
+        // bytes are never read at all.
+        const cBytes = bytesOfCandidate(sid);
+        if (cBytes === null)
             continue;
         // Seed at the rarest picked anchor that literally occurs in this
         // candidate.
@@ -525,7 +649,30 @@ async function bridgeImpl(ctx, query, proposed) {
         }
         if (seed === null)
             continue;
+        if (diagnostics)
+            diagnostics.seeded++;
         const { matched, gaps } = align(ctx, query, cBytes, seed.qo, seed.co);
+        if (diagnostics)
+            diagnostics.aligned++;
+        // Investment gate: even treating every two-sided mismatch as a valid
+        // synonym, can this alignment satisfy the bridge's final coverage rule?
+        // Distributional span composition performs bounded ancestor climbs; never
+        // pay for it on a candidate arithmetic already proves cannot win.
+        let matchStart = query.length;
+        let matchEnd = 0;
+        let potential = 0;
+        for (const [s, e] of matched) {
+            matchStart = Math.min(matchStart, s);
+            matchEnd = Math.max(matchEnd, e);
+            potential += e - s;
+        }
+        for (const g of gaps) {
+            if (g.qe > g.qs && g.ce > g.cs)
+                potential += g.qe - g.qs;
+        }
+        if (matchStart > W || query.length - matchEnd > W ||
+            !dominates(potential, query.length))
+            continue;
         // Gate each mismatch: a corroborated, geometrically-identified
         // substitution counts as accounted; anything else stays a gap.
         //
@@ -565,12 +712,14 @@ async function bridgeImpl(ctx, query, proposed) {
             // happen to share a few letters.  Uses the SAME dominates() bar
             // (part*2 > whole) applied throughout the codebase, symmetrically:
             // the smaller raw side must be more than half the larger.  Applies
-            // to the RAW gap, before expansion — expansion only ever grows both
-            // sides by IDENTICAL absorbed bytes, so it cannot fix an imbalance
-            // that was already there.
+            // to the RAW gap for GEOMETRIC identity, before expansion — expansion
+            // only ever grows both sides by IDENTICAL absorbed bytes, so it cannot
+            // fix an imbalance that was already there. Distributional synonym
+            // evidence is exempt: two phrases may occupy the same role at very
+            // different lengths.
             let accepted = false;
             const balanced = dominates(Math.min(uLen, cLen), Math.max(uLen, cLen));
-            const maxExtra = balanced ? reachCap - Math.max(uLen, cLen) : -1;
+            const maxExtra = reachCap - Math.max(uLen, cLen);
             outer: for (let extra = 0; extra <= maxExtra; extra++) {
                 for (let a = 0; a <= extra; a++) {
                     const b = extra - a;
@@ -596,7 +745,31 @@ async function bridgeImpl(ctx, query, proposed) {
                         continue;
                     const u = query.subarray(qs2, qe2);
                     const cSpan = cBytes.subarray(cs2, ce2);
-                    if (cosine(perceive(ctx, u).v, perceive(ctx, cSpan).v) < bar) {
+                    const geometric = cosine(perceive(ctx, u).v, perceive(ctx, cSpan).v);
+                    const qKey = `${qs2}:${qe2}`;
+                    let qHalo = queryHaloMemo.get(qKey);
+                    if (qHalo === undefined) {
+                        qHalo = spanHalo(ctx, query, qs2, qe2);
+                        queryHaloMemo.set(qKey, qHalo);
+                    }
+                    const cKey = `${sid}:${cs2}:${ce2}`;
+                    let cHalo = candidateHaloMemo.get(cKey);
+                    if (cHalo === undefined) {
+                        cHalo = spanHalo(ctx, cBytes, cs2, ce2);
+                        candidateHaloMemo.set(cKey, cHalo);
+                    }
+                    const distributional = qHalo !== null && cHalo !== null
+                        ? cosine(qHalo, cHalo)
+                        : 0;
+                    if (diagnostics) {
+                        diagnostics.synonymChecks++;
+                        diagnostics.bestSynonym = Math.max(diagnostics.bestSynonym, distributional);
+                    }
+                    // Graded identity: byte geometry remains the cheap first tier;
+                    // VSA company is the synonym tier when differently-spelled forms
+                    // occupy the same learnt distributional role.
+                    if ((!balanced || geometric < bar) &&
+                        distributional < synonymBar) {
                         continue;
                     }
                     if (!unanimous(u, cSpan, query.subarray(qs2 - W, qs2), query.subarray(qe2, qe2 + W)))
@@ -625,6 +798,8 @@ async function bridgeImpl(ctx, query, proposed) {
         // recall's job, not the bridge's.
         if (!ok)
             continue;
+        if (diagnostics)
+            diagnostics.structurallyValid++;
         // Coverage: matched runs plus accepted substitutions must dominate the
         // query, every interior gap already proved ≤ W above, and the EDGES
         // must be explained to the same one-window tolerance — the same "at
@@ -645,10 +820,34 @@ async function bridgeImpl(ctx, query, proposed) {
             covered += e - Math.max(s, reachEnd);
             reachEnd = Math.max(reachEnd, e);
         }
+        if (diagnostics) {
+            diagnostics.bestCovered = Math.max(diagnostics.bestCovered, covered);
+            const candidateGapBytes = gaps.reduce((n, g) => n + g.ce - g.cs, 0);
+            diagnostics.closest.push({
+                id: sid,
+                covered,
+                leading: spans[0][0],
+                trailing: query.length - reachEnd,
+                gaps: gaps.length,
+                substitutions: subs.length,
+                queryGapBytes: gaps.reduce((n, g) => n + g.qe - g.qs, 0),
+                candidateGapBytes,
+                gapRanges: gaps.map((g) => [g.qs, g.qe, g.cs, g.ce]),
+                candidateSurplus: cBytes.length - covered - candidateGapBytes,
+                gapsExplained: gaps.every((g) => explainedSpan(cBytes, g.cs, g.ce)),
+            });
+            diagnostics.closest.sort((a, b) => b.covered - a.covered ||
+                a.leading + a.trailing - b.leading - b.trailing ||
+                a.id - b.id);
+            if (diagnostics.closest.length > W)
+                diagnostics.closest.length = W;
+        }
         if (spans[0][0] > W || query.length - reachEnd > W)
             continue;
         if (!dominates(covered, query.length))
             continue;
+        if (diagnostics)
+            diagnostics.coverageValid++;
         // ZERO-SUBSTITUTION ADMISSION — an IDENTITY claim, not a substitution.
         //
         // A candidate needing no substitution is normally refused (see the trap
@@ -715,6 +914,8 @@ async function bridgeImpl(ctx, query, proposed) {
             if (!gaps.every((g) => explainedSpan(cBytes, g.cs, g.ce)))
                 continue;
         }
+        if (diagnostics)
+            diagnostics.identityValid++;
         // KNOWN content may never be dismissed — see dismissedKnownContent
         // (the live case: "what is the capital of france" aligning into a
         // Matrix synopsis by writing off "ance" — a stored window of the
@@ -722,9 +923,13 @@ async function bridgeImpl(ctx, query, proposed) {
         // test/49's untrained "Name" remain tolerable).
         if (dismissedKnownQ(spans))
             continue;
+        if (diagnostics)
+            diagnostics.knownContentValid++;
         if (covered > bestAccounted) {
             bestAccounted = covered;
             best = { id: sid, accounted: spans, subs };
+            if (diagnostics)
+                diagnostics.bestRank = candidateIndex;
         }
     }
     if (best !== null) {
@@ -732,7 +937,11 @@ async function bridgeImpl(ctx, query, proposed) {
             rNode(ctx, best.id, "bridged-context"),
             ...best.subs.map((s) => rItem(query.subarray(s.qs, s.qe), "substituted")),
         ], `a trained context accounts for the query up to ${best.subs.length} ` +
-            `corroborated substitution(s) — grounding through its learnt edges`);
+            `corroborated substitution(s) — grounding through its learnt edges`, undefined, diagnostics);
+    }
+    else {
+        ctx.trace?.step("substitutionBridge", [rItem(query, "query")], [], "candidate contexts were proposed, but none passed the bridge's " +
+            "structural identity and corroboration gates", undefined, diagnostics);
     }
     return best;
 }

package/dist/src/mind/junction.d.ts

@@ -45,9 +45,9 @@ export declare function loadJunctionSynonymSides(ctx: MindContext, left: Uint8Ar
  *  Exported for callers (synonym junctions) that hold one side FIXED across
  *  several calls and so compute its seeds once instead of per call. */
 export declare function junctionSeeds(ctx: MindContext, b: Uint8Array): number[];
-/** Per-response cache of the identity walks' pure reads (capped bytes,
- *  parent pages, container pages), keyed by the response lifecycle object
- *  (ctx.climbMemo).  One response issues many walks whose ancestries overlap
+/** Session cache of the identity walks' pure reads (capped bytes,
+ *  parent pages, container pages), keyed by the write-invalidated structural
+ *  lifecycle object. One response issues many walks whose ancestries overlap
  *  heavily (pair sides repeat across combos, and synonym walks revisit the
  *  same neighbourhoods); the store is read-only while a response is in flight,
  *  so every one of these reads is a pure function of the id — repeats cost a
@@ -63,6 +63,7 @@ export interface WalkCache {
     containers: Map<number, number[]>;
 }
 export declare function walkCache(ctx: MindContext): WalkCache | null;
+export declare function invalidateJunctionCache(ctx: MindContext): void;
 export declare function cachedRead(ctx: MindContext, cache: WalkCache | null, id: number, cap: number): Uint8Array;
 /** Tier 1 body, parameterised on already-resolved seed lists so a caller
  *  holding one side FIXED across several calls (synonym junctions) pays for
@@ -131,4 +132,6 @@ export declare function junctionContainers(ctx: MindContext, left: Uint8Array, r
  *  cost is bounded at √N·W pops total regardless of how many siblings are
  *  tried.  A sibling whose bytes exceed `maxInterior` is skipped (it
  *  cannot be junction-sized). */
-export declare function junctionSynonyms(ctx: MindContext, left: Uint8Array, right: Uint8Array, maxInterior: number, unordered?: boolean, sides?: JunctionSynonymSides): Promise<SynonymJunction[]>;
+export declare function junctionSynonyms(ctx: MindContext, left: Uint8Array, right: Uint8Array, maxInterior: number, unordered?: boolean, sides?: JunctionSynonymSides, sharedBudget?: {
+    n: number;
+}): Promise<SynonymJunction[]>;