@hviana/sema 0.4.3 → 0.4.6

package/dist/src/mind/attention.js

@@ -9,7 +9,7 @@
 import { isChunk } from "../sema.js";
 import { lightestDerivation, } from "../derive/src/index.js";
 import { composeStructuralGist, consensusFloor, dominates, estimatorNoise, } from "../geometry.js";
-import { foldTree, gistOf, latin1Key, perceive, read } from "./primitives.js";
+import { foldTree, gistOf, latin1Key, perceive, read, resolve, } from "./primitives.js";
 import { recognise } from "./recognition.js";
 import { leafIdRun } from "./canonical.js";
 import { corpusN, edgeAncestors, hubBound, sharedReachMemo, } from "./traverse.js";
@@ -139,6 +139,18 @@ export async function computeAttention(ctx, query, k, mode) {
             // positional accident this work exists to remove.
             chunk: false,
             known: true, // a recognised site IS a stored form
+            // …and CARRY WHICH ONE.  `known: true` claimed exactness while the
+            // identity itself was dropped, leaving the climb to re-derive it from
+            // the gist through the ANN — so which stored node an exact site voted
+            // with turned on approximate rank.  Measured on test/34: the site
+            // "square" ([10,16), payload 40) resonated to "quare" (119) instead;
+            // the exact junction tier then found no container holding both "blue"
+            // and 119, fell through to the single-synonym tier, and "blue then
+            // square" attended to "red square" — a context NEITHER attribute
+            // attends to alone.  This is the same exact-first economy chunks
+            // already get from canonicalChunkId, and it REMOVES an ANN query
+            // rather than adding one.
+            id: s.payload,
         });
     }
     // The trace draft (spec §9): allocated ONLY when a trace was requested —
@@ -273,6 +285,105 @@ export function collectRegions(ctx, query) {
         // left the sentences CAST needs with no free run at all (C2, C3).  A
         // region must come from the fold, not from a stride over it.
     });
