@hviana/sema 0.2.2 → 0.2.3

package/src/mind/mechanisms/cover.ts

@@ -159,11 +159,18 @@ export const coverMechanism: PipelineMechanism = {
 
     const connectors = await resolveConnectors(ctx, sites);
     let splits = rec.splits;
+    let starts = rec.starts;
     if (computed.length > 0) {
       splits = new Set(rec.splits);
+      starts = new Set(rec.starts);
       for (const u of computed) {
         splits.add(u.i);
         splits.add(u.j);
+        // A computation's own boundaries carry the same fold-level evidence
+        // a chunk boundary does — "computation always wins" (see the header
+        // comment) extends to being trusted ground for cross-leaf recovery.
+        starts.add(u.i);
+        starts.add(u.j);
       }
     }
     const concepts = await resolveConcepts(ctx, sites);
@@ -199,6 +206,7 @@ export const coverMechanism: PipelineMechanism = {
       concepts,
       rec.leaves,
       splits,
+      starts,
       undefined,
       connectors,
       computedResults,

package/src/mind/mechanisms/extraction.ts

@@ -70,43 +70,118 @@ export async function extractBySkill(
   if (ranked.length === 0) {
     return fail("no consensus anchor — no skill to apply");
   }
-  let exemplar: SkillInfo | null = null;
-  let chosenAnchor: number | null = null;
-  let skipped = 0;
-  for (const cand of ranked) {
-    const ex = await pre.spanShapedOf(cand.anchor);
-    if (ex) {
-      exemplar = ex;
-      chosenAnchor = cand.anchor;
-      break;
+
+  // Try ranked anchors IN ORDER until one yields a USABLE extraction — not
+  // merely a span-shaped exemplar, but one whose extracted span clears the
+  // same one-river-fold quantum (W) cover.ts's restatedSpan gate already
+  // treats as the floor below which byte overlap is chance, not evidence.
+  // isSpanShaped (spanShapedOf) is a deliberately permissive sparse-
+  // subsequence check — see the section note below — so it accepts exemplars
+  // whose relation to the query is coincidental gap-matching, not genuine
+  // structure.  Stopping at the FIRST such exemplar let a coincidental match
+  // early in the ranked list win outright and read out a sub-quantum
+  // fragment (observed: a 3-byte "Hel" pulled from an unrelated exemplar,
+  // while a later ranked anchor would have read the query's own "Hello…"
+  // correctly).  Trying further anchors when one produces nothing usable is
+  // the same idiom this loop already uses for non-exemplars — extended to
+  // cover a bad extraction, not just a structural non-match.
+  //
+  // The retry is bounded at pre.k — the SAME evidence-breadth constant every
+  // other consumer of a ranked list already self-limits to (resonance, the
+  // weave, the climb itself; see Precomputed.k's own doc comment) — not the
+  // full ranked list.  locate()'s frame match has an EXACT-byte tier with no
+  // significance correction of its own (short W-byte frames are cheap to
+  // match by pure chance), so trying every ranked anchor turns that per-
+  // anchor chance into a near-certainty over enough attempts: on a pure-
+  // gibberish query, 170 anchors deep found an unrelated Zulu exemplar whose
+  // short frame happened to byte-match, producing "xyzzy pl" — a coincidence
+  // no different in kind from the "RaBitQ estimate overshot the reach bar
+  // and grounded pure gibberish" failure recall.ts's own significance
+  // correction exists to prevent (see recallByResonance's reach-threshold
+  // comment).  Bounding the search to the ranked list's own top-k restores
+  // the "genuinely relevant but not root-significant" exemplars this loop
+  // was built for, without the unbounded tail's chance collisions.
+  const W = ctx.space.maxGroup;
+  const searched = ranked.slice(0, pre.k);
+  let shapeMisses = 0;
+  let subQuantum = 0;
+  for (const cand of searched) {
+    const exemplar = await pre.spanShapedOf(cand.anchor);
+    if (!exemplar) {
+      shapeMisses++;
+      continue;
+    }
+    const built = buildFromExemplar(ctx, query, pre, exemplar);
+    if (built === null || built.bytes.length < W) {
+      subQuantum++;
+      continue;
+    }
+    if (shapeMisses > 0 || subQuantum > 0) {
+      ctx.trace?.step(
+        "trySkillAnchors",
+        [
+          rItem(
+            query.subarray(0, 0),
+            `skipped ${shapeMisses + subQuantum}`,
+          ),
+          rNode(ctx, cand.anchor, "chosen"),
+        ],
+        [],
+        `skipped ${shapeMisses} non-exemplar and ${subQuantum} sub-quantum ` +
+          `anchor(s) before one yielded a usable extraction`,
+      );
     }
-    skipped++;
+    t?.done(
+      [rItem(built.bytes, "extracted")],
+      built.pieces === 1
+        ? `apply a learnt extraction skill — read the analogous span of the query` +
+          ` framed like "${
+            decodeText(exemplar.answerBytes)
+          }" sits in its exemplar`
+        : `apply a learnt MULTI-PIECE skill — read ${built.pieces} analogous` +
+          ` pieces of the query and synthesize them like "${
+            decodeText(exemplar.answerBytes)
+          }"`,
+    );
+    return {
+      bytes: built.bytes,
+      accounted: built.accounted,
+      unexplained: unexplainedLabel(query, built.accounted),
+    };
   }
-  if (exemplar === null) {
+  if (shapeMisses === searched.length) {
     ctx.trace?.step(
       "trySkillAnchors",
       [],
       [],
-      `none of ${ranked.length} ranked anchor(s) is a span-shaped skill exemplar`,
+      `none of the top ${searched.length} ranked anchor(s) (of ${ranked.length} total) ` +
+        `is a span-shaped skill exemplar`,
     );
     return fail("no consensus root is a span-shaped skill exemplar");
   }
-  if (skipped > 0) {
-    ctx.trace?.step(
-      "trySkillAnchors",
-      [
-        rItem(query.subarray(0, 0), `skipped ${skipped}`),
-        rNode(ctx, chosenAnchor!, "chosen"),
-      ],
-      [],
-      `skipped ${skipped} anchor(s) that are not skill exemplars`,
-    );
-  }
+  return fail(
+    "no ranked anchor yielded an extraction at or above the quantum floor",
+  );
+}
+
+/** Build the extracted bytes for ONE already-accepted span-shaped exemplar —
+ *  factored out of {@link extractBySkill} so its anchor loop can try
+ *  successive ranked candidates instead of committing to the first
+ *  structural match.  Null when the exemplar's answer does not decompose
+ *  against its context, or no piece's frame locates in the query. */
+function buildFromExemplar(
+  ctx: MindContext,
+  query: Uint8Array,
+  pre: Precomputed,
+  exemplar: SkillInfo,
+):
+  | { bytes: Uint8Array; accounted: Array<[number, number]>; pieces: number }
+  | null {
   const { contextBytes, answerBytes } = exemplar;
 
   const ansCtxRuns = answerRunsInContext(ctx, contextBytes, answerBytes);
   if (ansCtxRuns === null || ansCtxRuns.length === 0) {
-    return fail("answer is not a subsequence of the context");
+    return null;
   }
 
   if (ansCtxRuns.length > 1) {
@@ -200,25 +275,11 @@ export async function extractBySkill(
     if (preBounded && postBounded) accounted.push([start, end]);
   }
   if (pieces.length === 0) {
-    return fail("no answer piece's frame located in the query");
+    return null;
   }
 
   const out = pieces.length === 1 ? pieces[0] : concatBytes(pieces);
-  t?.done(
-    [rItem(out, "extracted")],
-    pieces.length === 1
-      ? `apply a learnt extraction skill — read the analogous span of the query` +
-        ` framed like "${decodeText(answerBytes)}" sits in its exemplar`
-      : `apply a learnt MULTI-PIECE skill — read ${pieces.length} analogous` +
-        ` pieces of the query and synthesize them like "${
-          decodeText(answerBytes)
-        }"`,
-  );
-  return {
-    bytes: out,
-    accounted,
-    unexplained: unexplainedLabel(query, accounted),
-  };
+  return { bytes: out, accounted, pieces: pieces.length };
 }
 
 // ── The two span-shape readings: OPEN acceptance vs. STRONG decomposition ──

package/src/mind/mind.ts

@@ -266,9 +266,15 @@ export class Mind implements MindContext {
     sites: ReadonlyArray<Site>;
     leaves: ReadonlyArray<Leaf>;
     splits: ReadonlySet<number>;
+    starts: ReadonlySet<number>;
   } {
     const r = recognise(this, bytes);
-    return { sites: r.sites, leaves: r.leaves, splits: r.splits };
+    return {
+      sites: r.sites,
+      leaves: r.leaves,
+      splits: r.splits,
+      starts: r.starts,
+    };
   }
 
   /** Disambiguate among multiple learnt continuations of the same context node.

package/src/mind/pipeline.ts

@@ -288,8 +288,43 @@ export async function think(
     ? new Set<number>()
     : new Set(recognise(ctx, answer).sites.map((s) => s.payload));
   const reasoned = await reason(ctx, query, answer, preConsumed, pre);
-  const fused = provenance === "recall" || provenance === "recall-echo"
-    ? await fuseAttention(ctx, query, reasoned, pre)
+
+  // Fuse only when the query has a genuine REMAINDER no mechanism's
+  // structural evidence touched at all.  `decided.accounted` alone
+  // undercounts this: it is a COST-LADDER quantity (cover.ts prices its
+  // masked/computed spans at near-zero and deliberately leaves them out of
+  // `accounted` so PASS-bridged bytes are still charged), not a coverage
+  // one — a query fully explained by one computed span plus bridged
+  // connectors can report `accounted: []` while nothing is actually left
+  // unexplained.  The genuine remainder is what NEITHER the winning
+  // candidate's accounted spans NOR any recognised extension's computed
+  // span (`pre.computed` — every mechanism's parse() output, ALU included)
+  // ever touched.  A remainder under one river-fold quantum (W, the same
+  // floor cover.ts's restatedSpan and the honesty-density bar above both
+  // use) is bridging punctuation/whitespace, never a second topic —
+  // observed: a single space between two fully-computed arithmetic spans
+  // ("2+2 3+3") registered as "unaccounted" and pulled in an unrelated
+  // corpus fact, corrupting "4 6" into "4 63".
+  const explained: Array<[number, number]> = [
+    ...decided.accounted,
+    ...pre.computed.map((u): [number, number] => [u.i, u.j]),
+  ];
+  const remainder = unaccounted(explained);
+  // Whether the winning candidate's entire recognised substance is
+  // COMPUTED — every accounted span exactly a pre.computed span, nothing
+  // from a genuinely recognised/climbed site.  fuseAttention's lone-root
+  // shortcut assumes a single point of attention already IS primary's own
+  // source; that assumption is exactly backwards for a pure computation
+  // (an ALU result has no anchor of its own) — see fuseAttention's
+  // `unclimbed` parameter, gated there by Attention.breadth so a
+  // coincidental echo (which this flag alone cannot distinguish) is still
+  // rejected.
+  const unclimbed = decided.accounted.length > 0 &&
+    decided.accounted.every(([i, j]) =>
+      pre.computed.some((u) => u.i === i && u.j === j)
+    );
+  const fused = remainder >= ctx.space.maxGroup
+    ? await fuseAttention(ctx, query, reasoned, pre, unclimbed)
     : reasoned;
 
   done(

package/src/mind/reasoning.ts

@@ -141,6 +141,14 @@ export async function fuseAttention(
   query: Uint8Array,
   primary: Uint8Array,
   pre: Precomputed,
+  /** True when `primary` never touched the consensus climb at all — e.g. a
+   *  pure ALU computation, which has no anchor of its own.  commitVotes
+   *  ALWAYS admits the dominant root regardless of its vote (attention.ts:
+   *  "roots.length === 0 || …") on the assumption a lone root already IS
+   *  primary's own source; that assumption is exactly backwards when
+   *  primary is unclimbed.  Absent or false preserves the original
+   *  behaviour exactly. */
+  unclimbed = false,
 ): Promise<Uint8Array> {
   // When the answer is structurally drawn from the query itself
   // (extraction), it already spans all the query's pieces — fusion
@@ -155,17 +163,32 @@ export async function fuseAttention(
   // query, same k, same DF mode) — read them from Precomputed instead of
   // re-climbing, so even a traced response pays for the climb once.
   const forest = (await pre.attention()).roots;
-  if (forest.length <= 1) return primary;
+  // A LONE root is ordinarily primary's own source — nothing to fuse.  But
+  // when primary is unclimbed, the lone root was never checked against
+  // anything: it is admitted by commitVotes unconditionally, so it may be
+  // genuine consensus (Attention.breadth dominates — most of the query's
+  // OWN regions corroborate it) or a coincidental echo (breadth does not
+  // dominate — see test/35-attention-confidence).  breadth is the SCALE-
+  // INVARIANT read of exactly this question: the raw IDF vote cannot serve
+  // here, since it is an absolute ln(N)-scaled quantity (a genuine root on
+  // a large store can score BELOW its own floor while a coincidental echo
+  // on a small one scores comfortably above its own, smaller, floor).
+  const lonePromotes = unclimbed && forest.length === 1 &&
+    forest[0].breadth > 0.5;
+  if (forest.length === 0 || (forest.length <= 1 && !lonePromotes)) {
+    return primary;
+  }
 
   const pieces: Array<{ start: number; bytes: Uint8Array }> = [
     { start: forest[0].start, bytes: primary },
   ];
   const qv = pre.guide; // once, not per root
+  const rest = lonePromotes ? forest : forest.slice(1);
   const t = ctx.trace?.enter("fuseAttention", [
     rItem(primary, "primary"),
-    ...forest.slice(1).map((r) => rNode(ctx, r.anchor, "point", r.vote)),
+    ...rest.map((r) => rNode(ctx, r.anchor, "point", r.vote)),
   ]);
-  for (const root of forest.slice(1)) {
+  for (const root of rest) {
     const g = await project(ctx, root.anchor, qv);
     if (g === null || g.length === 0) continue;
     if (pieces.some((p) => indexOf(p.bytes, g, 0) >= 0)) continue;

package/src/mind/recognition.ts

@@ -52,7 +52,8 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
   const sites: Site[] = [];
   const leaves: Leaf[] = [];
   const splits = new Set<number>();
-  if (bytes.length === 0) return { sites, leaves, splits };
+  const starts = new Set<number>();
+  if (bytes.length === 0) return { sites, leaves, splits, starts };
 
   // Span-resolve memo for THIS call: the structural pass (sub-runs inside
   // leaf-parents) and the canonical pass (leaf-id chains) probe overlapping
@@ -90,7 +91,6 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
   };
 
   // ── structural: the query's own perceived tree ──────────────────────
-  const starts = new Set<number>();
   starts.add(0);
   foldTree(ctx, perceive(ctx, bytes), 0, (n, start, end, node) => {
     if (n.kids === null) {
@@ -115,7 +115,15 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
         leafOffsets.push(off);
         off += k.leaf?.length ?? 0;
       }
+      // Sub-spans starting at i > 0 begin INSIDE the chunk, at an offset the
+      // query's own fold did not itself choose as a boundary — the same
+      // opportunistic byte-atom-chain risk `tryChain`'s `boundary` gate
+      // guards below (see its comment).  Only the chunk's own left edge
+      // (i === 0, already registered in `starts` above) carries the fold's
+      // evidence; interior sub-starts are exempt from the guard only while
+      // atoms themselves still discriminate at this corpus scale.
       for (let i = 0; i < n.kids.length; i++) {
+        if (i > 0 && atomsAreHubs) break;
         const subIds: number[] = [];
         for (let j = i; j < n.kids.length; j++) {
           const kj = n.kids[j];
@@ -158,9 +166,23 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
     }
   }
 
+  // A chain rebuilt from a NON-boundary offset (the query's own perceived
+  // cut, `starts`, never chose to segment here) is opportunistic: the same
+  // byte-atom coincidence the hub guard above already exists for, just
+  // spelled over 2+ leaves instead of 1.  At small corpus scale that's fine
+  // — coincidence is rare and every chain is real evidence (see `atomIsHub`).
+  // Past the scale where atoms themselves stop discriminating, the same
+  // uniform-expectation argument bounds a CHAIN'S commonality too: it is at
+  // least as rare as its rarest atom, so a store where atoms are hubs makes
+  // interior chain reconstructions no more trustworthy than the atoms they
+  // are built from ("hi" resolving out of "W[hi]ch" is exactly this: two
+  // hub-scale atoms, chained at an offset nothing in the query's own fold
+  // selected).  Chains that start ON a boundary carry the fold's own
+  // evidence instead and are exempt.
   const tryChain = (
     p: number,
     maxIds: number,
+    boundary: boolean,
   ): void => {
     const first = leafFrom(p);
     if (!first) return;
@@ -174,6 +196,7 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
       ids.push(nx.id);
       pos = nx.end;
       if (store.findBranch(ids) === null) continue;
+      if (!boundary && atomsAreHubs) continue;
       const id = resolveSpan(p, pos);
       if (id === null || id === prevId) continue;
       prevId = id;
@@ -183,10 +206,10 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
 
   for (let p = 0; p < bytes.length; p++) {
     if (starts.has(p)) {
-      tryChain(p, chainReach(W)); // boundary start — full reach
+      tryChain(p, chainReach(W), true); // boundary start — full reach
     } else {
       const limit = chunkEnd[p] + W;
-      tryChain(p, Math.min(limit - p, chainReach(W)));
+      tryChain(p, Math.min(limit - p, chainReach(W)), false);
     }
   }
 
@@ -211,7 +234,7 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
       ` (over ${leaves.length} perceived leaves)`,
   );
 
-  return { sites, leaves, splits };
+  return { sites, leaves, splits, starts };
 }
 
 /** Segment bytes using the geometry's own groupings — leaf-parent

package/src/mind/traverse.ts

@@ -7,6 +7,7 @@
 // project) live in match.ts — the elementary match-and-project operation.
 
 import { cosine, Vec } from "../vec.js";
+import { consensusFloor } from "../geometry.js";
 import type { AncestorReach, MindContext } from "./types.js";
 import { gistOf, read } from "./primitives.js";
 
@@ -527,6 +528,23 @@ export function chooseNext(
     }
   }
 
+  // A pick among GENUINELY competing continuations still needs to clear the
+  // same genuine-corroboration floor {@link consensusFloor} draws for every
+  // other consumer that turns distinct-context support into a vote (the
+  // climb's recallByResonance/commitVotes) — below it, "most corroborated"
+  // is only the least-thin echo among several, not real evidence.  Gated to
+  // corpus scale large enough that this echo is even possible (the same
+  // scale {@link atomIsHub} already switches on for the identical reason:
+  // at small N every edge IS the evidence there is).  A hub id has no
+  // meaningful "distinct context" reading at all (id < 0 atoms are excluded
+  // from this path already, since chooseNext only ever sees real edges).
+  const N = corpusN(ctx);
+  if (
+    capped.length > 1 && atomIsHub(ctx, N) && bestSupport < consensusFloor(N)
+  ) {
+    return undefined;
+  }
+
   // Trace is built lazily — the filter + map below only execute when a
   // trace listener is attached, so the common (no-trace) path pays only
   // for the prevCount calls in the loop above, never for extra rItemShort

package/src/mind/types.ts

@@ -64,6 +64,7 @@ export interface GraphSearchHost {
     sites: ReadonlyArray<Site>;
     leaves: ReadonlyArray<Leaf>;
     splits: ReadonlySet<number>;
+    starts: ReadonlySet<number>;
   };
   chooseNext?(node: number): number | undefined;
 }
@@ -79,6 +80,13 @@ export interface Recognition {
   leaves: Leaf[];
   /** Sub-leaf positions where a form boundary falls between leaf edges. */
   splits: Set<number>;
+  /** Leaf-parent (chunk) start positions from the query's OWN perceived
+   *  fold — the positions the fold itself chose as a grouping boundary, as
+   *  opposed to an offset a byte-level scan merely happens to land on.  The
+   *  one boundary signal opportunistic cross-leaf recovery (recognition's
+   *  own canonical chains, the search's `fuse`) can lean on instead of
+   *  ASCII/word heuristics: see the `boundary` gate in recognition.ts. */
+  starts: Set<number>;
 }
 
 /** How the consensus climb weights a region's Document-Frequency reach. */
@@ -93,6 +101,16 @@ export interface Attention {
   /** The union of the query byte-spans whose evidence supports this point. */
   start: number;
   end: number;
+  /** SCALE-INVARIANT confidence: the fraction of the query's OWN regions
+   *  whose evidence this point accounts for (Σ RegionVote.absorbed among
+   *  its contributors, over the query's total region count) — read PER-
+   *  ANCHOR, unlike the raw IDF vote (an absolute, ln(N)-scaled quantity
+   *  that means "strong" on a small store and "weak" on a large one for
+   *  the SAME degree of genuine consensus).  A point whose breadth clears
+   *  `dominates` (> half the query's regions corroborate it) is real
+   *  consensus; one that does not is a coincidental single-region echo —
+   *  see test/35-attention-confidence.test.mjs. */
+  breadth: number;
 }
 
 /** Both read-outs of one consensus climb. */
@@ -130,6 +148,14 @@ export interface RegionVote {
   roots: readonly number[];
   w: number;
   wFocus: number;
+  /** How many of the query's ORIGINAL regions this one vote's evidence
+   *  accounts for.  1 for an ordinary per-region vote (itself); for a
+   *  cross-region junction vote, 1 (itself) plus however many individual
+   *  votes it explained away (see crossRegionVotes) — the junction speaks
+   *  for all of them at once, and breadth accounting must not undercount it
+   *  to "one region" just because it collapsed to one pooled axiom.
+   *  Defaults to 1 when absent. */
+  absorbed?: number;
 }
 
 /** The edge-bearing contexts reached by climbing from a node, plus saturation info. */
@@ -256,6 +282,20 @@ export function liftAnswer(segs: Seg[], queryLen: number): Uint8Array | null {
 
   if (recognised.length === 1) {
     const s = segs[recognised[0]];
+    // A COMPUTED span's query-side width is operand digit-count, not
+    // evidence of how much of the query's meaning it accounts for — the
+    // half-dominance check below (built for a genuinely RECOGNISED learned
+    // form) is not a valid framing signal for it (see the `computed` field
+    // doc on Seg/GItem): "1000 - 421" outweighs "what is …?" by width only
+    // because the operands are big, not because the framing matters less.
+    // A LITERAL PREFIX before a computed span is unambiguous framing
+    // regardless of width — an arithmetic expression is never itself
+    // preceded by more literal computed content, so anything literal before
+    // it is question wording ("what is ", "compute ") to lift clear of.
+    // With no prefix (s.i === 0) the span is judged by the ordinary
+    // half-dominance rule below, which already correctly keeps a short
+    // trailing glue byte ("2+2." → "4.", the span dominates a 4-byte query).
+    if (s.computed && s.i > 0) return s.bytes;
     if (dominates(s.j - s.i, queryLen)) {
       return concatBytes(segs.map((x) => x.bytes));
     }

package/test/35-attention-confidence.test.mjs

@@ -0,0 +1,139 @@
+// 35-attention-confidence.test.mjs — SCALE-INVARIANT CONFIDENCE for a point
+// of attention (Attention.breadth).
+//
+// commitVotes always admits the DOMINANT root regardless of its IDF-weighted
+// vote (attention.ts: "roots.length === 0 || ..." — the first root is never
+// floor-gated).  That is correct for the common case ("give me your best
+// guess"), but it means a query's SOLE root can be either:
+//
+//   (a) genuine consensus — most of the query's own regions independently
+//       corroborate it (a real fact, or a real cross-region binding), or
+//   (b) a coincidental echo — ONE region's resonance happened to land
+//       somewhere, with the rest of the query silent on it.
+//
+// The raw IDF vote cannot tell these apart: it is an ABSOLUTE quantity that
+// scales with ln(corpus size), so the same vote means "strong" on a small
+// store and "weak" on a large one (see the session's earlier finding: a
+// genuine root on a 325K-context store scored BELOW its own consensus floor,
+// while a spurious echo on a 15-fact store scored comfortably above its own —
+// much smaller — floor).  A SCALE-INVARIANT measure is needed instead: what
+// FRACTION of the query's own regions this root's evidence accounts for —
+// the "N of M sub-regions voted" the rationale already reports, but read
+// PER-ANCHOR instead of globally, and tested against the same half-dominance
+// convention (`dominates`, part*2 > whole) the rest of the codebase already
+// uses for every other "is this real signal or noise" decision.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+
+const enc = (s) => new TextEncoder().encode(s);
+const mk = (seed) =>
+  new Mind({ seed, store: new SQliteStore({ path: ":memory:" }) });
+
+// ═══════════════════════════════════════════════════════════════════════════
+// GENUINE CONSENSUS — a real cross-region binding (test/34's own corpus).
+// Most of the query's regions agree on the joint context; breadth must
+// DOMINATE (> half of the query's own regions corroborate it).
+// ═══════════════════════════════════════════════════════════════════════════
+
+const BINDING_CORPUS = [
+  ["red", "is a color"],
+  ["blue", "is a color"],
+  ["circle", "is a shape"],
+  ["square", "is a shape"],
+  ["red circle", "answer alpha"],
+  ["red square", "answer beta"],
+  ["blue circle", "answer gamma"],
+  ["blue square", "answer delta"],
+];
+
+test("breadth: a genuine cross-region binding dominates the query's regions", async () => {
+  const m = mk(1);
+  await m.ingest(BINDING_CORPUS);
+  const roots = await m.climbAttention(enc("red then circle"), 24);
+  assert.equal(roots.length, 1, "expected exactly one committed root");
+  assert.ok(
+    typeof roots[0].breadth === "number",
+    "Attention must carry a breadth field",
+  );
+  assert.ok(
+    roots[0].breadth > 0.5,
+    `genuine binding must dominate (> half the query's own regions), got breadth=${
+      roots[0].breadth
+    }`,
+  );
+  await m.store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SPURIOUS ECHO — a short arithmetic query whose consensus climb lands on an
+// UNRELATED fact by coincidental byte-pattern resonance (observed directly
+// this session: "2+2 equals what?" climbs to "1+1", not "2+2").  Only a
+// minority of the query's regions support it; breadth must NOT dominate.
+// ═══════════════════════════════════════════════════════════════════════════
+
+const ARITH_CORPUS = [
+  ["1+2", "3"],
+  ["2+2", "4"],
+  ["2+3", "5"],
+  ["3+3", "6"],
+  ["3+5", "8"],
+  ["4+3", "7"],
+  ["2+5", "7"],
+  ["1+5", "6"],
+  ["6+1", "7"],
+  ["4+1", "5"],
+  ["3+4", "7"],
+  ["5+2", "7"],
+  ["1+1", "2"],
+  ["5+3", "8"],
+  ["7+1", "8"],
+];
+
+test("breadth: a coincidental single-region echo does not dominate", async () => {
+  const m = mk(1);
+  await m.ingest(ARITH_CORPUS);
+  const roots = await m.climbAttention(enc("2+2 equals what?"), 24);
+  assert.equal(roots.length, 1, "expected exactly one committed root");
+  assert.ok(
+    typeof roots[0].breadth === "number",
+    "Attention must carry a breadth field",
+  );
+  assert.ok(
+    roots[0].breadth <= 0.5,
+    `a coincidental echo must NOT dominate the query's own regions, got breadth=${
+      roots[0].breadth
+    }`,
+  );
+  await m.store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SCALE INVARIANCE — the whole point: the SAME breadth bar must separate
+// signal from noise whether the corpus has 15 facts or many more, unlike the
+// raw IDF vote (which is an absolute, ln(N)-scaled quantity — see the header
+// comment).  Doubling the corpus (more unrelated arithmetic facts) must not
+// flip either verdict merely by changing N.
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("breadth: the same bar holds as the corpus grows (scale invariance)", async () => {
+  const bigArith = [...ARITH_CORPUS];
+  for (let a = 1; a <= 9; a++) {
+    for (let b = 1; b <= 9; b++) {
+      bigArith.push([`${a}x${b}`, String(a * b)]);
+    }
+  }
+  const m = mk(1);
+  await m.ingest(bigArith);
+  const roots = await m.climbAttention(enc("2+2 equals what?"), 24);
+  assert.equal(roots.length, 1, "expected exactly one committed root");
+  assert.ok(
+    roots[0].breadth <= 0.5,
+    `a coincidental echo must still not dominate on a larger corpus, got breadth=${
+      roots[0].breadth
+    }`,
+  );
+  await m.store.close();
+});