@hviana/sema 0.2.1 → 0.2.3

package/dist/src/mind/mechanisms/extraction.js

@@ -49,32 +49,86 @@ export async function extractBySkill(ctx, query, pre) {
     if (ranked.length === 0) {
         return fail("no consensus anchor — no skill to apply");
     }
-    let exemplar = null;
-    let chosenAnchor = 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) {
-        ctx.trace?.step("trySkillAnchors", [], [], `none of ${ranked.length} ranked anchor(s) is a span-shaped skill exemplar`);
+    if (shapeMisses === searched.length) {
+        ctx.trace?.step("trySkillAnchors", [], [], `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, query, pre, exemplar) {
     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) {
         ctx.trace?.step("decomposeAnswer", [rItem(answerBytes, "multi-piece-answer")], ansCtxRuns.map((r) => rItem(contextBytes.subarray(r.start, r.end), "piece", undefined, [
@@ -142,19 +196,10 @@ export async function extractBySkill(ctx, query, pre) {
             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/dist/src/mind/mechanisms/recall.js

@@ -74,10 +74,34 @@ export async function recallByResonance(ctx, query, pre) {
             maximal.push(s);
             maxEnd = s.end;
         }
-        if (maximal.length === 1) {
+        // The wrapper must actually BE scaffolding: RC8's own premise is "the
+        // wrapper is scaffolding; the argument is the span that leads
+        // somewhere" ("How do you say 'thank you' in French?" — everything
+        // outside the argument is a small fixed template).  When the query
+        // instead has ANOTHER substantial recognised form (≥ W2, the same
+        // constituent bar the argument itself must clear) sitting OUTSIDE the
+        // chosen argument, the query is not one argument in a wrapper — it is
+        // several complete, independently-meaningful pieces (a multi-turn
+        // conversation's own accumulated turns are exactly this shape), and
+        // binding to the argument's continuation would answer past content
+        // the query itself already carries forward.  Derived from the same W2
+        // bar the argument itself is held to, never a separate tuned number.
+        const hasSubstantialOutside = maximal.length === 1 &&
+            pre.rec.sites.some((s) => s.end - s.start >= W2 &&
+                (s.end <= maximal[0].start || s.start >= maximal[0].end));
+        if (maximal.length === 1 && !hasSubstantialOutside) {
             const arg = maximal[0];
             const g = await follow(ctx, arg.payload, queryGist);
-            if (g !== null && g.length > 0) {
+            // The same "no restated fragment" guard tier 2 applies below (§ "the
+            // anchor cleared the consensus floor..."): a followed continuation
+            // that is itself a proper byte-subspan of the QUERY restates part of
+            // the question — never an answer.  A multi-turn query's own later
+            // turns are exact, content-addressed matches for exactly this reason
+            // (each turn is its own previously-learnt form), so without this
+            // guard the argument's OWN later restatement in the same
+            // conversation reads as if it were the next thing to say.
+            if (g !== null && g.length > 0 &&
+                !(g.length < query.length && indexOf(query, g, 0) >= 0)) {
                 return ground(g, "argument binding — the query's sole edge-source constituent, continuation followed", [[arg.start, arg.end]], STEP);
             }
         }

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

@@ -1,7 +1,7 @@
 import { Vec } from "../vec.js";
 import { Sema, Space } from "../sema.js";
 import { Alphabet } from "../alphabet.js";
-import { type FoldPyramid, Grid } from "../geometry.js";
+import { Grid } from "../geometry.js";
 import { BoundedMap, type Store } from "../store.js";
 import { type MindConfig } from "../config.js";
 import { type Canon } from "../canon.js";
@@ -111,7 +111,7 @@ export declare class Mind implements MindContext {
      *  {@link MindContext._gistCache}.  32 MB ≈ 8K gists at D=1024; hub
      *  candidate sets (√N at most) fit comfortably and recur across queries. */
     _gistCache: BoundedMap<number, Vec>;
-    _depositTrees: BoundedMap<string, FoldPyramid>;
+    _depositTrees: BoundedMap<string, import("./types.js").DepositCacheEntry>;
     _depositLens: Set<number>;
     _internIds: WeakMap<Sema, number>;
     private _nextConvId;
@@ -122,6 +122,7 @@ export declare class Mind implements MindContext {
         sites: ReadonlyArray<Site>;
         leaves: ReadonlyArray<Leaf>;
         splits: ReadonlySet<number>;
+        starts: ReadonlySet<number>;
     };
     /** Disambiguate among multiple learnt continuations of the same context node.
      *  Required by {@link GraphSearchHost} — the graph search calls this through the

package/dist/src/mind/mind.js

@@ -10,7 +10,7 @@
 // Implementation split across src/mind/*.ts — this file assembles the Mind class.
 import { makeKeyring, rng, setVecConfig } from "../vec.js";
 import { Alphabet } from "../alphabet.js";
-import { bytesToTreePyramid, reachThreshold, } from "../geometry.js";
+import { bytesToTree, reachThreshold, } from "../geometry.js";
 import { BoundedMap } from "../store.js";
 import { SQliteStore } from "../store-sqlite.js";
 import { resolveConfig } from "../config.js";
@@ -95,7 +95,12 @@ export class Mind {
     // recogniseSpan wraps recognise
     recogniseSpan(bytes) {
         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.
      *  Required by {@link GraphSearchHost} — the graph search calls this through the
@@ -263,14 +268,13 @@ export class Mind {
      *  where one turn ends and the next begins. */
     beginConversation(state) {
         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(this.space, this.alphabet, initBytes);
+        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(),
@@ -316,21 +320,18 @@ export class Mind {
      *  place a context grows ({@link addTurn} and {@link respondTurn} both
      *  come through here), so the append semantics cannot drift. */
     _growContext(data, turnBytes) {
-        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)
+        if (!grow)
+            return data.tree;
+        const grown = prevLen > 0 ? concat2(data.bytes, turnBytes) : turnBytes;
+        if (prevLen > 0)
             data.boundaries.push(prevLen);
-        const { tree, pyramid } = bytesToTreePyramid(this.space, this.alphabet, grown, data.pyramid);
-        data.pyramid = pyramid;
+        const tree = bytesToTree(this.space, this.alphabet, grown, undefined, undefined, data.boundaries.length > 0 ? data.boundaries : undefined);
+        data.tree = tree;
         data.bytes = grown;
         data.perceiveMemo.set(latin1Key(grown), tree);
         return tree;
@@ -377,42 +378,15 @@ export class Mind {
         this.canon = this._canonFor(typeof turn === "string" ? textCanon : null);
         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/dist/src/mind/pipeline.js

@@ -177,8 +177,40 @@ export async function think(ctx, query, mechs) {
             ? new Set()
             : 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 = [
+        ...decided.accounted,
+        ...pre.computed.map((u) => [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(fused, "grounded, reasoned forward, fused across points of attention");
     return { bytes: fused, provenance };

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

@@ -15,15 +15,22 @@ export declare function latin1Key(bytes: Uint8Array): string;
  *  CALLER — who assembled the multi-turn context — knows where those
  *  boundaries are; the geometry never guesses them from the bytes. */
 export declare function perceive(ctx: MindContext, input: Input, leafAt?: (i: number) => number | null, lookup?: (ids: number[]) => number | null, boundaries?: readonly number[]): Sema;
-/** 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 declare function perceiveDeposit(ctx: MindContext, bytes: Uint8Array): Sema;
+/** 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 declare function perceiveDeposit(ctx: MindContext, bytes: Uint8Array, conversational?: boolean): Sema;
 /** The raw bytes of an input — modality-neutral conversion. */
 export declare function inputBytes(ctx: MindContext, input: Input): Uint8Array;
 /** Convenience: the gist vector of a byte span. */

package/dist/src/mind/primitives.js

@@ -2,7 +2,7 @@
 //
 //   Address  — bytes → node   (perceive, foldTree, resolve)
 //   Read     — node → bytes   (read)
-import { bytesToTree, bytesToTreePyramid, gridToTree, hilbertBytes, stackGrids, } from "../geometry.js";
+import { bytesToTree, bytesToTreePyramid, gridToTree, hilbertBytes, stablePrefixFoldIncremental, stackGrids, } from "../geometry.js";
 import { canonHash } from "../canon.js";
 import { bytesEqual } from "../bytes.js";
 import { ALL } from "./types.js";
@@ -58,29 +58,65 @@ export function perceive(ctx, input, leafAt, lookup, boundaries) {
     }
     return gridToTree(ctx.space, ctx.alphabet, input);
 }
-/** 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, bytes) {
+/** 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, bytes, conversational = false) {
     let prev;
-    // 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;
+    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;
+    let entry;
+    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.
@@ -88,7 +124,7 @@ export function perceiveDeposit(ctx, bytes) {
             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/dist/src/mind/reasoning.d.ts

@@ -12,4 +12,12 @@ export declare function reason(ctx: MindContext, query: Uint8Array, answer: Uint
  *  When the consensus climb finds more than one dominant point, each
  *  independent point grounds its own answer; they are bridged together
  *  by any learnt connector the graph holds between them. */
-export declare function fuseAttention(ctx: MindContext, query: Uint8Array, primary: Uint8Array, pre: Precomputed): Promise<Uint8Array>;
+export declare function fuseAttention(ctx: MindContext, 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?: boolean): Promise<Uint8Array>;

package/dist/src/mind/reasoning.js

@@ -111,7 +111,15 @@ export async function reason(ctx, query, answer, preConsumed, pre) {
  *  When the consensus climb finds more than one dominant point, each
  *  independent point grounds its own answer; they are bridged together
  *  by any learnt connector the graph holds between them. */
-export async function fuseAttention(ctx, query, primary, pre) {
+export async function fuseAttention(ctx, query, primary, pre, 
+/** 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) {
     // When the answer is structurally drawn from the query itself
     // (extraction), it already spans all the query's pieces — fusion
     // would only add noise from unrelated stored contexts.  The gate is
@@ -125,17 +133,31 @@ export async function fuseAttention(ctx, query, primary, pre) {
     // 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)
+    // 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 = [
         { 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;