+    // ─── FORMS THE QUERY'S OWN CUT SPLIT ────────────────────────────────────
+    // The walk above enumerates FOLD NODES ONLY, so a stored form the query's
+    // content-defined cut happens to split is not addressable at all — however
+    // discriminative it is.  Measured: `request_id=1042` against a 200-record
+    // log, the query's best match, cut as `...uest_id=|10|42 and r`; "1042"
+    // reaches exactly ONE context of 205 (maximal IDF) and cast no vote, while
+    // the scaffolding "=10" — which matches every record 1000–1099 — did.  The
+    // climb was voting on the only evidence it could address, and that was the
+    // non-discriminative kind.
+    //
+    // The WRITE path already made these reachable: canonicalWindows interns a
+    // form at both lengths precisely so one straddling a cut resolves from
+    // either side.  The read path simply never used the guarantee.  So this is
+    // recovered here by lookup — the fold, its invariants and the write path
+    // are untouched.
+    //
+    // Admitting every resolvable window is REFUTED (it is the ascent-sites
+    // failure): on a 5-context corpus a 26-byte query yielded 17 "unique"
+    // windows that were all fragments of ONE word (" pai" "pain" "aint" …).
+    // No per-window threshold separates that from the log case — the two need
+    // the same windows ADMITTED and COLLAPSED at identical per-window IDF.  It
+    // is a REDUNDANCY problem, so overlapping admitted windows are COALESCED
+    // into maximal spans: the log query then yields the two disjoint records it
+    // names, and the 17 fragments yield the one span " painted the Mona Lisa".
+    const W = ctx.space.maxGroup;
+    if (query.length > W) {
+        const N = corpusN(ctx);
+        const reachMemo = sharedReachMemo(ctx);
+        // Coalesce while sweeping left to right: a window overlapping (or just
+        // touching) the span under construction extends it.  Merging cannot
+        // inflate what the climb pays for this evidence — the merged span votes
+        // as ITSELF, and a longer span is at least as discriminative as its most
+        // discriminative part, i.e. its reach is bounded by the MIN over the
+        // windows that built it.
+        const spans = [];
+        // COVERAGE BY PREFIX MAXIMUM, NOT BY RESCANNING THE REGIONS.
+        // The containment test below is the loop's hot path — it rejects 97% of
+        // windows — and asking it as `regions.some(...)` re-walked every region
+        // at every offset: O(|query| · |regions|).  That is quadratic in the
+        // input, and the region count grows with it — measured 1,510 regions on
+        // an 8,195-byte query, i.e. ~12.4M predicate evaluations in ONE call,
+        // against the constant-KB/s law test/14 asserts.
+        //
+        // A region contains the window [o, o+W) exactly when it starts at or
+        // before `o` and ends at or after `o+W`.  So the only thing the test
+        // needs from the regions is, per offset, the FARTHEST end among those
+        // starting at or before it — a prefix maximum, built in one pass and
+        // read in O(1).  Identical verdict by construction, no behaviour change.
+        const maxEndFrom = new Int32Array(query.length + 1);
+        for (const r of regions) {
+            if (r.start <= query.length && r.end > maxEndFrom[r.start]) {
+                maxEndFrom[r.start] = r.end;
+            }
+        }
+        for (let i = 1; i <= query.length; i++) {
+            if (maxEndFrom[i - 1] > maxEndFrom[i])
+                maxEndFrom[i] = maxEndFrom[i - 1];
+        }
+        for (let o = 0; o + W <= query.length; o++) {
+            // A window some fold region wholly contains offers no address the walk
+            // above did not already offer.
+            if (maxEndFrom[o] >= o + W)
+                continue;
+            const ids = leafIdRun(ctx, query, o, o + W);
+            if (ids === null)
+                continue;
+            const wid = ctx.store.findBranch(ids);
+            if (wid === null)
+                continue;
+            const reach = edgeAncestors(ctx, wid, N, reachMemo);
+            // Saturated = the climb ABSTAINED; no roots = it reached nothing that
+            // could corroborate anything.  Neither is evidence.
+            if (reach.saturated || reach.roots.length === 0)
+                continue;
+            const last = spans[spans.length - 1];
+            if (last && o <= last.end)
+                last.end = o + W;
+            else
+                spans.push({ start: o, end: o + W });
+        }
+        for (const { start, end } of spans) {
+            // The same wrapper filter the fold regions pass through.
+            if (dominates(end - start, query.length) && regions.length > 0)
+                continue;
+            regions.push({
+                v: gistOf(ctx, query.subarray(start, end)),
+                start,
+                end,
+                // NOT a chunk: `chunk` means "a smallest grouped unit the FOLD
+                // produced", and this span was assembled here.  Setting it is
+                // REFUTED — it cost 5 tests (honest silence, fusion direction, both
+                // test/50 probes) where chunk:false costs none.
+                chunk: false,
+                known: true,
+                // EVIDENCE, NOT A POINT OF ATTENTION — see Region.corroborating.
+                corroborating: true,
+            });
+        }
+    }
     return regions;
 }
 export async function voteRegions(ctx, query, regions, k, mode, N, reachMemo, td) {
@@ -286,7 +397,89 @@ export async function voteRegions(ctx, query, regions, k, mode, N, reachMemo, td
         // `v`/`start`/`end` are rebindable: a long approximate segment may vote
         // with the sub-span that actually carries its evidence — see below.
         let { v, start, end } = regions[ri];
-        const { chunk, known } = regions[ri];
+        const { chunk } = regions[ri];
+        // BELOW ONE RIVER WINDOW, BYTE IDENTITY IS NOT EVIDENCE.  The same
+        // principle identityBar states and recognition's own `emit` already
+        // enforces on sites ("below one river window, byte overlap is chance"),
+        // applied to what the climb calls EXACT.  It was unnecessary while the
+        // fold grouped at fixed arity — every chunk was then exactly W bytes —
+        // but content-defined cuts run from W-1 up to the keyring's seat count,
+        // so sub-window segments now exist, and a 3-byte string is interned by
+        // triviality rather than by evidence.
+        //
+        // Such a region is NOT dropped: it still votes on its gist, through the
+        // contrastive-margin gate every approximate region pays.  Dropping them
+        // outright was measured and REFUTED — the suite fell 441 -> 406, because
+        // short regions do carry real evidence; what they must not carry is the
+        // EXACT tier's full mutual weight and its exemption from the margin.
+        //
+        // Measured on test/50's junk query: the 3-byte chunk "of " voted exact
+        // at mutual 1.00 with idf 4.22, and an unrelated haiku exemplar's pooled
+        // vote went 1.13 -> 5.94 — past consensusFloor (5.82), making a junk root
+        // TRUSTED and licensing CAST to compare content the query never named.
+        // consensusFloor did not drift; what fed it stopped being evidence.
+        //
+        // A region spanning the WHOLE query is exempt, exactly as the site rule
+        // exempts a whole-query span: it is then not a fragment of something
+        // longer, it is the question ("red" asked on its own — test/34).
+        const subWindow = end - start < W &&
+            !(start === 0 && end === query.length);
+        // EXACTNESS IS A PROPERTY OF THE CONTENT, NOT OF THIS QUERY'S GROUPING.
+        // `known` used to mean "these bytes resolve to ONE stored node", which
+        // conflates two different things: whether the store has seen the content,
+        // and whether this query's cut happened to group it the same way the
+        // deposit did.  Under fixed-arity folding those coincided; under
+        // content-defined cuts they routinely do not.
+        //
+        // Measured over 42 voting regions (attributes / capitals / artists),
+        // against a graded reading — what fraction of the region's river windows
+        // are content-addressed:
+        //
+        //   known=true   cov=1.0  90%   cov=0   0%   0<cov<1  10%
+        //   known=false  cov=1.0   5%   cov=0  52%   0<cov<1  43%
+        //
+        // The 5% are regions where EVERY window resolves — the content is
+        // entirely in the store — yet the region was called unknown purely
+        // because this cut grouped it differently, so it paid the contrastive
+        // margin as though it were an approximate gist. That is grouping churn
+        // taxed as uncertainty.
+        //
+        // Only the fully-addressed case is promoted here: every window resolving
+        // is exact evidence about the content by the same content-addressing the
+        // whole-region test uses, just read at the window scale identityBar
+        // already calls the floor below which overlap is chance. The partial band
+        // (43%) is deliberately NOT promoted — it is genuinely mixed evidence and
+        // the margin is the right price for it.  Paid only when the cheap whole-
+        // region test already failed, and bounded by the region's own length.
+        // HOW MUCH OF THIS REGION IS CONTENT-ADDRESSED — a fraction, not a bit.
+        // Measured over 42 voting regions, `known` as a boolean loses a wide band:
+        // 43% of "unknown" regions are PARTIALLY addressed and 5% are fully
+        // addressed while failing the whole-region test (grouping churn). Promoting
+        // the partial band wholesale was measured too and is over-crediting — it
+        // buys test/00 with a region attested 1 window in 5, granting a 20%-attested
+        // region the same full exemption a fully-attested one gets.
+        //
+        // So the coverage SCALES the bar instead of switching it: a region pays the
+        // estimator's noise floor in proportion to how much of it is NOT
+        // content-addressed. cov=1 pays nothing (identical to the old exemption),
+        // cov=0 pays the full floor (identical to the old gate), cov=0.2 pays 0.8
+        // of it. No new constant — estimatorNoise is unchanged and the coverage is
+        // read off the store by the same content addressing `known` already used.
+        const windowCoverage = () => {
+            if (end - start < W)
+                return 0;
+            let tot = 0, hit = 0;
+            for (let o = start; o + W <= end; o++) {
+                tot++;
+                if (resolve(ctx, query.subarray(o, o + W)) !== null)
+                    hit++;
+            }
+            return tot === 0 ? 0 : hit / tot;
+        };
+        // A sub-window region pays in full: below one river window its byte
+        // identity is chance, so it has no coverage to claim.
+        const cov = subWindow ? 0 : (regions[ri].known ? 1 : windowCoverage());
+        const known = cov >= 1 && !subWindow;
         // Trace-only bookkeeping for this region — allocated only under `td`
         // (i.e. only when ctx.trace is set); see ConsensusRegionTrace/
         // RegionOutcome (spec §4).  `examinedIds` tracks distinct ANN hits
@@ -327,9 +520,11 @@ export async function voteRegions(ctx, query, regions, k, mode, N, reachMemo, td
         // the resonate() call for most exact regions — the single largest
         // remaining inference sink — with the anchor choice unchanged (the
         // canonical branch already ignored hits[0]).
-        let canonicalId = chunk
-            ? canonicalChunkId(ctx, query.subarray(start, end), N, reachMemo)
-            : null;
+        let canonicalId = subWindow
+            ? null
+            : (chunk
+                ? canonicalChunkId(ctx, query.subarray(start, end), N, reachMemo)
+                : (regions[ri].id ?? null));
         let canonicalUsable = canonicalId !== null &&
             (ctx.store.hasParents(canonicalId) ||
                 ctx.store.hasContainers(canonicalId));
@@ -574,7 +769,8 @@ export async function voteRegions(ctx, query, regions, k, mode, N, reachMemo, td
                 break;
             }
             contrastiveMargin = margin;
-            const noiseFloor = estimatorNoise(ctx.store.D);
+            // Scaled by what this region does NOT address — see `cov` above.
+            const noiseFloor = estimatorNoise(ctx.store.D) * (1 - cov);
             if (margin <= noiseFloor) {
                 recordRegion("contrastive-margin-rejection", {
                     selected,
@@ -619,6 +815,8 @@ export async function voteRegions(ctx, query, regions, k, mode, N, reachMemo, td
             roots: reach.roots,
             w,
             wFocus,
+            // The pool sees VOTES, not regions — carry the region's standing with it.
+            ...(regions[ri].corroborating ? { corroborating: true } : {}),
         });
         if (ctx.trace) {
             regionVoter[ri] = { id: voterId, score, w: wf };
@@ -742,6 +940,41 @@ export function poolVotes(ctx, regionVotes, sat, N, td) {
     const support = new Map();
     const regionSupport = new Map();
     const regionSpans = new Map();
+    // ONE POOLED AXIOM = ONE REGION VOTE.  Counted separately from the spans
+    // below because the two are different quantities: a JOINT binding is a
+    // single vote whose evidence sits in several separate places (RegionVote.
+    // parts), so its span count exceeds its axiom count.  Reading the axiom
+    // count off `regionSpans.length` conflated them and broke the accounting
+    // both ways — contributingEvidence (absorbed-weighted, one term per
+    // REGION) could read below it, and it could exceed the query's whole
+    // candidate-region count.
+    const regionAxioms = new Map();
+    // ANCHORS THE QUERY ITSELF POINTED AT.  votesIdf is keyed by anchor node,
+    // but root election has to know something about the REGIONS underneath it:
+    // whether at least one of them is a structure the query wove, rather than a
+    // form its cut split and collectRegions recovered (Region.corroborating).
+    // An anchor standing on corroborating evidence ALONE is a real, well-priced
+    // vote — it just is not a point of attention the query made, so it must not
+    // enter the distribution the root cut is read from, nor the breadth ratio.
+    //
+    // REFUTED: barring such anchors from ROOT CANDIDACY outright.  It defeats
+    // the purpose — in the log case the CORRECT record (request_id=1042, one
+    // context of 205) is addressable ONLY through the form the cut split, so
+    // rejecting it handed the answer back to the near-miss 1050 (vote 5.60 ->
+    // 3.81).  Grounding follows where the evidence points; what a corroborating
+    // region must not do is make the query look like it wove one more topic
+    // than it did.
+    const anchored = new Set();
+    // The LARGEST single region's contribution to this anchor's pooled vote.
+    // The pool is a SUM (deliberately — see the pooling note above), so it says
+    // how much evidence there is in total, never whether any ONE place in the
+    // query carries evidence on its own.  Consumers that hold an anchor to
+    // consensusFloor(N) = ln(N) + 1/2 need the latter: that bar prices ONE
+    // region's maximally-discriminative evidence (ln N is the IDF of content
+    // reaching a single context), so comparing a six-region sum against it is a
+    // dimensional error.  Recorded here, beside the count, because this is the
+    // only place the per-region contributions are still separable.
+    const regionPeak = new Map();
     const steps = [];
     let order = 0;
     for (const pc of pool.values()) {
@@ -757,7 +990,16 @@ export function poolVotes(ctx, regionVotes, sat, N, td) {
                     continue;
                 seenRi.add(p0.ri);
                 const rv = regionVotes[p0.ri];
-                breadthSum += rv.absorbed ?? 1;
+                // Breadth is a ratio over the query's OWN candidate points of
+                // attention (see below), and a corroborating region is not one of
+                // those — it enters neither side of that ratio, so breadth reads
+                // exactly as it did before such regions existed.  Its evidence still
+                // counts everywhere else: it is a premise, and it is a separate
+                // PLACE for cluster counting — corroborating is what it is for.
+                if (!rv.corroborating) {
+                    breadthSum += rv.absorbed ?? 1;
+                    anchored.add(pc.item.id);
+                }
                 premises.push({ kind: "form", span: [rv.start, rv.end] });
                 // A vote knows where its own evidence sits: `parts` when it stands on
                 // several separate places (a joint binding), the merged span
@@ -770,7 +1012,31 @@ export function poolVotes(ctx, regionVotes, sat, N, td) {
                     spans.push([rv.start, rv.end]);
             }
             regionSupport.set(pc.item.id, breadthSum);
-            regionSpans.set(pc.item.id, spans);
+            // A span is a PLACE, and the same place reached through two different
+            // votes (a standalone region and one part of a joint binding) is still
+            // one place — listing it twice reports evidence the query does not
+            // separately hold.  Measured on test/50's fixture: span [18,21)
+            // appeared twice among the top anchor's five.
+            const seenSpan = new Set();
+            regionSpans.set(pc.item.id, spans.filter((sp) => {
+                const key = `${sp[0]}:${sp[1]}`;
+                if (seenSpan.has(key))
+                    return false;
+                seenSpan.add(key);
+                return true;
+            }));
+            regionAxioms.set(pc.item.id, seenRi.size);
+            let peak = 0;
+            for (const c of pc.contributions) {
+                const p0 = c.premises[0].item;
+                if (p0.kind !== "region")
+                    continue;
+                const rv = regionVotes[p0.ri];
+                const own = rv.wFocus ?? rv.w;
+                if (own > peak)
+                    peak = own;
+            }
+            regionPeak.set(pc.item.id, peak);
             steps.push({
                 order: order++,
                 move: "pool-vote",
@@ -800,7 +1066,17 @@ export function poolVotes(ctx, regionVotes, sat, N, td) {
             }
         }
     }
-    return { votes, votesIdf, support, regionSupport, regionSpans, steps };
+    return {
+        votes,
+        votesIdf,
+        support,
+        regionSupport,
+        regionSpans,
+        regionAxioms,
+        regionPeak,
+        anchored,
+        steps,
+    };
 }
 /** The number of DISTINCT clusters a root's contributing regions form —
  *  see Attention.clusters.  Two regions belong to the same cluster iff the
@@ -832,7 +1108,7 @@ function countClusters(spans, W) {
     return clusters;
 }
 export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg) {
-    const { votes, votesIdf, support, regionSupport, regionSpans, steps } = pooled;
+    const { votes, votesIdf, support, regionSupport, regionSpans, regionAxioms, regionPeak, anchored, steps, } = pooled;
     if (votes.size === 0) {
         traceAttention(ctx, regions, regionVoter, [], steps, td, cfg);
         return { roots: [], ranked: [] };
@@ -841,13 +1117,20 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
     // is the query's OWN full candidate count (most never vote at all), the
     // same denominator the "N of M sub-regions voted" rationale text already
     // reports; regionSupport is that same accounting read PER ANCHOR.
-    const totalRegions = Math.max(1, regions.length);
+    // Corroborating regions are excluded from the denominator for the same
+    // reason they are excluded from the numerator (see poolVotes): they are
+    // not candidate points of attention the query wove, so counting them would
+    // silently shrink every anchor's breadth — measured: test/36's genuine
+    // second topic fell 6/11 -> 6/12 and fusion's dispersion gate dropped it,
+    // with nothing else about the climb changed.
+    const totalRegions = Math.max(1, regions.filter((r) => !r.corroborating).length);
     const ranked = [...votes.entries()]
         .map(([anchor, vote]) => {
         const s = support.get(anchor);
         return {
             anchor,
             vote,
+            peak: regionPeak.get(anchor) ?? 0,
             start: s.start,
             end: s.end,
             breadth: (regionSupport.get(anchor) ?? 0) / totalRegions,
@@ -856,7 +1139,18 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
     })
         .sort((a, b) => b.vote - a.vote);
     const overlaps = (a, b) => a.start < b.end && b.start < a.end;
-    const idfDesc = [...votesIdf.values()].sort((a, b) => b - a);
+    // Read the root cut from the anchors the QUERY pointed at.  A vote standing
+    // only on corroborating evidence (a form the query's cut split, recovered
+    // by lookup — Region.corroborating) is evidence for someone else's anchor,
+    // never a point of attention of its own: the query never wove it as an
+    // independent structure, the fold did that.  Letting such votes into
+    // idfDesc shifts naturalBreak — they are exact, hence high-IDF, hence they
+    // land at the top of the distribution — and a 2-topic query then elects 3
+    // roots (test/24:404, and the answered-continuation exclusion probe).
+    const idfDesc = [...votesIdf.entries()]
+        .filter(([anchor]) => anchored.has(anchor))
+        .map(([, v]) => v)
+        .sort((a, b) => b - a);
     const rootCut = naturalBreak(idfDesc);
     // A FURTHER point of attention (beyond the dominant one, which always
     // grounds) must clear the same absolute significance floor
@@ -879,7 +1173,7 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
             pooledVote: point.vote,
             idfVote: votesIdf.get(point.anchor) ?? 0,
             candidateBreadth: regions.length,
-            contributingVotes: regionSpans.get(point.anchor)?.length ?? 0,
+            contributingVotes: regionAxioms.get(point.anchor) ?? 0,
             contributingEvidence: regionSupport.get(point.anchor) ?? 0,
             breadth: point.breadth,
             contributingSpans: regionSpans.get(point.anchor) ?? [],
@@ -1515,6 +1809,18 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo, td) {
     // 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.
+    //
+    // MEASURED 2026-07-29, NOT YET RESOLVED.  This gate never engages at real
+    // scale: on the trained store N = 325,608 with k = 24 and W = 4, so the
+    // threshold is 96³ = 884,736 and a third of a million contexts still runs
+    // unbudgeted at hubBound·W = 2,280 pops PER PAIR — 160,210 junction pops,
+    // 5.9s, 31% of think.  Sharing one hubBound·W allowance across all pairs
+    // instead cuts that to 22,418 pops and 2.6s (think −19%), but is measurably
+    // too tight below ~10³ contexts: test/36 (N = 8, budget 8) loses the
+    // `red circle` binding root and test/14 (N = 120, budget 40) recalls 39/40.
+    // The sharing is the right shape; hubBound·W is the wrong size for it, and
+    // fitting a size to those two points would repeat the mistake the cube
+    // already makes — pricing the gate on the synthetic corpora.
     const marketScale = k * ctx.space.maxGroup;
     const corpusScale = N > marketScale ** 3;
     const exactBudget = corpusScale ? { n: k * ctx.space.maxGroup } : undefined;
@@ -1927,6 +2233,30 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo, td) {
                     }
                 }
             }
+            // COMPOSING TWO SPLIT FORMS DOES NOT WEAVE A POINT OF ATTENTION.
+            // Region.corroborating marks a form the query's own cut SPLIT and
+            // collectRegions recovered by lookup; poolVotes and commitVotes keep
+            // such evidence out of the breadth ratio and out of the root cut's
+            // distribution.  This path bypassed both: a junction vote is minted
+            // fresh here and carried nothing, so evidence the query never wove
+            // re-entered the root election as a first-class anchor.
+            //
+            // Measured over the suite: 130 accepted junctions, 44 standing on at
+            // least one corroborating region and 12 standing on NOTHING ELSE (both
+            // endpoints corroborating, all structural-resonance tier).  Those 12
+            // are precisely the leak — the query wove neither endpoint.
+            //
+            // The flag is inherited only when EVERY part is corroborating.  One
+            // genuine fold region among the parts means the query did point here,
+            // and the junction anchors on it; that also preserves the case
+            // Region.corroborating's doc calls out as REFUTED to bar (the correct
+            // log record reachable only through a split form still grounds, because
+            // it grounds as evidence for an anchor, not as a topic of its own).
+            // Safe against the explaining-away accounting because that is EXACT
+            // tier only (spec §15) and an all-corroborating junction has no exact
+            // ordinary vote to absorb.
+            const jointCorroborating = [cand[a], cand[b], ...bestExtras]
+                .every((ri) => regions[ri].corroborating === true);
             out.push({
                 start: spanStart,
                 end: spanEnd,
@@ -1935,6 +2265,7 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo, td) {
                 w,
                 wFocus: w,
                 absorbed: 1 + explainedAway,
+                ...(jointCorroborating ? { corroborating: true } : {}),
                 // The places this junction actually stands on — its two endpoints and
                 // any N-ary extras, NOT the merged span [spanStart, spanEnd], which
                 // swallows the gap and reads as one neighbourhood.  See

package/dist/src/mind/bridge.js

@@ -553,30 +553,54 @@ async function bridgeImpl(ctx, query, proposed) {
     // hundreds of roots), so this is where its proposals are first sized.
     //
     // 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. */
+    // check — not eagerly for every collected id. Most climb-proposed
+    // candidates fail the seed check and never reach the expensive identity
+    // and frame-consensus gates.
+    //
+    // Frame unanimity is different: once any candidate reaches that gate, it
+    // must be evaluated against the COMPLETE collected candidate population,
+    // not only the prefix whose bytes happened to be loaded earlier. The full
+    // phrase-scale population is therefore materialised once, lazily, on the
+    // first unanimous() call and reused afterward.
+    //
+    // Null results are memoised too, so an empty or over-cap candidate is never
+    // read repeatedly by the candidate loop and the population materialiser.
+    const candidateByteMemo = new Map();
+    /** Read one candidate at most once. Returns null when it exceeds the
+     * phrase-scale cap or has no content. */
     const bytesOfCandidate = (sid) => {
-        const hit = seededBytes.get(sid);
-        if (hit !== undefined)
-            return hit;
+        const cached = candidateByteMemo.get(sid);
+        if (cached !== undefined)
+            return cached;
         const b = candidateBytes(sid);
-        if (b !== null)
-            seededBytes.set(sid, b);
+        candidateByteMemo.set(sid, b);
         return b;
     };
-    if (diagnostics)
-        diagnostics.phraseScale = seededBytes.size;
+    let framePopulation = null;
+    /** Return the complete phrase-scale candidate population.
+     *
+     * This is intentionally lazy: queries that never reach frame unanimity
+     * keep the cheap per-candidate seed path. Once required, every candidate
+     * is bounded by candidateBytes(), loaded at most once, and all subsequent
+     * unanimity checks observe the same order-independent population.
+     */
+    const ensureFramePopulation = () => {
+        if (framePopulation !== null) {
+            return framePopulation;
+        }
+        const complete = new Map();
+        for (const sid of candidates) {
+            const bytes = bytesOfCandidate(sid);
+            if (bytes !== null) {
+                complete.set(sid, bytes);
+            }
+        }
+        framePopulation = complete;
+        if (diagnostics) {
+            diagnostics.phraseScale = complete.size;
+        }
+        return complete;
+    };
     // 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
@@ -595,7 +619,8 @@ 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 seededBytes.values()) {
+        const population = ensureFramePopulation();
+        for (const bytes of population.values()) {
             let from = 0;
             for (;;) {
                 const i = indexOf(bytes, lf, from);

package/dist/src/mind/junction.js

@@ -230,8 +230,24 @@ unordered = false) {
         // abstains here in a handful of pops and falls through to the resonance
         // tier.  Below the page bound the read IS the full container list, so
         // the walk stays exact exactly where identity evidence discriminates.
-        const containers = cachedContainers(ctx, cache, x, bound);
-        if (containers.length < bound) {
+        // READ ONE PAST THE PAGE TO TELL "FULL" FROM "SATURATED".  The guard
+        // below means "this node's containers fill a whole page, so its
+        // containment ancestry is a non-discriminative slice of the corpus".
+        // But the read itself is CAPPED at the page size, so `length` can never
+        // exceed it and `length < bound` really asks "did the capped read come
+        // back full?" — which is the same answer for a genuine hub and for a
+        // node that has exactly `bound` containers and not one more.  Reading
+        // bound + 1 separates them: only a node with MORE than a page is a hub.
+        //
+        // Measured on test/34 (8 deposits, so the page is √N = 3): "blue" has
+        // exactly 3 containers and was suppressed, while "red" has 2 and was
+        // expanded — so "red then circle" composed and "blue then square" fell
+        // through to the synonym tier, which substituted "red" and answered
+        // "red square", a context NEITHER attribute attends to alone.  The two
+        // cross-cuts are structurally identical; only the container count
+        // differed, and only by one.
+        const containers = cachedContainers(ctx, cache, x, bound + 1);
+        if (containers.length <= bound) {
             for (const c of containers) {
                 if (!seen.has(c)) {
                     seen.add(c);

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

@@ -114,6 +114,17 @@ export declare function analogyStrength(ctx: MindContext, a: number, b: number):
  *  is maxGroup, the same quantum differsByOneWindow and canonicalChunkId
  *  measure by; no tuned constants. */
 export declare function sharedFrameStrength(ctx: MindContext, a: number, b: number): number;
+/** The same measure over BYTES, for callers holding a role-establishing
+ *  CONTEXT rather than the node whose role it establishes — CAST's comparison
+ *  reads the tier this way when two candidate analogs are fillers (bare entity
+ *  names) rather than frame-bearing structures themselves.  A role is a
+ *  property of the context that establishes a filler, never of the filler's
+ *  own bytes: measured on test/29's corpus, "Michelangelo" against "Homer"
+ *  reads 0.000 while their establishing contexts ("The David was sculpted
+ *  by…" against "The Iliad was written by…") read 0.452, and a context in a
+ *  genuinely different frame ("Water boils at…") still reads 0.000 — the tier
+ *  discriminates, it was simply being asked about the wrong bytes. */
+export declare function sharedFrameStrengthOf(ctx: MindContext, A: Uint8Array, B: Uint8Array): number;
 /** FORWARD through a synonym: the continuation an edge-less node borrows from
  *  a concept (halo) sibling — resonate the node's halo, take the first
  *  sibling above the concept threshold that itself has a direct edge. */

package/dist/src/mind/match.js

@@ -403,9 +403,20 @@ export async function analogyStrength(ctx, a, b) {
  *  is maxGroup, the same quantum differsByOneWindow and canonicalChunkId
  *  measure by; no tuned constants. */
 export function sharedFrameStrength(ctx, a, b) {
+    return sharedFrameStrengthOf(ctx, read(ctx, a), read(ctx, b));
+}
+/** The same measure over BYTES, for callers holding a role-establishing
+ *  CONTEXT rather than the node whose role it establishes — CAST's comparison
+ *  reads the tier this way when two candidate analogs are fillers (bare entity
+ *  names) rather than frame-bearing structures themselves.  A role is a
+ *  property of the context that establishes a filler, never of the filler's
+ *  own bytes: measured on test/29's corpus, "Michelangelo" against "Homer"
+ *  reads 0.000 while their establishing contexts ("The David was sculpted
+ *  by…" against "The Iliad was written by…") read 0.452, and a context in a
+ *  genuinely different frame ("Water boils at…") still reads 0.000 — the tier
+ *  discriminates, it was simply being asked about the wrong bytes. */
+export function sharedFrameStrengthOf(ctx, A, B) {
     const W = ctx.space.maxGroup;
-    const A = read(ctx, a);
-    const B = read(ctx, b);
     if (A.length < W || B.length < W)
         return 0;
     // Mark every byte of the shorter side covered by a learnt W-window that