@hviana/sema 0.2.0 → 0.2.2

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.0",
+  "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/graph-search.ts

@@ -707,52 +707,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: number): Rule<GItem> => ({
+          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],
@@ -768,6 +820,36 @@ export class GraphSearch {
         cost: 0,
       };
     } 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/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",