@hviana/sema 0.2.0 → 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/graph-search.js

@@ -487,53 +487,104 @@ export class GraphSearch {
             }
             return;
         }
-        // LIMIT 2 decides all three facts this rule needs — emptiness, plurality
-        // (whether to consult the disambiguator), and the first-inserted
-        // fallback — without materialising a hub context's corpus-sized fan-out.
-        const nx = this.store.nextFirst(it.node, 2);
-        if (nx.length) {
-            // A direct edge — step along the chain toward its fixpoint.  A recomposed
-            // form (parts already rewritten and fused into a learned whole) follows
-            // its continuation at MICRO, so reaching the grounded answer of the
-            // recomposition beats leaving the parts split; the flag rides the chain so
-            // every step of the recomposition's completion stays cheap.
-            //
-            // WHICH edge: a context node often carries SEVERAL learnt continuations
-            // (the same sentence trained against 100+ target languages, a question
-            // answered differently across sessions).  `nx[0]` is an accident of
-            // training order; when the host provides a `chooseNext` disambiguator
-            // (see Mind.chooseNext) it picks the continuation with the most
-            // distributional evidence (prevOf count — the structural manifestation
-            // of its halo), falling back to first-inserted when evidence is equal.
-            yield {
-                premises: [it],
-                conclusion: {
-                    kind: "form",
-                    i: it.i,
-                    j: it.j,
-                    node: (nx.length > 1 ? this.host.chooseNext?.(it.node) : undefined) ??
-                        nx[0],
-                    via: true,
-                    rcmp: it.rcmp,
-                },
-                // A recomposed form's continuation is FREE: the two (or more) parts were
-                // already paid for as their own rewrites, and the single consolidated
-                // span saves one cover-bridge versus leaving them split — so charging 0
-                // here makes the grounded whole (e.g. "DE"→F) strictly beat the split
-                // ("D","E") by exactly that saved bridge, deterministically.
-                cost: it.rcmp ? 0 : STEP,
-            };
-        }
-        else if (it.via) {
-            // The chain reached a node with no WHOLE-node continuation.  Before
-            // emitting it as terminal, CONTINUE THE EXPLORATION into its own structure:
-            // a composite answer like "p1 p2" leads nowhere as a whole, yet recognising
-            // it surfaces p1, p2 — each of which continues (→ R1, R2) and recomposes
-            // into a deeper learnt form (→ FINAL).  {@link recompleteNode} re-covers the
-            // node's bytes through the SAME recognition + edge/fuse machinery the top
-            // query uses (a continued graph exploration, not a re-perception), and
-            // returns the deeper completion's bytes when it genuinely leads somewhere
-            // new.  Emit that; else emit the node itself as the terminal answer.
+        if (it.via) {
+            // A CHAIN hop (this form was itself reached by following an edge):
+            // read up to the hub bound — the SAME √(max(2,N)) convention {@link
+            // hubBound} in traverse.ts derives, replicated here because
+            // GraphSearch holds only a bare Store, not a MindContext — and fork
+            // across EVERY continuation.  A bidirectional pair (SmolSent trains
+            // both directions) puts the back-edge to where we came from ahead of
+            // the forward edge in insertion order; a single first-inserted pick
+            // would walk the search straight into a cycle (the A*LD duplicate-key
+            // guard then dead-ends it) with no way to reach the forward edge.
+            // Forking offers every continuation as its own rule so the one that
+            // genuinely advances (not a duplicate) is still reachable.
+            const bound = Math.ceil(Math.sqrt(Math.max(2, this.store.edgeSourceCount())));
+            const nx = this.store.nextFirst(it.node, bound);
+            if (nx.length) {
+                // The SAME evidence-weighted disambiguation the first hop uses
+                // (below) identifies the most-corroborated continuation.  Yielding
+                // it FIRST matters: {@link lightestDerivation}'s chart keeps the
+                // FIRST rule to reach a given cost for an item and discards later
+                // arrivals at an EQUAL cost (`cost < current`, strictly) — so
+                // among same-depth sibling forks that tie in cost, the
+                // evidence-backed edge wins deterministically, never by
+                // exploration-order luck.  `preferred`, when set, is necessarily
+                // an element of `nx` (chooseNext reads the identical hub-bounded
+                // set — see traverse.ts), so a plain skip-in-place suffices; no
+                // second array need be allocated to reorder it to the front.
+                const preferred = nx.length > 1
+                    ? this.host.chooseNext?.(it.node)
+                    : undefined;
+                const fork = (node) => ({
+                    premises: [it],
+                    conclusion: { kind: "form", i: it.i, j: it.j, node, via: true },
+                    // A real edge always costs STEP, whether it is the first hop or
+                    // the fifth — so a chain's total cost is proportional to its
+                    // length and the lightest derivation is always the SHORTEST
+                    // successful one.  (Charging every hop after the first for
+                    // FREE, as an earlier design did, made every stopping point at
+                    // any depth tie at the same cost — indistinguishable to the
+                    // search, decided by whichever arrived first.)
+                    cost: STEP,
+                });
+                if (preferred !== undefined)
+                    yield fork(preferred);
+                for (const c of nx) {
+                    if (c !== preferred)
+                        yield fork(c);
+                }
+                // Also offer stopping HERE, at CONCEPT above whatever the chain
+                // has already cost — the same "a synonym jump is dearer than a
+                // direct edge" ordering the ladder already uses elsewhere,
+                // repurposed as "giving up early is dearer than one more real
+                // hop".  A premature stop at depth D costs D·STEP + CONCEPT, so a
+                // SHORTER premature stop always beats a longer one, and a genuine
+                // fixpoint (below, costing +0) always beats any premature stop at
+                // the same depth — the search only settles here when continuing
+                // genuinely dead-ends (every fork above revisits an already-
+                // explored key) or grows costlier than giving up.
+                //
+                // The stop-here bytes are the node's OWN, as-is — NOT recompleteNode's
+                // recursive re-cover.  recompleteNode re-runs the full recognition
+                // + edge/fuse search over the node's bytes, an O(node's own
+                // substructure) cost independent of chain depth; offering it at
+                // EVERY premature stop makes a query's total cost scale with how
+                // many nodes the corpus happens to interconnect here (corpus
+                // density), not with the answer's own hop count — the exact
+                // output-sensitivity the rest of this search is built to keep.
+                // Reserved below for the ONE place it is load-bearing: the true
+                // fixpoint, checked once, at the chain's actual end.
+                yield {
+                    premises: [it],
+                    conclusion: {
+                        kind: "out",
+                        i: it.i,
+                        j: it.j,
+                        bytes: nodeBytes(it.node),
+                        cover: true,
+                        rec: true,
+                        node: it.node,
+                    },
+                    cost: CONCEPT,
+                };
+                return;
+            }
+            // The chain reached a node with no WHOLE-node continuation anywhere
+            // — a genuine fixpoint, not a premature stop.  Before emitting it as
+            // terminal, CONTINUE THE EXPLORATION into its own structure: a
+            // composite answer like "p1 p2" leads nowhere as a whole, yet
+            // recognising it surfaces p1, p2 — each of which continues (→ R1,
+            // R2) and recomposes into a deeper learnt form (→ FINAL).  {@link
+            // recompleteNode} re-covers the node's bytes through the SAME
+            // recognition + edge/fuse machinery the top query uses (a continued
+            // graph exploration, not a re-perception), and returns the deeper
+            // completion's bytes when it genuinely leads somewhere new.  Emit
+            // that; else emit the node itself as the terminal answer.  This is
+            // the ONE place the recursive re-cover runs — once, at the chain's
+            // actual end, never per intermediate stop — so its cost tracks the
+            // ANSWER's own structure, not how densely the corpus interconnects
+            // the nodes passed through on the way there.
             const deeper = this.recompleteNode(it.node);
             yield {
                 premises: [it],
@@ -550,6 +601,35 @@ export class GraphSearch {
             };
         }
         else {
+            // The FIRST hop out of a recognised site — unchanged from the
+            // original design.  LIMIT 2 only senses PLURALITY (does this node
+            // have more than one learnt continuation?); the actual bounded read
+            // and evidence-weighted pick both live inside {@link
+            // Mind.chooseNext} (see traverse.ts), which floors its own hub bound
+            // at √(max(2,N)) regardless of what we read here.
+            const nx = this.store.nextFirst(it.node, 2);
+            if (nx.length) {
+                yield {
+                    premises: [it],
+                    conclusion: {
+                        kind: "form",
+                        i: it.i,
+                        j: it.j,
+                        node: (nx.length > 1 ? this.host.chooseNext?.(it.node) : undefined) ??
+                            nx[0],
+                        via: true,
+                        rcmp: it.rcmp,
+                    },
+                    // A recomposed form's continuation is FREE: the two (or more) parts
+                    // were already paid for as their own rewrites, and the single
+                    // consolidated span saves one cover-bridge versus leaving them
+                    // split — so charging 0 here makes the grounded whole (e.g.
+                    // "DE"→F) strictly beat the split ("D","E") by exactly that saved
+                    // bridge, deterministically.
+                    cost: it.rcmp ? 0 : STEP,
+                };
+                return;
+            }
             // Recognised but edge-less: borrow a concept (halo) sibling's edge.  No
             // edge and no concept means the form leads nowhere — it yields no rule, so
             // a query of only such forms produces no derivation, and think is silent.

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,6 +373,15 @@ export class Mind {
         this.canon = this._canonFor(typeof turn === "string" ? textCanon : null);
         this.canonMemo = this.canon ? new Map() : null;
         try {
+            // 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. */