@hviana/sema 0.2.1 → 0.2.3

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/articulation.js

@@ -83,7 +83,7 @@ export async function articulate(ctx, answer, query) {
             s.end,
         ])),
     ]);
-    const solved = ctx.search.cover(answer.length, voicedSites, new Map(), ans.leaves, ans.splits, substitutions, undefined, undefined, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
+    const solved = ctx.search.cover(answer.length, voicedSites, new Map(), ans.leaves, ans.splits, ans.starts, substitutions, undefined, undefined, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
     const segs = solved && solved.segs;
     tArtCover?.done(segs === null
         ? []

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

@@ -39,6 +39,9 @@ export declare function poolVotes(ctx: MindContext, regionVotes: readonly Region
         end: number;
         w: number;
     }>;
+    /** Per-anchor SCALE-INVARIANT support: Σ RegionVote.absorbed over the
+     *  distinct contributing regions — see Attention.breadth. */
+    regionSupport: Map<number, number>;
     steps: DerivationStep[];
 };
 export declare function commitVotes(ctx: MindContext, pooled: {
@@ -49,6 +52,7 @@ export declare function commitVotes(ctx: MindContext, pooled: {
         end: number;
         w: number;
     }>;
+    regionSupport: Map<number, number>;
     steps: DerivationStep[];
 }, sat: SaturationInfo, regions: readonly Region[], regionVoter: ReadonlyArray<{
     id: number;

package/dist/src/mind/attention.js

@@ -400,6 +400,7 @@ export function poolVotes(ctx, regionVotes, sat, N) {
     const votes = new Map();
     const votesIdf = new Map();
     const support = new Map();
+    const regionSupport = new Map();
     const steps = [];
     let order = 0;
     for (const pc of pool.values()) {
@@ -407,14 +408,17 @@ export function poolVotes(ctx, regionVotes, sat, N) {
             votes.set(pc.item.id, pc.cost);
             const premises = [];
             const seenRi = new Set();
+            let breadthSum = 0;
             for (const c of pc.contributions) {
                 const p0 = c.premises[0].item;
                 if (p0.kind !== "region" || seenRi.has(p0.ri))
                     continue;
                 seenRi.add(p0.ri);
                 const rv = regionVotes[p0.ri];
+                breadthSum += rv.absorbed ?? 1;
                 premises.push({ kind: "form", span: [rv.start, rv.end] });
             }
+            regionSupport.set(pc.item.id, breadthSum);
             steps.push({
                 order: order++,
                 move: "pool-vote",
@@ -444,18 +448,29 @@ export function poolVotes(ctx, regionVotes, sat, N) {
             }
         }
     }
-    return { votes, votesIdf, support, steps };
+    return { votes, votesIdf, support, regionSupport, steps };
 }
 export function commitVotes(ctx, pooled, sat, regions, regionVoter, N) {
-    const { votes, votesIdf, support, steps } = pooled;
+    const { votes, votesIdf, support, regionSupport, steps } = pooled;
     if (votes.size === 0) {
         traceAttention(ctx, regions, regionVoter, [], steps);
         return { roots: [], ranked: [] };
     }
+    // SCALE-INVARIANT confidence — see Attention.breadth's doc.  regions.length
+    // is the query's OWN full candidate count (most never vote at all), the
+    // same denominator the "N of M sub-regions voted" rationale text already
+    // reports; regionSupport is that same accounting read PER ANCHOR.
+    const totalRegions = Math.max(1, regions.length);
     const ranked = [...votes.entries()]
         .map(([anchor, vote]) => {
         const s = support.get(anchor);
-        return { anchor, vote, start: s.start, end: s.end };
+        return {
+            anchor,
+            vote,
+            start: s.start,
+            end: s.end,
+            breadth: (regionSupport.get(anchor) ?? 0) / totalRegions,
+        };
     })
         .sort((a, b) => b.vote - a.vote);
     const overlaps = (a, b) => a.start < b.end && b.start < a.end;
@@ -736,6 +751,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 +817,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) {
@@ -826,14 +870,6 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo) {
                 spanStart = Math.min(spanStart, regions[ei].start);
                 spanEnd = Math.max(spanEnd, regions[ei].end);
             }
-            out.push({
-                start: spanStart,
-                end: spanEnd,
-                canonicalFailed: false, // content-addressed: never saturation-masked
-                roots: reach.roots,
-                w,
-                wFocus: w,
-            });
             consumed.add(cand[a]);
             consumed.add(cand[b]);
             for (const ei of bestExtras)
@@ -843,15 +879,32 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo) {
             // vote's bytes are literally part of the learnt whole), and FULL root
             // disjointness is the disagreement test: a vote sharing even one root
             // with the junction corroborates it and keeps its say elsewhere.
+            // Counted BEFORE pushing the junction's own vote below: each ORIGINAL
+            // region this ascent explains away is evidence the junction speaks
+            // for, not evidence lost — `absorbed` (RegionVote's breadth-accounting
+            // field) must credit the junction with all of it, not just the ONE
+            // pooled axiom it collapses to.
             const containerBytes = cachedRead(ctx, cache, best.id, cap);
             const jointRoots = new Set(reach.roots);
+            let explainedAway = 0;
             for (const rv of rvs.votes) {
                 if (rv.roots.some((r) => jointRoots.has(r)))
                     continue;
                 const bytes = query.subarray(rv.start, rv.end);
-                if (indexOf(containerBytes, bytes, 0) >= 0)
+                if (indexOf(containerBytes, bytes, 0) >= 0 && !superseded.has(rv)) {
                     superseded.add(rv);
+                    explainedAway++;
+                }
             }
+            out.push({
+                start: spanStart,
+                end: spanEnd,
+                canonicalFailed: false, // content-addressed: never saturation-masked
+                roots: reach.roots,
+                w,
+                wFocus: w,
+                absorbed: 1 + explainedAway,
+            });
             const label = [cand[a], cand[b], ...bestExtras]
                 .sort((x, y) => regions[x].start - regions[y].start)
                 .map((ri) => dec(query.subarray(regions[ri].start, regions[ri].end)))

package/dist/src/mind/graph-search.d.ts

@@ -54,6 +54,18 @@ export type GItem = {
     cover: boolean;
     rec: boolean;
     node?: number;
+    /** Set only for a {@link ComputedResult} axiom (an extension's derived
+     *  value, e.g. ALU arithmetic) — as opposed to a genuinely RECOGNISED
+     *  learned form.  Both set `rec: true` (a computation bridges the cover
+     *  exactly like a learned terminal answer), but they mean different
+     *  things for `i..j`'s WIDTH: a recognised form's query-span width is
+     *  real evidence of how much of the query's meaning it accounts for
+     *  (liftAnswer's half-dominance framing decision); a computed span's
+     *  width is operand digit-count, uncorrelated with meaning ("1000 - 421"
+     *  is wider than "15 * 7" only because the numbers are bigger, not
+     *  because subtraction is more "the point" of its query).  See
+     *  {@link liftAnswer}. */
+    computed?: boolean;
 };
 export declare const STEP = 1;
 export declare const CONCEPT = 10;
@@ -72,6 +84,9 @@ export interface Seg {
     bytes: Uint8Array;
     rec: boolean;
     node?: number;
+    /** See the `computed` field of the "out" {@link GItem} — set only for an
+     *  extension's derived value, never a genuinely recognised learned form. */
+    computed?: boolean;
 }
 /** One rule application inside the cover's lightest derivation — the FINEST
  *  grain of Sema's core reasoning, one node of the adapted A*LD proof tree.  `move`
@@ -144,7 +159,7 @@ export declare class GraphSearch {
      *  Any learnt connector between two rewrites is spliced IN by the in-search
      *  connector rule (see {@link outRules}), so the returned spans already carry
      *  it — there is no post-pass. */
-    cover(queryLen: number, sites: ReadonlyArray<Site>, conceptTarget: ReadonlyMap<number, number>, leaves: ReadonlyArray<Leaf>, splits: ReadonlySet<number>, substitutions?: ReadonlyMap<number, Uint8Array>, connectors?: ReadonlyMap<string, Uint8Array>, computedResults?: ReadonlyArray<ComputedResult>, 
+    cover(queryLen: number, sites: ReadonlyArray<Site>, conceptTarget: ReadonlyMap<number, number>, leaves: ReadonlyArray<Leaf>, splits: ReadonlySet<number>, starts: ReadonlySet<number>, substitutions?: ReadonlyMap<number, Uint8Array>, connectors?: ReadonlyMap<string, Uint8Array>, computedResults?: ReadonlyArray<ComputedResult>, 
     /** When given, receives the lightest derivation's rule applications — the
      *  full adapted A*LD proof tree as classified {@link DerivationStep}s — for the TOP
      *  cover only (a recursive recompletion solves its own sub-cover and is not

package/dist/src/mind/graph-search.js

@@ -63,6 +63,7 @@ function readCover(derivation) {
                 bytes: out.bytes,
                 rec: out.rec,
                 node: out.node,
+                computed: out.computed,
             });
         }
         node = node.premises[0];
@@ -205,7 +206,7 @@ export class GraphSearch {
      *  Any learnt connector between two rewrites is spliced IN by the in-search
      *  connector rule (see {@link outRules}), so the returned spans already carry
      *  it — there is no post-pass. */
-    cover(queryLen, sites, conceptTarget, leaves, splits, substitutions, connectors, computedResults, 
+    cover(queryLen, sites, conceptTarget, leaves, splits, starts, substitutions, connectors, computedResults, 
     /** When given, receives the lightest derivation's rule applications — the
      *  full adapted A*LD proof tree as classified {@link DerivationStep}s — for the TOP
      *  cover only (a recursive recompletion solves its own sub-cover and is not
@@ -221,6 +222,7 @@ export class GraphSearch {
             sites,
             leaves,
             splits,
+            starts,
         }, conceptTarget, substitutions, connectors, computedResults, onDerivation);
     }
     /** Build the deduction system for one span and return its lightest cover's
@@ -237,7 +239,7 @@ export class GraphSearch {
      *  decomposes, two recomposes, any mix — and stops only when it reaches a node
      *  that leads nowhere new, never at an arbitrary count. */
     solve(spanLen, recognition, conceptTarget, substitutions, connectors, computedResults, onDerivation) {
-        const system = this.buildSearch(spanLen, recognition.sites, conceptTarget, recognition.leaves, recognition.splits, substitutions, connectors, computedResults);
+        const system = this.buildSearch(spanLen, recognition.sites, conceptTarget, recognition.leaves, recognition.splits, recognition.starts, substitutions, connectors, computedResults);
         const derivation = lightestDerivation(system);
         // When covering under a substitution map (articulation), a form→out rule is
         // the form EMITTING the asker's voice, not grounding to its own answer — so
@@ -257,8 +259,15 @@ export class GraphSearch {
      *  adjacent fragments toward a known leaf (findLeaf) or branch (findBranch);
      *  a completion fused with its neighbour may spell a deeper learned form the
      *  flat probes can't name, recovered canonically by {@link resolve}. */
-    buildSearch(queryLen, sites, conceptTarget, leaves, splits, substitutions, connectors, computedResults) {
+    buildSearch(queryLen, sites, conceptTarget, leaves, splits, starts, substitutions, connectors, computedResults) {
         const W = this.maxGroup; // fusible span ceiling (shortest composite bound)
+        // Same corpus-scale hub floor {@link atomIsHub}/{@link atomReach} (traverse.ts)
+        // derive for byte atoms — duplicated here rather than imported because this
+        // module is deliberately host-based (no MindContext), and both inputs
+        // (maxGroup, edgeSourceCount) are already in scope with no ctx needed.  If
+        // the formula ever changes, it must change in BOTH places (see canonical.ts's
+        // header for the same write/read-side duplication convention).
+        const atomsAreHubs = Math.max(1, Math.ceil((this.store.edgeSourceCount() * W) / 256)) > Math.ceil(Math.sqrt(Math.max(2, this.store.edgeSourceCount())));
         const nodeBytes = (n) => this.store.bytesPrefix(n, ALL);
         // Content-addressed probes over the store's hash-cons maps — the same keys
         // training filled.  No byte-by-byte trie walk.
@@ -350,6 +359,7 @@ export class GraphSearch {
                             cover: true,
                             rec: true,
                             node: u.node,
+                            computed: true,
                         },
                         cost: STEP,
                     };
@@ -388,6 +398,8 @@ export class GraphSearch {
                 return this.outRules(it, {
                     W,
                     splits,
+                    starts,
+                    atomsAreHubs,
                     coversDone,
                     outsByStart,
                     outsByEnd,
@@ -845,7 +857,23 @@ export class GraphSearch {
      *  enters the graph as a form the moment it names a node. */
     *fuse(l, r, ctx) {
         const bytes = concat2(l.bytes, r.bytes);
-        let node = bytes.length <= ctx.W ? ctx.findLeafU(bytes) : undefined;
+        // A PURE leaf-leaf fuse (neither side already a recognised completion)
+        // is opportunistic cross-leaf recovery exactly like recognition.ts's own
+        // canonical chain — findLeaf/findBranch here have no idea WHY these two
+        // leaves are adjacent, only that their concatenation happens to spell a
+        // trained form ("hi" recovered from "W[hi]ch").  The same corpus-scale
+        // caution recognition.ts's `boundary` gate applies: trust it fully when
+        // `l.i` is a position the query's OWN fold chose as a boundary (real
+        // structural evidence); past the scale where atoms themselves stop
+        // discriminating, an interior offset's opportunistic match is noise, not
+        // a genuine cross-leaf recovery.  A completion-involved fuse (l.rec ||
+        // r.rec) is a different, legitimate case — a rewrite growing into its
+        // neighbour — and is exempt, same as recognition.ts's rec-derived sites.
+        const trusted = l.rec || r.rec || ctx.starts.has(l.i) ||
+            !ctx.atomsAreHubs;
+        let node = (trusted && bytes.length <= ctx.W)
+            ? ctx.findLeafU(bytes)
+            : undefined;
         // Whether this pair ACTUALLY forms a 2-child branch — the hard evidence
         // that the fused bytes are a learned form worth keeping alive.  Derived
         // from the same findBranchU probe that sets `node`; when false, the pair
@@ -853,7 +881,8 @@ export class GraphSearch {
         // node cannot contribute to any further fusion (findBranch needs two
         // nodes, resolve needs a completion, and findLeaf already had its chance).
         let pairFormsBranch = false;
-        if (node === undefined && l.node !== undefined && r.node !== undefined) {
+        if (trusted && node === undefined && l.node !== undefined &&
+            r.node !== undefined) {
             node = ctx.findBranchU([l.node, r.node]);
             pairFormsBranch = node !== undefined;
         }

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/alu.js

@@ -12,7 +12,14 @@ import { unexplainedLabel } from "../rationale.js";
 export function aluToMechanism(alu) {
     return {
         name: "alu",
-        provenance: "cover",
+        // Not a cover derivation: cover.ts composes an answer by walking
+        // recognised query STRUCTURE; the ALU evaluates a recognised expression
+        // to its authoritative result and hands the bytes back untouched. It
+        // shares cover's near-zero floor (computation always wins, masked into
+        // cover's own search — see mechanisms/cover.ts), but the candidate this
+        // produces is not one of cover's derivations, so it carries its own
+        // honest label, the same way extract/cast/recall each carry theirs.
+        provenance: "alu",
         parse: (query) => alu.parse(query),
         async floor(_ctx, _query, pre, _worthRunning) {
             return pre.computed.length > 0 ? 0 : null;

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

@@ -70,19 +70,37 @@ const MIN_WEAVE = 2;
  *
  *  Returns the array of {@link CastResult}s that fired (possibly empty). */
 export async function counterfactualTransfer(ctx, query, pre) {
+    // Opened unconditionally, at entry — the same convention recall.ts's
+    // recallByResonance and extraction.ts's extractBySkill use, so every exit
+    // path (five gates below, then the schemas themselves) closes through
+    // ONE scope and inspectRationale never hits a silent dead end.  Only the
+    // first two gates duplicate floor()'s own admissible bound (query length,
+    // ranked anchor count) — required to stay in sync per this function's own
+    // doc comment above, and effectively dead through the ordinary pipeline
+    // (floor() returning null already stops run() from being called at all),
+    // but this function is also exported and callable directly, so they stay
+    // and get the same honest trace as everything past them.
+    const t = ctx.trace?.enter("counterfactual", [rItem(query, "query")]);
+    const fail = (note) => {
+        t?.done([], note);
+        return [];
+    };
     const quantum = ctx.space.maxGroup;
     if (query.length < 2 * quantum || ctx.store.edgeSourceCount() === 0) {
-        return [];
+        return fail("query below the two-quantum floor, or no edges learnt yet");
     }
     const { roots, ranked } = await pre.attention();
-    if (ranked.length < 2)
-        return [];
+    if (ranked.length < 2) {
+        return fail(`only ${ranked.length} ranked anchor(s) — CAST needs at least two`);
+    }
     const weave = await pre.weave();
     const points = weave.points;
     const depth = weave.depth;
     const aligned = points.length;
-    if (aligned < 2)
-        return [];
+    if (aligned < 2) {
+        return fail(`only ${aligned} structure(s) aligned across the query — CAST needs ` +
+            `at least two to transfer between`);
+    }
     // ── Frame gate (half-dominance, weave-local) ─────────────────────────
     // A byte is FRAME when more than MIN_WEAVE aligned structures cover it
     // AND those structures are a majority of all aligned structures.
@@ -120,14 +138,20 @@ export async function counterfactualTransfer(ctx, query, pre) {
     const isRoot = (id) => roots.some((r) => r.anchor === id);
     // The weave must touch a COMMITTED point of attention: the dominant
     // structure itself, or another aligned point the climb committed to.
-    if (!points.some((p) => isRoot(p.anchor)))
+    if (!points.some((p) => isRoot(p.anchor))) {
+        t?.done([
+            ...points.map((p) => rNode(ctx, p.anchor, "aligned")),
+            ...roots.map((r) => rNode(ctx, r.anchor, "committed-root")),
+        ], `${points.length} aligned structure(s), but none is one of the climb's ` +
+            `${roots.length} committed root(s) — CAST refuses to transfer through ` +
+            `content the climb itself never settled on`);
         return [];
+    }
     const woven = points.some((p) => p.runs.some((r) => !pre.rec.sites.some((s) => r.qs >= s.start && r.qe <= s.end)));
-    if (!woven)
-        return [];
-    const t = ctx.trace?.enter("counterfactual", [
-        rItem(query, "query"),
-    ]);
+    if (!woven) {
+        return fail(`every aligned run restates a recognised query site — nothing was ` +
+            `actually WOVEN across structures, so there is nothing to transfer`);
+    }
     // Each schema tried below RECORDS its candidate (when it fires) rather than
     // returning immediately — every schema that succeeds contributes its own
     // candidate, and the grounding decider's own weight comparison (not CAST's

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";
@@ -121,11 +122,18 @@ export const coverMechanism = {
             return [];
         const connectors = await resolveConnectors(ctx, sites);
         let splits = rec.splits;
+        let starts = rec.starts;
         if (computed.length > 0) {
             splits = new Set(rec.splits);
+            starts = new Set(rec.starts);
             for (const u of computed) {
                 splits.add(u.i);
                 splits.add(u.j);
+                // A computation's own boundaries carry the same fold-level evidence
+                // a chunk boundary does — "computation always wins" (see the header
+                // comment) extends to being trusted ground for cross-leaf recovery.
+                starts.add(u.i);
+                starts.add(u.j);
             }
         }
         const concepts = await resolveConcepts(ctx, sites);
@@ -149,7 +157,7 @@ export const coverMechanism = {
             ])),
             ...computedResults.map((u) => rItem(u.bytes, "computed")),
         ], coverDeps.length ? coverDeps : undefined);
-        const solved = ctx.search.cover(query.length, sites, concepts, rec.leaves, splits, undefined, connectors, computedResults, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
+        const solved = ctx.search.cover(query.length, sites, concepts, rec.leaves, splits, starts, undefined, connectors, computedResults, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
         const segs = solved && solved.segs;
         tCover?.done(segs === null
             ? []
@@ -158,6 +166,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 [];