@hviana/sema 0.2.1 → 0.2.2

package/dist/src/geometry.d.ts

@@ -90,6 +90,13 @@ export declare function consensusFloor(N: number): number;
  *  replaces runtime coverage gating with a batch pass that removes
  *  structurally-isolated entries.  Derived, never tuned. */
 export declare function coverageBar(_maxGroup: number, D: number): number;
+export interface Folded {
+    tree: Sema;
+    /** Byte length of the subtree — carried incrementally so the stable-prefix
+     *  boundary scan never re-walks subtrees (the old per-level walk was
+     *  O(n log n) over the whole input). */
+    len: number;
+}
 export interface Grid {
     width: number;
     height: number;
@@ -116,6 +123,27 @@ export declare function knownPrefixLength(bytes: Uint8Array, leafAt: (i: number)
  *  turn extend perception instead of refolding it: identical prefixes
  *  produce identical subtrees regardless of what follows them. */
 export declare function bytesToTree(space: Space, alphabet: Alphabet, bytes: Uint8Array, leafAt?: (i: number) => number | null, lookup?: (leafIds: number[]) => number | null, boundaries?: readonly number[]): Sema;
+/** A stable-prefix fold's reusable state: the segment edge offsets and each
+ *  segment's independently-folded root ({@link riverFoldRaw} output).  A
+ *  grown stream whose boundary set EXTENDS a previous fold's reuses every
+ *  matching segment's Folded unchanged (segments fold independently by
+ *  construction, so reuse is bit-identical to refolding) and folds only the
+ *  new right-edge segment — O(turn) per extension, the stable-prefix
+ *  counterpart of {@link FoldPyramid}.  Purely a cache: the produced tree
+ *  never depends on cache state. */
+export interface StableFold {
+    edges: number[];
+    segs: Folded[];
+}
+/** {@link stablePrefixFold} with incremental segment reuse — same cuts, same
+ *  segment folds, same left-nested join, same single root normalize; `prev`
+ *  only elides recomputing segments whose [start,end) offsets it already
+ *  folded over a byte-identical prefix (the caller keys the cache by
+ *  content).  Requires a non-empty effective boundary set. */
+export declare function stablePrefixFoldIncremental(space: Space, alphabet: Alphabet, bytes: Uint8Array, boundaries: readonly number[], prev?: StableFold): {
+    tree: Sema;
+    fold: StableFold;
+};
 /** The PLAIN fold's full level pyramid — every level's item list, bottom
  *  (leaves) to top (root).  Left-grouped folding is RADIX-ALIGNED: the item
  *  at level L, index i, covers exactly bytes [i·mg^L, (i+1)·mg^L) whenever

package/dist/src/geometry.js

@@ -321,6 +321,41 @@ function stablePrefixFold(space, alphabet, bytes, boundaries) {
     normalize(cur.tree.v);
     return cur.tree;
 }
+/** {@link stablePrefixFold} with incremental segment reuse — same cuts, same
+ *  segment folds, same left-nested join, same single root normalize; `prev`
+ *  only elides recomputing segments whose [start,end) offsets it already
+ *  folded over a byte-identical prefix (the caller keys the cache by
+ *  content).  Requires a non-empty effective boundary set. */
+export function stablePrefixFoldIncremental(space, alphabet, bytes, boundaries, prev) {
+    const cuts = [];
+    let prevB = 0;
+    for (const b of boundaries) {
+        if (b > prevB && b < bytes.length) {
+            cuts.push(b);
+            prevB = b;
+        }
+    }
+    const edges = [0, ...cuts, bytes.length];
+    const segs = [];
+    for (let i = 0; i + 1 < edges.length; i++) {
+        const hit = prev !== undefined && prev.edges[i] === edges[i] &&
+            prev.edges[i + 1] === edges[i + 1]
+            ? prev.segs[i]
+            : undefined;
+        segs.push(hit ??
+            riverFoldRaw(space, bytesToLeaves(alphabet, bytes.subarray(edges[i], edges[i + 1]))));
+    }
+    if (segs.length === 1) {
+        // Degenerate boundary set — the plain fold, as stablePrefixFold does.
+        const tree = riverFold(space, bytesToLeaves(alphabet, bytes), bytes.length).tree;
+        return { tree, fold: { edges, segs } };
+    }
+    let cur = segs[0];
+    for (let i = 1; i < segs.length; i++)
+        cur = fold2(space, cur, segs[i]);
+    normalize(cur.tree.v);
+    return { tree: cur.tree, fold: { edges, segs } };
+}
 /** Join two folded items as one 2-kid branch — the top-level join of the
  *  stable-prefix fold, identical FP ops to foldSlice's seat-bound
  *  accumulation over a group of two.  Unnormalized (interior). */

package/dist/src/mind/attention.js

@@ -736,6 +736,27 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo) {
                 continue;
             if (ra.end >= rb.start)
                 continue; // overlap or adjacent — nothing between
+            // Candidates strictly BETWEEN ra and rb (cand is sorted by start, so
+            // that is exactly cand[a+1 .. b-1]) that already cast their OWN vote —
+            // genuine, individually-corroborated evidence about what fills the gap
+            // — gate the container search below: a joint container is binding
+            // evidence only when it is CONSISTENT with that evidence, i.e. its own
+            // bytes actually contain what the between-region says. This is the
+            // n-ary composition's normal shape (a between-attribute's bytes DO
+            // recur inside the joint container, credited as an "extra" below) as
+            // opposed to a container that silently substitutes something else for
+            // it (e.g. bridging past "Italy" to a container whose interior is
+            // "Japan" — a different, contradicting learnt whole).
+            // Only a KNOWN (content-addressed, exact) between-region qualifies —
+            // an approximate region's resonance climbing "somewhere" is ordinary
+            // noise (any ANN query returns SOME nearest neighbour), not evidence
+            // this specific gap already means something specific.
+            const between = [];
+            for (let m = a + 1; m < b; m++) {
+                if (strong.has(cand[m]) && !consumed.has(cand[m]) &&
+                    regions[cand[m]].known)
+                    between.push(cand[m]);
+            }
             // A single KNOWN region covering both: the whole form is already a
             // stored identity that votes directly; its pieces add nothing.
             if (regions.some((r) => r.known && r.start <= ra.start && rb.end <= r.end))
@@ -781,6 +802,14 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo) {
                     if (indexOf(query, joined, 0) >= 0)
                         continue; // query says it itself
                 }
+                // CONTRADICTION GUARD: a between-region already carrying its own
+                // vote must actually recur in this container's bytes — otherwise
+                // the container is a different learnt whole that happens to share
+                // ra/rb, and letting it stand in for the gap would silently
+                // override evidence the query itself already resolved there.
+                if (between.some((bi) => indexOf(bytes, query.subarray(regions[bi].start, regions[bi].end), 0) < 0)) {
+                    continue;
+                }
                 let cov = left.length + right.length;
                 const extras = [];
                 for (const ei of cand) {

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

@@ -18,7 +18,7 @@ export declare function internTreeIds(ctx: MindContext, node: Sema, ids: Map<Sem
 export declare function indexSubSpans(ctx: MindContext, tree: Sema, ids: Map<Sema, number>): Promise<boolean>;
 /** Perceive, intern, and index a single input.  Returns the perceived tree,
  *  root id, id map, and the changed (new) subtrees for halo reinforcement. */
-export declare function deposit(ctx: MindContext, input: Input, track: boolean): Promise<{
+export declare function deposit(ctx: MindContext, input: Input, track: boolean, conversational?: boolean): Promise<{
     tree: Sema;
     rootId: number;
     ids: Map<Sema, number>;

package/dist/src/mind/learning.js

@@ -4,7 +4,7 @@
 //   node.  A fact is an EDGE between node ids; recall traverses edges.
 import { bindSeat, companySignature, isChunk } from "../sema.js";
 import { changedNodes } from "./types.js";
-import { inputBytes, perceiveDeposit, resolve, } from "./primitives.js";
+import { inputBytes, latin1Key, perceiveDeposit, resolve, } from "./primitives.js";
 import { canonicalWindows, leafIdPrefix } from "./canonical.js";
 import { fold as foldVecs } from "../sema.js";
 /** Intern a perceived tree into node ids, bottom-up, sharing equal subtrees.
@@ -103,7 +103,7 @@ export async function indexSubSpans(ctx, tree, ids) {
 }
 /** Perceive, intern, and index a single input.  Returns the perceived tree,
  *  root id, id map, and the changed (new) subtrees for halo reinforcement. */
-export async function deposit(ctx, input, track) {
+export async function deposit(ctx, input, track, conversational = false) {
     const bytes = inputBytes(ctx, input);
     // Deposit-shaped perception: stable-prefix tree SEEDING (see
     // perceiveDeposit) — an accumulated context re-folds only its new suffix,
@@ -111,8 +111,13 @@ export async function deposit(ctx, input, track) {
     // (no store-probe fallback): a knownPrefixLength scan on every novel fact
     // would cost O(n²) hashing, while conversation replays are always warm —
     // re-deposition replays from the first turn, rebuilding the cache as it
-    // goes.
-    const tree = perceiveDeposit(ctx, bytes);
+    // goes.  `conversational` scopes the STABLE-PREFIX variant (turn-boundary
+    // folding, matching query-time perception) to ingestPair's own growing
+    // context argument — a bare ingestOne deposit whose bytes merely happen
+    // to extend an earlier UNRELATED deposit (no conversational relationship)
+    // must keep the plain fold, or two coincidentally-prefix-sharing facts
+    // would stop sharing structure with each other.
+    const tree = perceiveDeposit(ctx, bytes, conversational);
     const ids = new Map();
     const rootId = await internTreeIds(ctx, tree, ids);
     const indexed = await indexSubSpans(ctx, tree, ids);
@@ -185,9 +190,19 @@ async function propagateSuffixes(ctx, src, dst) {
 }
 /** Ingest a pair (context, continuation) — learn an edge and pour halos. */
 export async function ingestPair(ctx, ctxInput, cont) {
-    const c = await deposit(ctx, ctxInput, true);
+    const c = await deposit(ctx, ctxInput, true, true);
     const cont_ = await deposit(ctx, cont, false);
     const ctxId = c.rootId, contId = cont_.rootId;
+    // Stamp this turn's continuation onto its own cache entry — the proof a
+    // FUTURE, longer ctxInput needs (see perceiveDeposit) to recognise itself
+    // as this conversation's genuine next turn rather than an unrelated fact
+    // that happens to share this ctxInput's byte prefix.
+    {
+        const ctxBytes = inputBytes(ctx, ctxInput);
+        const entry = ctx._depositTrees.get(latin1Key(ctxBytes));
+        if (entry !== undefined)
+            entry.nextBytes = inputBytes(ctx, cont);
+    }
     await ctx.store.link(ctxId, contId);
     await propagateSuffixes(ctx, ctxId, contId);
     // Halos pour company SIGNATURES (identity), not gists (content) — see

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

@@ -8,6 +8,7 @@
 // cover runs FIRST in defaultMechanisms: a computed-backed cover becomes a
 // near-zero-cost incumbent that prunes the other mechanisms through the
 // ordinary admissible-floor check, with no extension special-case anywhere.
+import { bytesEqual, indexOf } from "../../bytes.js";
 import { read, resolve } from "../primitives.js";
 import { guidedFirst } from "../traverse.js";
 import { conceptHop } from "../match.js";
@@ -158,6 +159,37 @@ export const coverMechanism = {
             : "lightest derivation: the chosen spans, left to right");
         if (segs === null)
             return [];
+        // A chosen span's SUBSTITUTED bytes (an edge followed from a recognised
+        // site, not the site's own literal text read back) that equal a byte
+        // span the query ALREADY CONTAINS elsewhere restates part of the
+        // question — never an answer (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
+        // 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 — the cover
+        // search has no notion of "turn" to gate this itself, so the check
+        // belongs here, over the derivation it already chose.
+        const W = ctx.space.maxGroup;
+        for (const s of segs) {
+            if (!s.rec)
+                continue;
+            const literal = s.j - s.i === s.bytes.length &&
+                bytesEqual(s.bytes, query.subarray(s.i, s.j));
+            if (literal)
+                continue;
+            // A span shorter than one river window is exactly the "ice"/"c"
+            // case: a chain hop's short terminal coincidentally recurring as a
+            // substring of an unrelated longer word.  Below the quantum, byte
+            // overlap is chance, not evidence — the same floor identityBar and
+            // reachThreshold hold every other structural-overlap claim to.
+            if (s.bytes.length >= W && s.bytes.length < query.length &&
+                indexOf(query, s.bytes, 0) >= 0) {
+                ctx.trace?.step("restatedSpan", [rItem(s.bytes, "substituted", s.node, [s.i, s.j])], [], "the chosen span's substitution already occurs elsewhere in the query — restates it, not an answer");
+                return [];
+            }
+        }
         const composed = liftAnswer(segs, query.length);
         if (composed === null)
             return [];

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;

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";
@@ -263,14 +263,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 +315,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 +373,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/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/types.d.ts

@@ -6,7 +6,25 @@ import type { Alphabet } from "../alphabet.js";
 import type { MindConfig } from "../config.js";
 import type { GraphSearch, Leaf, Seg, 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;
+}
 export type Input = string | Uint8Array | Grid | Grid[];
 /** The host capabilities GraphSearch consults during a cover.  MindContext
  *  extends this so the Mind can pass itself as the host. */
@@ -153,15 +171,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "type": "module",
   "main": "dist/src/index.js",

package/src/geometry.ts

@@ -145,7 +145,7 @@ export function coverageBar(_maxGroup: number, D: number): number {
 
 // ---- types ----
 
-interface Folded {
+export interface Folded {
   tree: Sema;
   /** Byte length of the subtree — carried incrementally so the stable-prefix
    *  boundary scan never re-walks subtrees (the old per-level walk was
@@ -383,6 +383,66 @@ function stablePrefixFold(
   return cur.tree;
 }
 
+/** A stable-prefix fold's reusable state: the segment edge offsets and each
+ *  segment's independently-folded root ({@link riverFoldRaw} output).  A
+ *  grown stream whose boundary set EXTENDS a previous fold's reuses every
+ *  matching segment's Folded unchanged (segments fold independently by
+ *  construction, so reuse is bit-identical to refolding) and folds only the
+ *  new right-edge segment — O(turn) per extension, the stable-prefix
+ *  counterpart of {@link FoldPyramid}.  Purely a cache: the produced tree
+ *  never depends on cache state. */
+export interface StableFold {
+  edges: number[];
+  segs: Folded[];
+}
+
+/** {@link stablePrefixFold} with incremental segment reuse — same cuts, same
+ *  segment folds, same left-nested join, same single root normalize; `prev`
+ *  only elides recomputing segments whose [start,end) offsets it already
+ *  folded over a byte-identical prefix (the caller keys the cache by
+ *  content).  Requires a non-empty effective boundary set. */
+export function stablePrefixFoldIncremental(
+  space: Space,
+  alphabet: Alphabet,
+  bytes: Uint8Array,
+  boundaries: readonly number[],
+  prev?: StableFold,
+): { tree: Sema; fold: StableFold } {
+  const cuts: number[] = [];
+  let prevB = 0;
+  for (const b of boundaries) {
+    if (b > prevB && b < bytes.length) {
+      cuts.push(b);
+      prevB = b;
+    }
+  }
+  const edges = [0, ...cuts, bytes.length];
+  const segs: Folded[] = [];
+  for (let i = 0; i + 1 < edges.length; i++) {
+    const hit = prev !== undefined && prev.edges[i] === edges[i] &&
+        prev.edges[i + 1] === edges[i + 1]
+      ? prev.segs[i]
+      : undefined;
+    segs.push(
+      hit ??
+        riverFoldRaw(
+          space,
+          bytesToLeaves(alphabet, bytes.subarray(edges[i], edges[i + 1])),
+        ),
+    );
+  }
+  if (segs.length === 1) {
+    // Degenerate boundary set — the plain fold, as stablePrefixFold does.
+    const tree =
+      riverFold(space, bytesToLeaves(alphabet, bytes), bytes.length).tree;
+    return { tree, fold: { edges, segs } };
+  }
+  let cur = segs[0];
+  for (let i = 1; i < segs.length; i++) cur = fold2(space, cur, segs[i]);
+  normalize(cur.tree.v);
+  return { tree: cur.tree, fold: { edges, segs } };
+}
+
 /** Join two folded items as one 2-kid branch — the top-level join of the
  *  stable-prefix fold, identical FP ops to foldSlice's seat-bound
  *  accumulation over a group of two.  Unnormalized (interior). */

package/src/mind/attention.ts

@@ -867,6 +867,28 @@ async function crossRegionVotes(
       const rb = regions[cand[b]];
       if (!strong.has(cand[a]) && !strong.has(cand[b])) continue;
       if (ra.end >= rb.start) continue; // overlap or adjacent — nothing between
+      // Candidates strictly BETWEEN ra and rb (cand is sorted by start, so
+      // that is exactly cand[a+1 .. b-1]) that already cast their OWN vote —
+      // genuine, individually-corroborated evidence about what fills the gap
+      // — gate the container search below: a joint container is binding
+      // evidence only when it is CONSISTENT with that evidence, i.e. its own
+      // bytes actually contain what the between-region says. This is the
+      // n-ary composition's normal shape (a between-attribute's bytes DO
+      // recur inside the joint container, credited as an "extra" below) as
+      // opposed to a container that silently substitutes something else for
+      // it (e.g. bridging past "Italy" to a container whose interior is
+      // "Japan" — a different, contradicting learnt whole).
+      // Only a KNOWN (content-addressed, exact) between-region qualifies —
+      // an approximate region's resonance climbing "somewhere" is ordinary
+      // noise (any ANN query returns SOME nearest neighbour), not evidence
+      // this specific gap already means something specific.
+      const between: number[] = [];
+      for (let m = a + 1; m < b; m++) {
+        if (
+          strong.has(cand[m]) && !consumed.has(cand[m]) &&
+          regions[cand[m]].known
+        ) between.push(cand[m]);
+      }
       // A single KNOWN region covering both: the whole form is already a
       // stored identity that votes directly; its pieces add nothing.
       if (
@@ -932,6 +954,22 @@ async function crossRegionVotes(
           );
           if (indexOf(query, joined, 0) >= 0) continue; // query says it itself
         }
+        // CONTRADICTION GUARD: a between-region already carrying its own
+        // vote must actually recur in this container's bytes — otherwise
+        // the container is a different learnt whole that happens to share
+        // ra/rb, and letting it stand in for the gap would silently
+        // override evidence the query itself already resolved there.
+        if (
+          between.some((bi) =>
+            indexOf(
+              bytes,
+              query.subarray(regions[bi].start, regions[bi].end),
+              0,
+            ) < 0
+          )
+        ) {
+          continue;
+        }
         let cov = left.length + right.length;
         const extras: number[] = [];
         for (const ei of cand) {

package/src/mind/learning.ts

@@ -9,6 +9,7 @@ import type { Input, MindContext } from "./types.js";
 import { changedNodes } from "./types.js";
 import {
   inputBytes,
+  latin1Key,
   perceive,
   perceiveDeposit,
   resolve,
@@ -119,6 +120,7 @@ export async function deposit(
   ctx: MindContext,
   input: Input,
   track: boolean,
+  conversational = false,
 ): Promise<
   { tree: Sema; rootId: number; ids: Map<Sema, number>; changed: Sema[] }
 > {
@@ -129,8 +131,13 @@ export async function deposit(
   // (no store-probe fallback): a knownPrefixLength scan on every novel fact
   // would cost O(n²) hashing, while conversation replays are always warm —
   // re-deposition replays from the first turn, rebuilding the cache as it
-  // goes.
-  const tree = perceiveDeposit(ctx, bytes);
+  // goes.  `conversational` scopes the STABLE-PREFIX variant (turn-boundary
+  // folding, matching query-time perception) to ingestPair's own growing
+  // context argument — a bare ingestOne deposit whose bytes merely happen
+  // to extend an earlier UNRELATED deposit (no conversational relationship)
+  // must keep the plain fold, or two coincidentally-prefix-sharing facts
+  // would stop sharing structure with each other.
+  const tree = perceiveDeposit(ctx, bytes, conversational);
 
   const ids = new Map<Sema, number>();
   const rootId = await internTreeIds(ctx, tree, ids);
@@ -214,10 +221,20 @@ export async function ingestPair(
   ctxInput: Input,
   cont: Input,
 ): Promise<void> {
-  const c = await deposit(ctx, ctxInput, true);
+  const c = await deposit(ctx, ctxInput, true, true);
   const cont_ = await deposit(ctx, cont, false);
   const ctxId = c.rootId, contId = cont_.rootId;
 
+  // Stamp this turn's continuation onto its own cache entry — the proof a
+  // FUTURE, longer ctxInput needs (see perceiveDeposit) to recognise itself
+  // as this conversation's genuine next turn rather than an unrelated fact
+  // that happens to share this ctxInput's byte prefix.
+  {
+    const ctxBytes = inputBytes(ctx, ctxInput);
+    const entry = ctx._depositTrees.get(latin1Key(ctxBytes));
+    if (entry !== undefined) entry.nextBytes = inputBytes(ctx, cont);
+  }
+
   await ctx.store.link(ctxId, contId);
   await propagateSuffixes(ctx, ctxId, contId);
 

package/src/mind/mechanisms/cover.ts

@@ -11,6 +11,7 @@
 
 import type { MindContext } from "../types.js";
 import type { ComputedResult, Site } from "../graph-search.js";
+import { bytesEqual, indexOf } from "../../bytes.js";
 import { read, resolve } from "../primitives.js";
 import { guidedFirst } from "../traverse.js";
 import { conceptHop } from "../match.js";
@@ -217,6 +218,43 @@ export const coverMechanism: PipelineMechanism = {
 
     if (segs === null) return [];
 
+    // A chosen span's SUBSTITUTED bytes (an edge followed from a recognised
+    // site, not the site's own literal text read back) that equal a byte
+    // span the query ALREADY CONTAINS elsewhere restates part of the
+    // question — never an answer (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
+    // 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 — the cover
+    // search has no notion of "turn" to gate this itself, so the check
+    // belongs here, over the derivation it already chose.
+    const W = ctx.space.maxGroup;
+    for (const s of segs) {
+      if (!s.rec) continue;
+      const literal = s.j - s.i === s.bytes.length &&
+        bytesEqual(s.bytes, query.subarray(s.i, s.j));
+      if (literal) continue;
+      // A span shorter than one river window is exactly the "ice"/"c"
+      // case: a chain hop's short terminal coincidentally recurring as a
+      // substring of an unrelated longer word.  Below the quantum, byte
+      // overlap is chance, not evidence — the same floor identityBar and
+      // reachThreshold hold every other structural-overlap claim to.
+      if (
+        s.bytes.length >= W && s.bytes.length < query.length &&
+        indexOf(query, s.bytes, 0) >= 0
+      ) {
+        ctx.trace?.step(
+          "restatedSpan",
+          [rItem(s.bytes, "substituted", s.node, [s.i, s.j])],
+          [],
+          "the chosen span's substitution already occurs elsewhere in the query — restates it, not an answer",
+        );
+        return [];
+      }
+    }
+
     const composed = liftAnswer(segs, query.length);
     if (composed === null) return [];
 

package/src/mind/mechanisms/recall.ts

@@ -113,10 +113,38 @@ export async function recallByResonance(
       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",

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>();
 
@@ -513,18 +512,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 +573,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 +643,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/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/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";
 
@@ -189,15 +208,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