@hviana/sema 0.2.2 → 0.2.4

package/src/mind/recognition.ts

@@ -16,7 +16,7 @@ import {
   resolve,
 } from "./primitives.js";
 import { atomIsHub, corpusN, leadsSomewhere } from "./traverse.js";
-import { chainReach, leafIdAt } from "./canonical.js";
+import { chainReach, leafIdAt, leafIdRun } from "./canonical.js";
 import { isChunk, type Sema } from "../sema.js";
 import type { Leaf, Site } from "./graph-search.js";
 
@@ -34,12 +34,44 @@ import type { Leaf, Site } from "./graph-search.js";
  *  Both O(n · maxGroup) bounded O(1) probes — never a scan of the corpus. */
 export function recognise(ctx: MindContext, bytes: Uint8Array): Recognition {
   // Content-keyed memo — works for both single-turn respond() and multi-turn
-  // respondTurn() (where the map persists across calls).  Skipped while
-  // tracing so every call still emits its rationale step.
-  if (ctx.recogniseMemo && !ctx.trace) {
+  // respondTurn() (where the map persists across calls).  ALWAYS consulted,
+  // regardless of tracing — matching perceive()'s own memo, which carries no
+  // trace gate at all.  This memo is NOT an optional accelerator: recogniseImpl
+  // walks the query's perceived tree via foldTree, whose subtree-resolution
+  // fast path (see primitives.ts) skips invoking `visit` — and therefore
+  // skips EMITTING SITES — for any subtree already cached in
+  // ctx._resolvedSubtrees.  A multi-turn conversation's stable-prefix fold
+  // deliberately shares node OBJECTS across turns, so by the second call on
+  // the exact same bytes, large swaths of the tree are already cached and
+  // foldTree stops short of recursing into them — a second recogniseImpl
+  // call on the SAME bytes is not idempotent; it silently finds FEWER sites
+  // than the first (observed live: 31 sites → 5 on an immediate repeat
+  // call).  Skipping this memo "only while tracing" used to mean every
+  // traced turn re-ran recogniseImpl from scratch at every one of the many
+  // call sites that recognise the same query (cover, reason, articulate...),
+  // each subsequent call silently more incomplete than the last — measurably
+  // changing which mechanism grounds the answer, not just costing time.  The
+  // trace step must still fire on every call regardless (a cache hit is not
+  // silent), so it is emitted here directly instead of only inside
+  // recogniseImpl.
+  if (ctx.recogniseMemo) {
     const key = latin1Key(bytes);
     const hit = ctx.recogniseMemo.get(key);
-    if (hit !== undefined) return hit;
+    if (hit !== undefined) {
+      ctx.trace?.step(
+        "recognise",
+        [rItem(bytes, "query")],
+        hit.sites.map((s) =>
+          rItem(bytes.subarray(s.start, s.end), "form", s.payload, [
+            s.start,
+            s.end,
+          ])
+        ),
+        `decompose the query into ${hit.sites.length} learnt form(s) that ` +
+          `lead somewhere (over ${hit.leaves.length} perceived leaves) [cached]`,
+      );
+      return hit;
+    }
     const fresh = recogniseImpl(ctx, bytes);
     ctx.recogniseMemo.set(key, fresh);
     return fresh;
@@ -52,7 +84,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
@@ -82,15 +115,24 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
   // silence.  Atoms stay available as leaves (PASS-carried literals) and
   // through exact tier-0 resolution regardless.
   const atomsAreHubs = atomIsHub(ctx, corpusN(ctx));
+  // Distinct probes (structural exact match, canon fallback, edge trims at
+  // several offsets) can legitimately re-derive the SAME (start, end, id)
+  // site from different tree nodes — a wide edge-trim search is exactly
+  // this on purpose (see below).  Duplicate site entries are not wrong
+  // evidence, but they double the weight cover's derivation search gives
+  // that span, distorting its cost model — the same span must count once.
+  const seen = new Set<string>();
   const emit = (start: number, end: number, id: number) => {
     if (id < 0 && atomsAreHubs) return;
+    const key = start + "," + end + "," + id;
+    if (seen.has(key)) return;
+    seen.add(key);
     if (leadsSomewhere(ctx, id)) {
       sites.push({ start, end, payload: id });
     }
   };
 
   // ── 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) {
@@ -101,10 +143,93 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
     // missed may still be a stored form under the response's equivalence
     // (case, width, whitespace — whatever the injected canonicalizer says).
     // O(subtree bytes) per miss, memoised per response; a no-op when no
-    // canonicalizer was injected or the store has no canon index.
-    else if (end - start >= 2) {
+    // canonicalizer was injected or the store has no canon index.  A raw
+    // leaf (n.kids === null) is single-byte and handled by the byte-atom
+    // path above instead — canon equivalence only applies to composites.
+    else if (n.kids !== null) {
       const cid = canonResolve(ctx, bytes.subarray(start, end));
       if (cid !== null) emit(start, end, cid);
+      // The edge-trim fallbacks below remove 1 byte from a side; the
+      // remainder must still be a composite (>= 2 bytes, the same floor
+      // n.kids !== null enforces above) rather than degenerate into
+      // single-byte-atom territory, which atomIsHub already governs
+      // separately.
+      else if (end - start - 1 >= 2) {
+        // The chunk's own boundary is drawn by content geometry, not by
+        // any notion of "form" — it can include one edge byte the query's
+        // fold happened to attach here that the trained span never had
+        // (e.g. a separator from the preceding chunk).  The core has no
+        // idea what that byte means; it only knows resolve()/canonResolve
+        // are self-verifying (hash-then-verify, same discipline as every
+        // content lookup here), so a blind one-byte-shorter guess on
+        // either edge costs nothing when wrong and is trustworthy when it
+        // hits.  Two extra probes, only on the already-failed miss path.
+        const left = resolve(ctx, bytes.subarray(start + 1, end));
+        if (left !== null) emit(start + 1, end, left);
+        const right = resolve(ctx, bytes.subarray(start, end - 1));
+        if (right !== null) emit(start, end - 1, right);
+        // A misalignment wider than one byte (e.g. more than one edge
+        // separator swallowed) is not itself geometry-quantized — the
+        // WRITE side's canonical index (canonicalWindows) interns sliding
+        // W−1/W-length windows over leaf ids at EVERY offset, not just
+        // radix-aligned ones (see canonical.ts) — so the offset that
+        // recovers a trained span can be anything, not a multiple of W.
+        // What IS bounded is how far it's worth looking: chainReach(W)=W²,
+        // the same reach the canonical pass (tryChain) trusts for a chain
+        // rebuilt off the query's own fold.  Every candidate offset is
+        // gated by store.findBranch(leafIds) first — the SAME cheap,
+        // fold-free existence check tryChain already uses — so the extra
+        // resolve() fold (the real cost) is only paid when a branch could
+        // plausibly exist there, not for every offset.  The node itself is
+        // also bounded to chunk-scale (end - start <= W²): widening this at
+        // whole-query/root scale can rediscover a smaller subtree's own
+        // content as a second, overlapping site the structural walk's own
+        // finer recursion already emits correctly on its own — a duplicate
+        // that downstream derivation can stitch into a wrong answer.
+        const W = ctx.space.maxGroup;
+        for (
+          let k = 1;
+          end - start <= W * W && k <= W * W && start + k < end - 1;
+          k++
+        ) {
+          const lIds = leafIdRun(ctx, bytes, start + k, end);
+          if (lIds !== null && store.findBranch(lIds) !== null) {
+            const eLeft = resolve(ctx, bytes.subarray(start + k, end));
+            if (eLeft !== null) emit(start + k, end, eLeft);
+          }
+          const rIds = leafIdRun(ctx, bytes, start, end - k);
+          if (rIds !== null && store.findBranch(rIds) !== null) {
+            const eRight = resolve(ctx, bytes.subarray(start, end - k));
+            if (eRight !== null) emit(start, end - k, eRight);
+          }
+        }
+        // A REAL extra word at the left edge (a discourse connective like
+        // "And " prepended to a follow-up turn — not boundary noise, actual
+        // content the injected canonicalizer has no equivalence for) shows
+        // up as a canon-miss too big for the chunk-scale search above: the
+        // turn is its OWN segment (stable-prefix folded independently — see
+        // mind.ts's _growContext), so it can be turn/segment-scale, not
+        // chunk-scale.  Widening the size bound itself reopens the root-
+        // scale false-positive this module already fixed once (test/46);
+        // widening the SEARCH instead — trying every position up to W
+        // chunk-widths from the left edge that the query's OWN fold treats
+        // as a chunk boundary (`starts`, the same set the canonical pass
+        // privileges with full chain reach) — does not: `starts.has(p)` is
+        // fold EVIDENCE the query produced on its own (a leaf-parent chunk
+        // like "And " is visited, and its start added to `starts`, before
+        // this composite ever runs — foldTree is post-order), never a blind
+        // guess.  Bounded to W candidates, each an O(1) set lookup before
+        // paying for the real canonResolve fold — canonResolve, not
+        // resolve()/findBranch, because the gap here is often exactly the
+        // kind of equivalence (case, in the live trace) canon exists for,
+        // not just an exact-content coincidence.
+        for (let k = 1; k <= W; k++) {
+          const p = start + k * W;
+          if (p >= end - 1 || !starts.has(p)) continue;
+          const cid = canonResolve(ctx, bytes.subarray(p, end));
+          if (cid !== null) emit(p, end, cid);
+        }
+      }
     }
     if (isChunk(n)) {
       starts.add(start);
@@ -115,7 +240,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 +291,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 +321,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 +331,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 +359,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

@@ -527,6 +527,23 @@ export function chooseNext(
     }
   }
 
+  // NO consensusFloor gate here (tried and reverted — see
+  // test/40-choosenext-scale-guard.test.mjs): that floor is calibrated for
+  // POOLED, IDF-weighted CLIMB VOTES (recallByResonance, commitVotes), where
+  // each corroborating region contributes at most ln N and the floor grows
+  // with N exactly as that per-region ceiling does (HOW_IT_WORKS.md §8.6).
+  // `bestSupport` here is a different kind of quantity — a raw prevCount of
+  // how many training contexts predicted ONE destination, bounded by how
+  // often that specific fact was retold, never by corpus size N.  Gating an
+  // N-invariant count against an N-growing threshold guarantees failure
+  // once N is large enough, discarding genuinely, structurally dominant
+  // edges (observed: a fact corroborated 2-to-1-1-1 refused at N≈325K,
+  // falling back to a noisy concept-hop).  The loop above already IS the
+  // "genuinely competing" test: a tie leaves first-inserted as the pick
+  // (test/30's own pinned behaviour); a strict winner is real evidence
+  // regardless of corpus scale.  Matches HOW_IT_WORKS.md §25's own
+  // chooseNext pseudocode, which has no such floor.
+
   // 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

@@ -39,7 +39,7 @@ export interface DepositCacheEntry {
    *  its own suffix bytes-equal this exactly. */
   nextBytes?: Uint8Array;
 }
-import { concatBytes } from "../bytes.js";
+import { bytesEqual, concatBytes, indexOf } from "../bytes.js";
 import { dominates } from "../geometry.js";
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -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,33 @@ 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;
+  /** DISPERSION: the number of distinct clusters this point's contributing
+   *  regions form, merging any two whose gap is under one river-fold
+   *  quantum W.  Neither breadth NOR raw region count discriminates a
+   *  genuine further topic from a coincidental echo (both were tried and
+   *  falsified — breadth starves a genuine, evenly-split multi-topic query,
+   *  since no root in a real N-way split can exceed half the vote; raw
+   *  count doesn't separate them either, since a short, structurally simple
+   *  echo racks up as many corroborating regions as a real topic does).
+   *  Dispersion asks a different question: not how MUCH evidence, but how
+   *  many separate PLACES in the query corroborate it.  A coincidental
+   *  match — one local phrase resonating with an unrelated stored form —
+   *  is structurally confined to ONE cluster no matter how strong its vote;
+   *  a genuine further topic is named in its own distinctive wording
+   *  somewhere the query's scaffolding does not reach, always a SEPARATE
+   *  cluster from whatever else corroborates it.  See
+   *  test/37-cluster-dispersion-fusion.test.mjs. */
+  clusters: number;
 }
 
 /** Both read-outs of one consensus climb. */
@@ -130,6 +165,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. */
@@ -247,23 +290,84 @@ export function spliceAll(segs: Seg[]): Uint8Array | null {
   return concatBytes(segs.map((s) => s.bytes));
 }
 
+/** Whether a chosen span RESTATES the query rather than answering it: its
+ *  SUBSTITUTED bytes (an edge followed from a recognised site, not the
+ *  site's own literal text read back) already occur elsewhere in the query
+ *  — the same principle recall.ts's tiers apply to a whole-query projection
+ *  ("a projection that is a proper byte-subspan of the query restates part
+ *  of the question").  A LITERAL span (the site's own bytes, unchanged) is
+ *  exempt: naming what's already there at its OWN position is not a
+ *  substitution.  A recognised site that is itself an entire PRIOR TURN of
+ *  a multi-turn query is exactly this shape: it carries a genuine learnt
+ *  continuation, but that continuation is something the asker already said
+ *  moments later in the SAME query, not a new answer.  Below one river
+ *  window, byte overlap is chance, not evidence — the same floor
+ *  identityBar and reachThreshold hold every other structural-overlap claim
+ *  to. */
+export function segRestatesQuery(
+  s: Seg,
+  query: Uint8Array,
+  queryLen: number,
+  W: number,
+): boolean {
+  if (!s.rec) return false;
+  const literal = s.j - s.i === s.bytes.length &&
+    bytesEqual(s.bytes, query.subarray(s.i, s.j));
+  if (literal) return false;
+  return s.bytes.length >= W && s.bytes.length < queryLen &&
+    indexOf(query, s.bytes, 0) >= 0;
+}
+
 /** Lift the answer out of the cover for think: the recognised region, free of
- *  the asker's surrounding (unrecognised) framing. */
-export function liftAnswer(segs: Seg[], queryLen: number): Uint8Array | null {
+ *  the asker's surrounding (unrecognised) framing — and free of any chosen
+ *  span that only RESTATES content the query already contains (see {@link
+ *  segRestatesQuery}).  A restating span is excluded from both the framing
+ *  (lo/hi) decision and the final concatenation: it is stale, not a second
+ *  answer, but the OTHER spans a derivation chose are independent evidence
+ *  and must not be discarded along with it. */
+export function liftAnswer(
+  segs: Seg[],
+  queryLen: number,
+  query: Uint8Array,
+  W: number,
+): Uint8Array | null {
+  const restated = segs.map((s) => segRestatesQuery(s, query, queryLen, W));
   const recognised: number[] = [];
-  for (let k = 0; k < segs.length; k++) if (segs[k].rec) recognised.push(k);
+  for (let k = 0; k < segs.length; k++) {
+    if (segs[k].rec && !restated[k]) recognised.push(k);
+  }
   if (recognised.length === 0) return 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));
+      return concatBytes(
+        segs.filter((_, k) => !restated[k]).map((x) => x.bytes),
+      );
     }
     return s.bytes;
   }
   const lo = recognised[0];
   const hi = recognised[recognised.length - 1];
-  return concatBytes(segs.slice(lo, hi + 1).map((x) => x.bytes));
+  return concatBytes(
+    segs.slice(lo, hi + 1).filter((_, k) => !restated[lo + k]).map((x) =>
+      x.bytes
+    ),
+  );
 }
 
 /** The CHANGED NODES of a freshly-perceived `tree` against the node ids a previous

package/src/store.ts

@@ -306,8 +306,17 @@ export interface Store {
   nodeCount(): number;
 
   // ── soft resonance over node gists ─────────────────────────────────────
-  /** The k nodes whose gist resonates most with v. */
-  resonate(v: Vec, k: number): Promise<Hit[]>;
+  /** The k nodes whose gist resonates most with v.  `exhaustive` widens the
+   *  IVF probe to every cluster (see {@link AbstractStore.efFor}'s doc) —
+   *  for refusal-path-only callers where an approximate top-√C-clusters
+   *  search is not the same discriminator as the caller's own byte-exact
+   *  verification (the substitution bridge's proposal channel): a rarer
+   *  paraphrase can score lower than hundreds of unrelated hits by pure
+   *  fold-geometry structural distance (a middle-of-string mismatch
+   *  perturbs the tree hash far more than a tail mismatch of the same
+   *  byte length) and so never even reach a probed cluster, no matter how
+   *  large k is — k only reorders WITHIN the clusters already probed. */
+  resonate(v: Vec, k: number, exhaustive?: boolean): Promise<Hit[]>;
   /** Mark a node as a RESONANCE TARGET — promote its gist into the content
    *  index so {@link resonate} can find it.  A node's gist is captured at intern
    *  but indexed LAZILY (only targets are indexed; the ~99.5% intermediate DAG
@@ -1636,7 +1645,7 @@ export abstract class AbstractStore implements Store {
 
   // ── Soft resonance ─────────────────────────────────────────────────────
 
-  async resonate(v: Vec, k: number): Promise<Hit[]> {
+  async resonate(v: Vec, k: number, exhaustive = false): Promise<Hit[]> {
     await this._ensureReady();
     // Synchronous flush of any buffered index writes: the FIRST resonance
     // after a large ingest pays that flush here, so it shows up in respond
@@ -1649,17 +1658,22 @@ export abstract class AbstractStore implements Store {
     // same values still hits.  Lazy-init: null after any index write; the
     // first miss after a flush recreates it.  When voteRegions resonates
     // identical perceived sub-regions, only the first call descends the ANN.
-    const rk = vecKey(v) + ":" + k;
+    const rk = vecKey(v) + ":" + k + (exhaustive ? ":x" : "");
     const cache = this._resonateCache;
     if (cache) {
       const hit = cache.get(rk);
       if (hit !== undefined) return hit;
     }
 
+    const clusters = this._vecContentClusterCount();
     const results = this._vecContentQuery(
       normalize(copy(v)),
       k * this.overfetch,
-      this.efFor(this._vecContentClusterCount()),
+      // Exhaustive: probe every cluster (ef ≥ 4·clusters guarantees the
+      // IVF's own ef→nprobe=ceil(ef/4) mapping reaches all of them) — the
+      // natural ceiling for a search that is ALREADY refusal-path-only and
+      // must not miss a candidate hiding in an unprobed cluster.
+      exhaustive ? 4 * clusters : this.efFor(clusters),
     );
     const out: Hit[] = [];
     for (const r of results) {

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();
+});