@hviana/sema 0.4.3 → 0.4.6

package/src/mind/attention.ts

@@ -34,7 +34,14 @@ import {
   estimatorNoise,
   type StructuralPart,
 } 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 {
@@ -556,6 +563,18 @@ export async function computeAttention(
       // 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,
     });
   }
 
@@ -704,6 +723,98 @@ export function collectRegions(ctx: MindContext, query: Uint8Array): Region[] {
     // 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: Array<{ start: number; end: number }> = [];
+    // 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;
 }
 
@@ -732,7 +843,87 @@ export async function voteRegions(
     // `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 = (): number => {
+      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
@@ -776,9 +967,11 @@ export async function voteRegions(
     // 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));
@@ -1037,7 +1230,8 @@ export async function voteRegions(
         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,
@@ -1085,6 +1279,8 @@ export async function voteRegions(
       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 };
@@ -1140,6 +1336,14 @@ export function poolVotes(
   regionSupport: Map<number, number>;
   /** Per-anchor contributing region spans — see Attention.clusters. */
   regionSpans: Map<number, Array<[number, number]>>;
+  /** Per-anchor count of contributing region VOTES (pooled axioms), which is
+   *  not the length of `regionSpans`: a joint binding is one vote sitting in
+   *  several places. */
+  regionAxioms: Map<number, number>;
+  /** Per-anchor LARGEST single-region contribution — see Attention.peak. */
+  regionPeak: Map<number, number>;
+  /** Anchors with support from at least one NON-corroborating region. */
+  anchored: Set<number>;
   steps: DerivationStep[];
 } {
   const eligible: number[] = [];
@@ -1232,6 +1436,41 @@ export function poolVotes(
   >();
   const regionSupport = new Map<number, number>();
   const regionSpans = new Map<number, Array<[number, number]>>();
+  // 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<number, number>();
+  // 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<number>();
+  // 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<number, number>();
   const steps: DerivationStep[] = [];
   let order = 0;
   for (const pc of pool.values()) {
@@ -1246,7 +1485,16 @@ export function poolVotes(
         if (p0.kind !== "region" || seenRi.has(p0.ri)) 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
@@ -1256,7 +1504,31 @@ export function poolVotes(
         } else 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<string>();
+      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",
@@ -1283,7 +1555,17 @@ export function poolVotes(
       }
     }
   }
-  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 —
@@ -1322,6 +1604,9 @@ export function commitVotes(
     support: Map<number, { start: number; end: number; w: number }>;
     regionSupport: Map<number, number>;
     regionSpans: Map<number, Array<[number, number]>>;
+    regionAxioms: Map<number, number>;
+    regionPeak: Map<number, number>;
+    anchored: Set<number>;
     steps: DerivationStep[];
   },
   sat: SaturationInfo,
@@ -1331,8 +1616,17 @@ export function commitVotes(
   td?: TraceDraft,
   cfg?: ClimbConsensusCfg,
 ): AttentionRead {
-  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: [] };
@@ -1342,13 +1636,23 @@ export function commitVotes(
   // 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,
@@ -1359,10 +1663,20 @@ export function commitVotes(
       };
     })
     .sort((a, b) => b.vote - a.vote);
-
   const overlaps = (a: Attention, b: Attention) =>
     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
@@ -1393,7 +1707,7 @@ export function commitVotes(
       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) ?? [],
@@ -2281,6 +2595,18 @@ async function crossRegionVotes(
   // 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;
@@ -2750,6 +3076,30 @@ async function crossRegionVotes(
         }
       }
 
+      // 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,
@@ -2758,6 +3108,7 @@ async function crossRegionVotes(
         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/src/mind/bridge.ts

@@ -594,27 +594,62 @@ async function bridgeImpl(
   // 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<number, Uint8Array>();
-  /** 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<number, Uint8Array | null>();
+
+  /** Read one candidate at most once. Returns null when it exceeds the
+   * phrase-scale cap or has no content. */
   const bytesOfCandidate = (sid: number): Uint8Array | null => {
-    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: Map<number, Uint8Array> | null = 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 = (): ReadonlyMap<number, Uint8Array> => {
+    if (framePopulation !== null) {
+      return framePopulation;
+    }
+
+    const complete = new Map<number, Uint8Array>();
+
+    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
@@ -639,7 +674,9 @@ async function bridgeImpl(
     lf: Uint8Array,
     rf: Uint8Array,
   ): boolean => {
-    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/src/mind/junction.ts

@@ -307,8 +307,24 @@ export function junctionContainersFrom(
     // 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);