@hviana/sema 0.2.1 → 0.2.3

package/src/mind/mind.ts

@@ -14,8 +14,6 @@ import { bindSeat, fold, Sema, Space } from "../sema.js";
 import { Alphabet } from "../alphabet.js";
 import {
   bytesToTree,
-  bytesToTreePyramid,
-  type FoldPyramid,
   Grid,
   gridToTree,
   hilbertBytes,
@@ -109,7 +107,7 @@ export interface Conversation {
  *  foldTree returns their ids immediately — O(suffix) instead of
  *  O(context) for every tree walk. */
 interface ConversationData {
-  pyramid: FoldPyramid;
+  tree: Sema;
   bytes: Uint8Array;
   boundaries: number[];
   perceiveMemo: Map<string, Sema>;
@@ -244,9 +242,10 @@ export class Mind implements MindContext {
   // bounded: a pyramid costs ~KB per content byte (one D-float gist per
   // interior node), and only the few live conversation chains need to stay
   // warm, so 8 entries is the honest budget.
-  _depositTrees = new BoundedMap<string, import("../geometry.js").FoldPyramid>(
-    8,
-  );
+  _depositTrees = new BoundedMap<
+    string,
+    import("./types.js").DepositCacheEntry
+  >(8);
   _depositLens = new Set<number>();
   _internIds = new WeakMap<import("../sema.js").Sema, number>();
 
@@ -267,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.
@@ -513,18 +518,20 @@ export class Mind implements MindContext {
    *  where one turn ends and the next begins. */
   beginConversation(state?: ConversationState): Conversation {
     const id = this._nextConvId++;
-    // Build the initial pyramid: from scratch for a new conversation,
-    // or from the saved context bytes when restoring.
     const initBytes = state?.context ?? new Uint8Array(0);
-    const { pyramid } = bytesToTreePyramid(
+    const initBoundaries = state?.boundaries ? [...state.boundaries] : [];
+    const tree = bytesToTree(
       this.space,
       this.alphabet,
       initBytes,
+      undefined,
+      undefined,
+      initBoundaries.length > 0 ? initBoundaries : undefined,
     );
     this._conversations.set(id, {
-      pyramid,
+      tree,
       bytes: initBytes,
-      boundaries: state?.boundaries ? [...state.boundaries] : [],
+      boundaries: initBoundaries,
       perceiveMemo: new Map(),
       recogniseMemo: new Map(),
       climbMemo: new Map(),
@@ -572,25 +579,23 @@ export class Mind implements MindContext {
    *  place a context grows ({@link addTurn} and {@link respondTurn} both
    *  come through here), so the append semantics cannot drift. */
   private _growContext(data: ConversationData, turnBytes: Uint8Array): Sema {
-    const prevLen = data.pyramid.bytes;
+    const prevLen = data.bytes.length;
     // An empty turn neither grows the context nor marks a boundary —
     // boundaries are documented strictly increasing, and a zero-length
-    // "turn" is no turn.  The pyramid's zero-growth shortcut makes the
-    // refold below O(1), so the existing tree is returned unchanged.
+    // "turn" is no turn.  Nothing changed, so the existing tree stands.
     const grow = turnBytes.length > 0;
-    const grown = !grow
-      ? data.bytes
-      : prevLen > 0
-      ? concat2(data.bytes, turnBytes)
-      : turnBytes;
-    if (grow && prevLen > 0) data.boundaries.push(prevLen);
-    const { tree, pyramid } = bytesToTreePyramid(
+    if (!grow) return data.tree;
+    const grown = prevLen > 0 ? concat2(data.bytes, turnBytes) : turnBytes;
+    if (prevLen > 0) data.boundaries.push(prevLen);
+    const tree = bytesToTree(
       this.space,
       this.alphabet,
       grown,
-      data.pyramid,
+      undefined,
+      undefined,
+      data.boundaries.length > 0 ? data.boundaries : undefined,
     );
-    data.pyramid = pyramid;
+    data.tree = tree;
     data.bytes = grown;
     data.perceiveMemo.set(latin1Key(grown), tree);
     return tree;
@@ -644,43 +649,15 @@ export class Mind implements MindContext {
     this.canonMemo = this.canon ? new Map() : null;
 
     try {
-      // Seed the recognise memo with the STANDALONE recognition of the
-      // NEW turn, offset into the accumulated context.  In the full-context
-      // tree, content-defined chunk boundaries shift when bytes are
-      // concatenated — foldTree no longer visits the original turn's root
-      // node, so the structural pass misses it.  Perceiving the turn alone
-      // preserves intact structure.  We seed ONLY the suffix (the new turn);
-      // prefix forms stay visible through the full-context recognition
-      // (they serve as context, not as questions to re-answer).
-      if (data.boundaries.length > 0) {
-        const suffixStart = data.boundaries[data.boundaries.length - 1];
-        if (suffixStart < newContext.length) {
-          const suffixBytes = newContext.subarray(suffixStart);
-          const suffixRec = recognise(this, suffixBytes);
-          const fullRec = recognise(this, newContext);
-          const seen = new Set(fullRec.sites.map((s) => `${s.start},${s.end}`));
-          const mergedSites = [...fullRec.sites];
-          for (const site of suffixRec.sites) {
-            const absStart = suffixStart + site.start;
-            const absEnd = suffixStart + site.end;
-            const key = `${absStart},${absEnd}`;
-            if (!seen.has(key)) {
-              seen.add(key);
-              mergedSites.push({
-                start: absStart,
-                end: absEnd,
-                payload: site.payload,
-              });
-            }
-          }
-          data.recogniseMemo.set(latin1Key(newContext), {
-            sites: mergedSites,
-            leaves: fullRec.leaves,
-            splits: fullRec.splits,
-          });
-        }
-      }
-
+      // No recognise-memo pre-seeding here: that used to be necessary
+      // because the flat/positional fold lost visibility into an earlier
+      // turn's own structure once later bytes shifted its position
+      // (foldTree no longer visited the turn's root node).  The
+      // STABLE-PREFIX fold (see {@link ConversationData}) makes every
+      // turn's subtree independent of what follows it by construction, so
+      // recognise() finds it correctly on its own, first-touch, exactly
+      // once per turn — no workaround needed, and none pre-empting
+      // recognise()'s own memo with a partial result.
       const top = this.trace?.enter("respondTurn", [
         rItem(newContext, "query"),
       ]);

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/primitives.ts

@@ -8,16 +8,16 @@ import { Sema } from "../sema.js";
 import {
   bytesToTree,
   bytesToTreePyramid,
-  type FoldPyramid,
   Grid,
   gridToTree,
   hilbertBytes,
+  stablePrefixFoldIncremental,
   stackGrids,
 } from "../geometry.js";
 import { canonHash } from "../canon.js";
 import { bytesEqual } from "../bytes.js";
 import { ALL } from "./types.js";
-import type { Input, MindContext } from "./types.js";
+import type { DepositCacheEntry, Input, MindContext } from "./types.js";
 
 // ── Address: bytes → node ──────────────────────────────────────────────
 
@@ -93,34 +93,76 @@ export function perceive(
   return gridToTree(ctx.space, ctx.alphabet, input as Grid);
 }
 
-/** The DEPOSIT-shaped perceive: the PLAIN fold (bit-identical to inference
- *  perception — that structural train/inference agreement is load-bearing
- *  for exact recall), computed INCREMENTALLY via the fold's level pyramid
- *  ({@link bytesToTreePyramid}).  An accumulated context (a conversation)
- *  grows by suffixes: the previous context's pyramid is cached by CONTENT
- *  (ctx._depositTrees), and this deposit refolds only the right edge of
- *  each level — O(turn) instead of O(context) per turn.  Purely a cache:
- *  the produced tree never depends on cache state. */
-export function perceiveDeposit(ctx: MindContext, bytes: Uint8Array): Sema {
-  let prev: FoldPyramid | undefined;
-  // Longest cached PROPER prefix first.
-  const lens = [...ctx._depositLens]
-    .filter((L) => L >= 2 && L < bytes.length)
-    .sort((a, b) => b - a);
-  for (const L of lens) {
-    const hit = ctx._depositTrees.get(latin1Key(bytes.subarray(0, L)));
-    if (hit !== undefined) {
-      prev = hit;
-      break;
+/** The DEPOSIT-shaped perceive.  A FIRST-SEEN input takes the PLAIN fold
+ *  (bit-identical to inference perception of a standalone query — that
+ *  structural train/inference agreement is load-bearing for exact recall),
+ *  computed incrementally via the fold's level pyramid
+ *  ({@link bytesToTreePyramid}).  An input that EXTENDS a previously
+ *  deposited one is a conversation context grown by one turn — the cached
+ *  prefix length IS the turn boundary (derived from the deposit sequence
+ *  itself, never from content conventions) — and takes the STABLE-PREFIX
+ *  fold over the accumulated boundaries, bit-identical to the boundary
+ *  fold query-time conversation perception uses, so the trained context
+ *  node and the query's context subtree are the SAME node.  Segment folds
+ *  reuse across deposits ({@link stablePrefixFoldIncremental}) — O(turn)
+ *  instead of O(context) per turn.  The fold state is purely a cache; the
+ *  boundary accumulation is what an evicted chain loses (falling back to
+ *  the plain fold, the pre-boundary shape — a warm replay restores it). */
+export function perceiveDeposit(
+  ctx: MindContext,
+  bytes: Uint8Array,
+  conversational = false,
+): Sema {
+  let prev: DepositCacheEntry | undefined;
+  let prefixLen = 0;
+  // Cache consult (both boundary lookup and stable-prefix reuse) is scoped
+  // to conversational deposits only — a bare, unrelated fact whose bytes
+  // happen to extend an earlier deposit is NOT a conversation turn, and
+  // must keep the plain fold so it shares structure with ITS OWN prior
+  // deposits, not fragment against a coincidental byte-prefix.
+  if (conversational) {
+    // Longest cached PROPER prefix first.
+    const lens = [...ctx._depositLens]
+      .filter((L) => L >= 2 && L < bytes.length)
+      .sort((a, b) => b - a);
+    for (const L of lens) {
+      const hit = ctx._depositTrees.get(latin1Key(bytes.subarray(0, L)));
+      // The suffix must bytes-equal the hit's OWN recorded continuation —
+      // proof this deposit is that turn's actual next turn, not a fact
+      // that coincidentally shares its byte prefix.
+      if (
+        hit !== undefined && hit.nextBytes !== undefined &&
+        bytesEqual(hit.nextBytes, bytes.subarray(L))
+      ) {
+        prev = hit;
+        prefixLen = L;
+        break;
+      }
     }
   }
-  const { tree, pyramid } = bytesToTreePyramid(
-    ctx.space,
-    ctx.alphabet,
-    bytes,
-    prev,
-  );
-  if (bytes.length >= 2) {
+  let tree: Sema;
+  let entry: DepositCacheEntry;
+  if (prev !== undefined) {
+    const boundaries = [...prev.boundaries, prefixLen];
+    const folded = stablePrefixFoldIncremental(
+      ctx.space,
+      ctx.alphabet,
+      bytes,
+      boundaries,
+      prev.stable,
+    );
+    tree = folded.tree;
+    entry = { boundaries, stable: folded.fold };
+  } else {
+    const plain = bytesToTreePyramid(ctx.space, ctx.alphabet, bytes);
+    tree = plain.tree;
+    entry = { boundaries: [], pyramid: plain.pyramid };
+  }
+  // Only a conversational deposit writes the cache too — otherwise a bare
+  // fact's plain fold could later be misread as a conversation's turn-zero
+  // boundary by an unrelated conversational deposit that happens to extend
+  // its bytes.
+  if (conversational && bytes.length >= 2) {
     // The lengths set drifts as the map evicts; past the probe budget the
     // drift itself becomes the cost (each stale length is an O(len) key
     // build), so both reset together — losing only warm-up on live chains.
@@ -128,7 +170,7 @@ export function perceiveDeposit(ctx: MindContext, bytes: Uint8Array): Sema {
       ctx._depositLens.clear();
       ctx._depositTrees.clear();
     }
-    ctx._depositTrees.set(latin1Key(bytes), pyramid);
+    ctx._depositTrees.set(latin1Key(bytes), entry);
     ctx._depositLens.add(bytes.length);
   }
   return tree;

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

@@ -19,7 +19,26 @@ import type {
   Site,
 } from "./graph-search.js";
 import type { Rationale } from "./rationale.js";
-import type { FoldPyramid, Grid } from "../geometry.js";
+import type { FoldPyramid, Grid, StableFold } from "../geometry.js";
+
+/** One {@link MindContext._depositTrees} entry — see that field's doc. */
+export interface DepositCacheEntry {
+  /** Turn boundaries accumulated over this content's deposit chain —
+   *  strictly increasing proper offsets, each a previously-deposited
+   *  whole-context length.  Empty for a first-seen (single-turn) input. */
+  boundaries: number[];
+  /** Plain-fold pyramid (first-seen inputs only). */
+  pyramid?: FoldPyramid;
+  /** Stable-prefix segment folds (grown-context inputs only). */
+  stable?: StableFold;
+  /** The continuation bytes this ctxInput was paired with in ingestPair, if
+   *  any — the ONLY thing that makes a later, longer ctxInput a genuine next
+   *  TURN of the same conversation rather than an unrelated fact that
+   *  happens to share this one's byte prefix (e.g. "2+2" vs. "2+2=5").  A
+   *  later deposit only takes this entry as its stable-prefix `prev` when
+   *  its own suffix bytes-equal this exactly. */
+  nextBytes?: Uint8Array;
+}
 import { concatBytes } from "../bytes.js";
 import { dominates } from "../geometry.js";
 
@@ -45,6 +64,7 @@ export interface GraphSearchHost {
     sites: ReadonlyArray<Site>;
     leaves: ReadonlyArray<Leaf>;
     splits: ReadonlySet<number>;
+    starts: ReadonlySet<number>;
   };
   chooseNext?(node: number): number | undefined;
 }
@@ -60,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. */
@@ -74,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. */
@@ -111,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. */
@@ -189,15 +234,19 @@ export interface MindContext extends GraphSearchHost {
    *  never invalidated.  Bounded LRU (byte-sized); a miss only re-perceives,
    *  never a correctness risk. */
   _gistCache: BoundedMap<number, Vec>;
-  /** DEPOSIT-path stable-prefix tree cache: content key (latin1) of a
-   *  deposited input → its plain-fold level PYRAMID, so the NEXT deposit
-   *  whose prefix it is (a conversation's accumulated context) reuses every
-   *  full aligned block and refolds only the right edge of each level —
-   *  O(turn) per deposit instead of O(context), with the tree BIT-IDENTICAL
-   *  to a from-scratch fold (see FoldPyramid).  Purely a performance cache.
-   *  Entry-count bounded (a pyramid is ~KB/byte of content; only the few
-   *  live conversation chains matter). */
-  _depositTrees: BoundedMap<string, FoldPyramid>;
+  /** DEPOSIT-path perception cache: content key (latin1) of a deposited
+   *  input → its accumulated turn BOUNDARIES plus reusable fold state.  A
+   *  deposit whose content extends a cached entry IS a conversation context
+   *  grown by one turn — the cached length is the new boundary — so it
+   *  folds with the SAME stable-prefix fold query-time perception uses
+   *  (structural train/inference agreement, load-bearing for recall),
+   *  reusing every already-folded segment via `stable` (see StableFold) —
+   *  O(turn) per deposit instead of O(context).  A first-seen input keeps
+   *  the plain fold and caches its `pyramid` (see FoldPyramid).  Purely a
+   *  performance cache for the FOLD STATE; the boundaries are semantic but
+   *  derived only from the deposit sequence itself (an evicted chain falls
+   *  back to plain-fold behavior, exactly the pre-boundary shape). */
+  _depositTrees: BoundedMap<string, DepositCacheEntry>;
   /** The byte lengths present in {@link _depositTrees} — the candidate
    *  prefix lengths probed (longest first).  Drifts on eviction (a stale
    *  length only costs a miss); cleared with the map when it outgrows the
@@ -233,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));
     }