@hviana/sema 0.1.6 → 0.1.8

package/dist/example/train_base.js

@@ -152,8 +152,11 @@ const LOCAL_PATH = env("LOCAL_PATH", ""); // train from a local dir of *.zip
 const CACHE_DIR = env("CACHE_DIR", join(process.cwd(), "cache"));
 const MAX_CACHE_BYTES = Number(env("MAX_CACHE_GB", "100")) * 1e9;
 const PROGRESS_MS = Number(env("PROGRESS_MS", "250")); // panel refresh cadence
-// Index maintenance at checkpoints: compact (remove garbage) then repair (fill
-// gaps). Both are idempotent batch operations; INDEX_MAINTENANCE=0 disables.
+// Index maintenance at checkpoints: compact (remove garbage), repair (fill
+// gaps), then refresh the canonical-form index (equivalence-class resolution —
+// src/canon.ts). All three are idempotent batch operations (the canon build is
+// additionally incremental via the store's `canon.upto` cursor);
+// INDEX_MAINTENANCE=0 disables.
 const INDEX_MAINTENANCE = env("INDEX_MAINTENANCE", "1") !== "0";
 const DOWNLOAD_TRIES = 5;
 // In-progress downloads are written to a sibling "<dest>.part" and atomically
@@ -1485,11 +1488,25 @@ async function main() {
     // final exit for tidiness. Same lesson as waitMs above (deliberately un-unref'd).
     const keepAlive = setInterval(() => { }, 1 << 30);
     const checkpoint = () => mind.save();
-    /** Run index maintenance: compact (remove garbage) then repair (fill gaps).
-     *  Both are idempotent — running twice produces the same result as once.
-     *  Compaction frees index space first; repair then adds back the bridges
-     *  whose gists were evicted before indexing, completing the coverage that
-     *  incremental bridge promotion alone cannot guarantee.
+    /** Run index maintenance: compact (remove garbage), repair (fill gaps),
+     *  then refresh the canonical-form index (see below).  All three are
+     *  idempotent — running twice produces the same result as once.
+     *  Compaction frees index space first; repair then adds back every
+     *  edge/halo-bearing node whose gist was evicted from the pending cache
+     *  before it reached the content index, completing the coverage that
+     *  incremental promotion alone cannot guarantee.
+     *
+     *  repair runs with minParents = 0, NOT the library default of 2.  The
+     *  default repairs only structural BRIDGES (≥2 parents), but this
+     *  trainer's fact deposits also leave answer-side DEPOSIT ROOTS with 0
+     *  structural parents ("The capital of France is Paris." as the dst of a
+     *  Q→A edge is a root of its own tree, contained in nothing).  Those are
+     *  resonance targets recall depends on — a trained store shipped without
+     *  them cannot ground statement-shaped queries against its own answers
+     *  (observed: 33 such roots missing after a full curriculum, including
+     *  high-traffic conversation replies).  minParents = 0 admits every
+     *  edge/halo bearer; the candidate set is still corpus-of-experiences-
+     *  sized, so the pass stays cheap.
      *
      *  Logs the number of entries removed/added so a run that silently degrades
      *  (growing compaction count, or repair never recovering anything) is
@@ -1507,14 +1524,30 @@ async function main() {
             progress.log(`  ${YEL}⚠ index compact failed${R}: ${err instanceof Error ? err.message : String(err)}`);
         }
         try {
-            const added = await mind.repairContentIndex();
+            const added = await mind.repairContentIndex(0);
             if (added > 0) {
-                progress.log(`  ${GRN}index repair: added ${int(added)} missing bridges${R}`);
+                progress.log(`  ${GRN}index repair: added ${int(added)} missing resonance targets${R}`);
             }
         }
         catch (err) {
             progress.log(`  ${YEL}⚠ index repair failed${R}: ${err instanceof Error ? err.message : String(err)}`);
         }
+        // Canonical-form index (src/canon.ts): lets resolution find stored forms
+        // across surface variation (case, width, whitespace).  Incremental and
+        // idempotent by construction — the `canon.upto` meta cursor scans only
+        // nodes newer than the last pass, and the (h, id) primary key ignores
+        // re-inserted rows — so it composes with the resume model exactly like
+        // compact/repair: every checkpoint (and finish) leaves the index
+        // covering all content trained so far.
+        try {
+            const added = await mind.buildCanonIndex();
+            if (added > 0) {
+                progress.log(`  ${GRN}canon index: added ${int(added)} canonical-form entries${R}`);
+            }
+        }
+        catch (err) {
+            progress.log(`  ${YEL}⚠ canon index build failed${R}: ${err instanceof Error ? err.message : String(err)}`);
+        }
     };
     // The checkpoint recall is a best-effort diagnostic. It is time-bounded so a
     // slow/large store can never freeze the deposit loop, and guarded so a still

package/dist/src/alu/src/parser.d.ts

@@ -144,6 +144,15 @@ export declare class QueryParser {
      *  same judgement the perception tree makes about spacing — so no character
      *  is privileged as "the" separator. */
     private arithmeticRuns;
+    /** The maximal BRACKETED arithmetic runs: like {@link arithmeticRuns} but
+     *  grouping brackets participate — an all-'(' term opens depth where an
+     *  operand is expected, a term beginning with ')' closes it where an
+     *  operator could follow (only its bracket prefix joins the run; anything
+     *  after — a trailing "?" — ends it).  A run is recorded only when it is
+     *  BALANCED, actually crossed a bracket, and contains an operator — the
+     *  bracket-free case is {@link arithmeticRuns}' own.  Evaluation is the
+     *  same registry-derived grammar, whose lexer already reads the brackets. */
+    private bracketedRuns;
     /** Evaluate an infix-arithmetic run to its canonical result bytes, through
      *  the kernel's recursive expression evaluator, or null if it does not
      *  evaluate.  A whole result stays an exact int; otherwise the canonical

package/dist/src/alu/src/parser.js

@@ -113,8 +113,26 @@ export class QueryParser {
             j,
             bytes: this.evalRun(query.subarray(i, j)),
         }));
-        const spans = runs.filter((r) => r.bytes !== null);
-        let stream = compose(tokens, runs);
+        // BRACKETED runs — "(3 + 4) * (10 - 2)" — extend across grouping
+        // notation the flat alternation cannot cross.  The expression grammar
+        // (expr.ts) already nests and parenthesizes; this only hands it the
+        // WHOLE bracketed span instead of the fragments between brackets.  A
+        // bracketed run that evaluates ABSORBS the flat runs inside it (the
+        // authority law: contained spans are its material); one that does not
+        // evaluate leaves the flat readings untouched.
+        const bracketed = this.bracketedRuns(query, tokens)
+            .map(([i, j]) => ({ i, j, bytes: this.evalRun(query.subarray(i, j)) }))
+            .filter((r) => r.bytes !== null);
+        const absorbed = (r) => bracketed.some((b) => b.i <= r.i && r.j <= b.j);
+        const composedRuns = [
+            ...runs.filter((r) => !absorbed(r)),
+            ...bracketed,
+        ].sort((a, b) => a.i - b.i);
+        const spans = [
+            ...runs.filter((r) => r.bytes !== null),
+            ...bracketed,
+        ];
+        let stream = compose(tokens, composedRuns);
         const readings = new Map();
         for (;;) {
             const fired = await this.operations(query, stream, readings);
@@ -231,6 +249,96 @@ export class QueryParser {
         }
         return runs;
     }
+    /** The maximal BRACKETED arithmetic runs: like {@link arithmeticRuns} but
+     *  grouping brackets participate — an all-'(' term opens depth where an
+     *  operand is expected, a term beginning with ')' closes it where an
+     *  operator could follow (only its bracket prefix joins the run; anything
+     *  after — a trailing "?" — ends it).  A run is recorded only when it is
+     *  BALANCED, actually crossed a bracket, and contains an operator — the
+     *  bracket-free case is {@link arithmeticRuns}' own.  Evaluation is the
+     *  same registry-derived grammar, whose lexer already reads the brackets. */
+    bracketedRuns(query, tokens) {
+        const OPEN = 0x28, CLOSE = 0x29;
+        const bracketPrefix = (t, b) => {
+            if (t.kind !== "term")
+                return 0;
+            let n = 0;
+            while (t.i + n < t.j && query[t.i + n] === b)
+                n++;
+            return n;
+        };
+        const allOf = (t, b) => bracketPrefix(t, b) === t.j - t.i;
+        const bridged = (from, to) => from >= to || this.host.segment(query.subarray(from, to)).length <= 1;
+        const runs = [];
+        let k = 0;
+        while (k < tokens.length) {
+            const first = tokens[k];
+            if (first.kind !== "operand" && !allOf(first, OPEN)) {
+                k++;
+                continue;
+            }
+            let depth = 0;
+            let ops = 0;
+            let brackets = 0;
+            let expectOperand = true;
+            let end = -1; // byte end of the last VALID run state (balanced, after operand/close)
+            let endTok = k; // token index just past the accepted prefix
+            let m = k;
+            let prevJ = -1;
+            while (m < tokens.length) {
+                const t = tokens[m];
+                if (prevJ >= 0 && !bridged(prevJ, t.i))
+                    break;
+                if (expectOperand) {
+                    if (allOf(t, OPEN)) {
+                        depth += t.j - t.i;
+                        brackets++;
+                    }
+                    else if (t.kind === "operand") {
+                        expectOperand = false;
+                        if (depth === 0) {
+                            end = t.j;
+                            endTok = m + 1;
+                        }
+                    }
+                    else
+                        break;
+                }
+                else {
+                    const c = bracketPrefix(t, CLOSE);
+                    if (c > 0 && depth > 0) {
+                        const take = Math.min(c, depth);
+                        depth -= take;
+                        brackets++;
+                        if (depth === 0) {
+                            end = t.i + take;
+                            endTok = m + 1;
+                        }
+                        // A term with content beyond its usable bracket prefix ("?")
+                        // ends the run inside the term.
+                        if (take < t.j - t.i)
+                            break;
+                    }
+                    else if (t.kind === "operator") {
+                        expectOperand = true;
+                        ops++;
+                    }
+                    else
+                        break;
+                }
+                prevJ = t.j;
+                m++;
+            }
+            if (end >= 0 && ops > 0 && brackets > 0) {
+                runs.push([first.i, end]);
+                k = endTok;
+            }
+            else {
+                k++;
+            }
+        }
+        return runs;
+    }
     /** Evaluate an infix-arithmetic run to its canonical result bytes, through
      *  the kernel's recursive expression evaluator, or null if it does not
      *  evaluate.  A whole result stays an exact int; otherwise the canonical

package/dist/src/canon.d.ts

@@ -0,0 +1,26 @@
+/** A content canonicalizer: maps a byte span to the canonical representative
+ *  of its equivalence class.  Must be pure and deterministic.  Returning the
+ *  input unchanged is always sound (the class is then {input}). */
+export type Canon = (bytes: Uint8Array) => Uint8Array;
+/** The TEXT canonicalizer: Unicode-aware equivalence over every character
+ *  variation that does not change what the text SAYS —
+ *
+ *   • compatibility normalization (NFKC): full-width forms, ligatures,
+ *     composed vs decomposed accents collapse to one representation;
+ *   • case folding (locale-independent lowercase after NFKC — the standard
+ *     simple fold);
+ *   • whitespace: every INTERIOR run of Unicode whitespace becomes one plain
+ *     space.  EDGE whitespace is preserved verbatim: a span's leading or
+ *     trailing separator belongs BETWEEN forms, not to the form — trimming
+ *     it would let a recognised span swallow the boundary byte that
+ *     separates it from its neighbour (observed: "ice fire" composing to
+ *     "coldhot" because the span "ice " matched the stored "ice").
+ *
+ *  "WHAT  IS", "What is" and "ｗｈａｔ is" share one canonical form.  This is
+ *  deliberately conservative: punctuation, digits and word order are content
+ *  and pass through untouched. */
+export declare function textCanon(bytes: Uint8Array): Uint8Array;
+/** 32-bit FNV-1a over a canonical key — the integer the store's canon index
+ *  is keyed on.  Same construction as the node table's content hash; a
+ *  collision is resolved by verifying canon(stored) === key, never trusted. */
+export declare function canonHash(key: Uint8Array): number;

package/dist/src/canon.js

@@ -0,0 +1,57 @@
+// canon.ts — content canonicalization for equivalence-class resolution.
+//
+// The store is content-addressed on RAW bytes: "What", "WHAT" and "what" are
+// three different hashes, so a query whose surface form varies from the
+// trained form resolves to nothing even though the CONTENT is the same.  A
+// CANONICALIZER maps every surface variant of the same content onto one
+// canonical byte string; the store keeps a small hash index from canonical
+// keys to node ids (see Store.canonAdd/canonFind), and resolution falls back
+// to that index when the exact content-addressed lookup misses.
+//
+// The canonicalizer is MODALITY-SPECIFIC and always INJECTED — nothing in the
+// store or the mind's core knows what "case" or "whitespace" is.  The text
+// canonicalizer below is the one `respondText`/`respondTurnText` pass down;
+// a grid or audio modality would supply its own (or none).
+//
+// Canonical keys are equivalence-class LABELS, never content: they are hashed
+// and verified (canon(stored bytes) must equal canon(query bytes) before an
+// id is accepted), so a hash collision costs a read, never a wrong id — the
+// same discipline as the node table's own `h` index.
+const dec = new TextDecoder("utf-8", { fatal: false });
+const enc = new TextEncoder();
+/** The TEXT canonicalizer: Unicode-aware equivalence over every character
+ *  variation that does not change what the text SAYS —
+ *
+ *   • compatibility normalization (NFKC): full-width forms, ligatures,
+ *     composed vs decomposed accents collapse to one representation;
+ *   • case folding (locale-independent lowercase after NFKC — the standard
+ *     simple fold);
+ *   • whitespace: every INTERIOR run of Unicode whitespace becomes one plain
+ *     space.  EDGE whitespace is preserved verbatim: a span's leading or
+ *     trailing separator belongs BETWEEN forms, not to the form — trimming
+ *     it would let a recognised span swallow the boundary byte that
+ *     separates it from its neighbour (observed: "ice fire" composing to
+ *     "coldhot" because the span "ice " matched the stored "ice").
+ *
+ *  "WHAT  IS", "What is" and "ｗｈａｔ is" share one canonical form.  This is
+ *  deliberately conservative: punctuation, digits and word order are content
+ *  and pass through untouched. */
+export function textCanon(bytes) {
+    const s = dec
+        .decode(bytes)
+        .normalize("NFKC")
+        .toLowerCase()
+        .replace(/(\S)\s+(?=\S)/g, "$1 ");
+    return enc.encode(s);
+}
+/** 32-bit FNV-1a over a canonical key — the integer the store's canon index
+ *  is keyed on.  Same construction as the node table's content hash; a
+ *  collision is resolved by verifying canon(stored) === key, never trusted. */
+export function canonHash(key) {
+    let h = 0x811c9dc5 >>> 0;
+    for (let i = 0; i < key.length; i++) {
+        h ^= key[i];
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h >>> 0;
+}

package/dist/src/geometry.d.ts

@@ -103,8 +103,19 @@ export declare function knownPrefixLength(bytes: Uint8Array, leafAt: (i: number)
 /** Bytes → Sema tree.  `leafAt` and `lookup` are store capabilities for
  *  detecting previously-stored prefixes so the river can split at the
  *  correct boundary.  Pass them through from `perceive`; the geometry
- *  computes the stable prefix internally. */
-export declare function bytesToTree(space: Space, alphabet: Alphabet, bytes: Uint8Array, leafAt?: (i: number) => number | null, lookup?: (leafIds: number[]) => number | null): Sema;
+ *  computes the stable prefix internally.
+ *
+ *  `boundaries` is the CALLER-computed stable-prefix boundary set (§10.3):
+ *  strictly-increasing proper byte offsets, each the length of a prefix that
+ *  is already a stored whole-stream form.  When given, the fold splits into
+ *  the segments between consecutive boundaries — each folded independently,
+ *  exactly as it folded when it was learned — and the segment roots join
+ *  LEFT-NESTED (((s₀·s₁)·s₂)…), so every learnt cumulative-context root
+ *  reappears as an identical subtree (and, by hash-consing, the very same
+ *  node) inside the grown stream.  This is what lets a conversation's next
+ *  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;
 /** 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

@@ -270,14 +270,101 @@ export function knownPrefixLength(bytes, leafAt, lookup) {
 /** Bytes → Sema tree.  `leafAt` and `lookup` are store capabilities for
  *  detecting previously-stored prefixes so the river can split at the
  *  correct boundary.  Pass them through from `perceive`; the geometry
- *  computes the stable prefix internally. */
-export function bytesToTree(space, alphabet, bytes, leafAt, lookup) {
+ *  computes the stable prefix internally.
+ *
+ *  `boundaries` is the CALLER-computed stable-prefix boundary set (§10.3):
+ *  strictly-increasing proper byte offsets, each the length of a prefix that
+ *  is already a stored whole-stream form.  When given, the fold splits into
+ *  the segments between consecutive boundaries — each folded independently,
+ *  exactly as it folded when it was learned — and the segment roots join
+ *  LEFT-NESTED (((s₀·s₁)·s₂)…), so every learnt cumulative-context root
+ *  reappears as an identical subtree (and, by hash-consing, the very same
+ *  node) inside the grown stream.  This is what lets a conversation's next
+ *  turn extend perception instead of refolding it: identical prefixes
+ *  produce identical subtrees regardless of what follows them. */
+export function bytesToTree(space, alphabet, bytes, leafAt, lookup, boundaries) {
     if (bytes.length === 0) {
         return sema(alphabet.vecs[0], new Uint8Array(0), null);
     }
+    if (boundaries !== undefined && boundaries.length > 0) {
+        return stablePrefixFold(space, alphabet, bytes, boundaries);
+    }
     const sb = (leafAt && lookup) ? knownPrefixLength(bytes, leafAt, lookup) : 0;
     return riverFold(space, bytesToLeaves(alphabet, bytes), sb > 0 ? sb : bytes.length).tree;
 }
+/** The stable-prefix segmented fold (§10.3).  Each segment between
+ *  consecutive boundaries folds PLAINLY and independently; segment roots
+ *  join left-nested, and only the final root is normalized (the linear-fold
+ *  contract: one normalize per perception).  A segment's own inner splits
+ *  need no recursion here: a nested learnt prefix is itself an earlier
+ *  boundary, so the left-nested join reproduces every intermediate learnt
+ *  root ((s₀·s₁) IS the root the store learnt for the first two segments'
+ *  bytes, and so on). */
+function stablePrefixFold(space, alphabet, bytes, boundaries) {
+    const cuts = [];
+    let prev = 0;
+    for (const b of boundaries) {
+        if (b > prev && b < bytes.length) {
+            cuts.push(b);
+            prev = b;
+        }
+    }
+    if (cuts.length === 0) {
+        return riverFold(space, bytesToLeaves(alphabet, bytes), bytes.length).tree;
+    }
+    const edges = [0, ...cuts, bytes.length];
+    const segs = [];
+    for (let i = 0; i + 1 < edges.length; i++) {
+        const seg = bytes.subarray(edges[i], edges[i + 1]);
+        segs.push(riverFoldRaw(space, bytesToLeaves(alphabet, seg)));
+    }
+    let cur = segs[0];
+    for (let i = 1; i < segs.length; i++)
+        cur = fold2(space, cur, segs[i]);
+    normalize(cur.tree.v);
+    return cur.tree;
+}
+/** 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). */
+function fold2(space, a, b) {
+    const D = space.D;
+    const gist = new Float32Array(D);
+    const kids = [a.tree, b.tree];
+    for (let k = 0; k < 2; k++) {
+        const seat = space.seats[k].fwd;
+        const v = kids[k].v;
+        for (let d = 0; d < D; d++)
+            gist[d] += v[seat[d]];
+    }
+    return { tree: sema(gist, null, kids), len: a.len + b.len };
+}
+/** Plain river fold WITHOUT the final root normalize — the segment-level
+ *  building block of {@link stablePrefixFold} (interiors must keep their
+ *  byte-proportional magnitude; only the whole perception's root is ever
+ *  normalized). */
+function riverFoldRaw(space, row) {
+    if (row.length === 0) {
+        const z = new Float32Array(space.D);
+        return { tree: sema(z, new Uint8Array(0), null), len: 0 };
+    }
+    if (row.length === 1)
+        return row[0];
+    let level = row;
+    while (level.length > 1) {
+        const next = [];
+        foldSlice(space, level, 0, level.length, next, false);
+        if (next.length === level.length) {
+            const forced = [];
+            foldSlice(space, next, 0, next.length, forced, true);
+            level = forced;
+        }
+        else {
+            level = next;
+        }
+    }
+    return level[0];
+}
 /** Plain bytes→tree (identical to capability-less {@link bytesToTree}) that
  *  also RETURNS its pyramid, reusing `prev` — the pyramid of a PROPER
  *  prefix of `bytes` (caller guarantees content match and
@@ -289,6 +376,18 @@ export function bytesToTreePyramid(space, alphabet, bytes, prev) {
             pyramid: { levels: [], bytes: 0 },
         };
     }
+    // ZERO GROWTH: the previous pyramid already covers every byte — its top
+    // level holds the finished, normalized root.  Refolding here would not
+    // only waste the work: when the whole span is one full block, the refold's
+    // top item is a REUSED raw interior of `prev`, and the final normalize
+    // below would mutate that shared raw block in place, corrupting every
+    // later incremental fold built on `prev`.
+    if (prev && prev.bytes === bytes.length && prev.levels.length > 0) {
+        return {
+            tree: prev.levels[prev.levels.length - 1][0].tree,
+            pyramid: prev,
+        };
+    }
     const mg = space.maxGroup;
     const reusable = (L) => {
         // prev's TOPMOST level holds its normalized ROOT — reusable blocks must

package/dist/src/index.d.ts

@@ -9,6 +9,7 @@ export * from "./mind/index.js";
 export * from "./store-sqlite.js";
 export * from "./config.js";
 export * from "./extension.js";
+export * from "./canon.js";
 export * from "./ingest-cache.js";
 export { IvfIndex, Prng, RaBitQuantizer, VectorDatabase, } from "./rabitq-ivf/src/index.js";
 export type { DatabaseOptions, ExternalId, IvfConfig, IvfHit, QueryContext, QueryResult, RaBitQOptions, StorageStats, } from "./rabitq-ivf/src/index.js";

package/dist/src/index.js

@@ -11,6 +11,7 @@ export * from "./mind/index.js";
 export * from "./store-sqlite.js";
 export * from "./config.js";
 export * from "./extension.js";
+export * from "./canon.js";
 export * from "./ingest-cache.js";
 // rabitq-ivf: the partitioned (IVF) vector index over 1-bit RaBitQ codes.
 export { IvfIndex, Prng, RaBitQuantizer, VectorDatabase, } from "./rabitq-ivf/src/index.js";

package/dist/src/mind/attention.js

@@ -9,7 +9,7 @@
 import { isChunk } from "../sema.js";
 import { lightestDerivation, } from "../derive/src/index.js";
 import { consensusFloor, dominates, estimatorNoise } from "../geometry.js";
-import { foldTree, gistOf, perceive, read } from "./primitives.js";
+import { foldTree, gistOf, latin1Key, perceive, read } from "./primitives.js";
 import { recognise } from "./recognition.js";
 import { leafIdRun } from "./canonical.js";
 import { corpusN, edgeAncestors } from "./traverse.js";
@@ -27,16 +27,20 @@ export async function climbAttention(ctx, query, k, mode = "inverse") {
  *  attention) and the entire ranked list.  Cached via ctx.climbMemo when
  *  ctx.trace is null. */
 export async function climbAttentionAll(ctx, query, k, mode = "inverse") {
+    // Content-keyed memo — works for both single-turn respond() and multi-turn
+    // respondTurn().  Skipped while tracing.
     if (ctx.climbMemo && !ctx.trace) {
-        const key = `${k}:${mode}`;
-        let byRead = ctx.climbMemo.get(query);
-        if (byRead === undefined)
-            ctx.climbMemo.set(query, byRead = new Map());
-        const hit = byRead.get(key);
+        const contentKey = latin1Key(query);
+        const modeKey = `${k}:${mode}`;
+        let byRead = ctx.climbMemo.get(contentKey);
+        if (byRead === undefined) {
+            ctx.climbMemo.set(contentKey, byRead = new Map());
+        }
+        const hit = byRead.get(modeKey);
         if (hit !== undefined)
             return hit;
         const read = await computeAttention(ctx, query, k, mode);
-        byRead.set(key, read);
+        byRead.set(modeKey, read);
         return read;
     }
     return computeAttention(ctx, query, k, mode);

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 } from "./primitives.js";
+import { inputBytes, 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.
@@ -152,12 +152,44 @@ export async function ingestOne(ctx, input) {
     }
     return Object.assign(tree, { id: rootId });
 }
+/** For each right-edge suffix of the context bytes, resolve it against the
+ *  store.  A suffix whose resolved node is already a known form inherits the
+ *  continuation edge.  Gate: ≥ 2 structural parents (reused across deposits),
+ *  or (halo > 0 ∧ already an edge source).  Pure answers do not qualify. */
+async function propagateSuffixes(ctx, src, dst) {
+    const W = ctx.space.maxGroup;
+    const bytes = ctx.store.bytes(src);
+    const n = bytes.length;
+    if (n < 2 * W)
+        return;
+    // Existence prefilter — the write side of the canonical contract: every
+    // deposit interns its WHOLE byte stream as a flat branch of per-byte leaf
+    // ids (deposit(), canonical.ts).  A suffix is a stored form exactly when
+    // that flat twin exists, so one content-hash probe per offset decides;
+    // only a hit pays for resolve()'s deposit-shaped perception.  This keeps
+    // the scan free of river folds — O(1) probes over cheap byte hashes
+    // instead of O(suffix) vector folds per offset.
+    const leafIds = leafIdPrefix(ctx, bytes);
+    for (let i = 1; i <= n - W; i++) {
+        if (ctx.store.findBranch(leafIds.slice(i)) === null)
+            continue;
+        const id = resolve(ctx, bytes.subarray(i));
+        if (id === null || id === src)
+            continue;
+        const known = ctx.store.parentsFirst(id, 2).length >= 2 ||
+            (ctx.store.haloMass(id) > 0 && ctx.store.hasNext(id));
+        if (!known)
+            continue;
+        await ctx.store.link(id, 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 cont_ = await deposit(ctx, cont, false);
     const ctxId = c.rootId, contId = cont_.rootId;
     await ctx.store.link(ctxId, contId);
+    await propagateSuffixes(ctx, ctxId, contId);
     // Halos pour company SIGNATURES (identity), not gists (content) — see
     // companySignature in sema.ts.
     const contSeat = bindSeat(ctx.space, companySignature(ctx.space, contId), 1);

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

@@ -94,8 +94,10 @@ export declare function follow(ctx: MindContext, id: number, guide?: Vec | null)
  *  `guide` the context whose gist resonates with the query wins (seat
  *  symmetry) — without one, the most-corroborated context wins (poured halo
  *  MASS, the direct measure of how many episodes established it), falling
- *  back to first-learnt on equal mass.  Callers that HAVE a query gist must
- *  pass it, or they silently change disambiguation regime.
+ *  back to first-learnt on equal mass.  Among many predecessors RECIPROCAL
+ *  ones (mutual edges) are preferred when any exist (RC5).  Callers that
+ *  HAVE a query gist must pass it, or they silently change disambiguation
+ *  regime.
  *
  *  `rev`, when the caller has already materialised prevOf (one read per
  *  relation — a hub's reverse fan-in is corpus-sized), is reused instead of

package/dist/src/mind/match.js

@@ -370,8 +370,10 @@ export async function follow(ctx, id, guide) {
  *  `guide` the context whose gist resonates with the query wins (seat
  *  symmetry) — without one, the most-corroborated context wins (poured halo
  *  MASS, the direct measure of how many episodes established it), falling
- *  back to first-learnt on equal mass.  Callers that HAVE a query gist must
- *  pass it, or they silently change disambiguation regime.
+ *  back to first-learnt on equal mass.  Among many predecessors RECIPROCAL
+ *  ones (mutual edges) are preferred when any exist (RC5).  Callers that
+ *  HAVE a query gist must pass it, or they silently change disambiguation
+ *  regime.
  *
  *  `rev`, when the caller has already materialised prevOf (one read per
  *  relation — a hub's reverse fan-in is corpus-sized), is reused instead of
@@ -386,11 +388,33 @@ export function reverseContext(ctx, id, guide, rev) {
     const candidates = rev ?? ctx.store.prevFirst(id, hubBound(ctx));
     if (candidates.length === 0)
         return null;
-    const pick = candidates.length === 1
-        ? candidates[0]
+    // RECIPROCAL PREFERENCE: among many predecessors, one that `id` also
+    // continues TO (cand → id AND id → cand both learnt) is a mutually
+    // established pairing — the strongest structural evidence a predecessor
+    // can carry (bidirectional training deposits both directions of a genuine
+    // pair).  A bare predecessor is one episode's adjacency; guide-resonance
+    // over bare predecessors favours whichever stored document merely
+    // CONTAINS the query's bytes (the linear fold's cosine is byte overlap —
+    // the observed "merci → unrelated French document" failure).  One capped
+    // forward read decides; when no reciprocal exists, behaviour is unchanged
+    // — bare predecessors ARE the honest answer for a shared deposited
+    // continuation (two questions → one answer; audited by 31-audit C1), and
+    // this arm serves every mechanism's reverse projection, so abstaining
+    // here starves far more than the one containment failure it would fix.
+    let pool = candidates;
+    if (candidates.length > 1) {
+        const fwd = new Set(ctx.store.nextFirst(id, hubBound(ctx)));
+        if (fwd.size > 0) {
+            const mutual = candidates.filter((c) => fwd.has(c));
+            if (mutual.length > 0)
+                pool = mutual;
+        }
+    }
+    const pick = pool.length === 1
+        ? pool[0]
         : guide
-            ? chooseAmong(ctx, candidates, guide).id
-            : pickByMass(ctx, candidates);
+            ? chooseAmong(ctx, pool, guide).id
+            : pickByMass(ctx, pool);
     const g = read(ctx, pick);
     return g.length > 0 ? g : null;
 }