@hviana/sema 0.7.3 → 0.7.6

package/docs/mechanisms/reference.md

@@ -0,0 +1,58 @@
+# Reference — Voicing a Slot with the Asker's Bytes
+
+Reference voices a slot of a learned frame with the bytes the asker supplied in
+that position — asserting _position_, not equivalence. The bytes are the
+asker's, so voicing them cannot fabricate corpus knowledge; the fabricable claim
+is the _relation_ about them, which the licence withholds.
+
+## Matcher — `frameSlots` inventory
+
+The shared matcher is `frameSlots` (`src/mind/match.ts`) via
+`Precomputed.frames()`.
+
+- Seeded at origin `(0,0)`, `alignAround` finds common runs (seed `W`) then
+  sweeps both directions; each gap is contracted by `contractGap` to its varying
+  core (shared prefix/suffix stripped) and tagged
+  `substitution | insertion | deletion`.
+- `frameSlots` **reports, never judges**: every gap (any kind, any size), sorted
+  by `qs`, plus `covered` (shared bytes) and `matched` spans. No gate is applied
+  there.
+
+## Gate — reference elects and licences; matcher does not
+
+All voicing gates belong to the **consumer**
+(`src/mind/mechanisms/reference.ts`), not the matcher. A shared layer that
+refused on their behalf would be reference-shaped and hide most real pairings.
+
+- **Election:** `electFrame` groups inventory by full slot signature
+  (`qs:qe,...`) and keeps the modal group — one frame, not one slot.
+- **Carriage licence:** `carriesFillers` —
+  `substituteAll(contA, fillersA→fillersB) == contB` byte-exact, all slots
+  simultaneously (longest needle first). Constant continuations pass vacuously;
+  filler-dependent content is refused.
+- **Four voicing gates** (in `voiceable` + caller):
+  1. frame `dominates` query (`covered > |query|/2`);
+  2. every slot reaches one window `W` on _both_ sides;
+  3. no insertion/deletion (substitutions only);
+  4. fillers pairwise distinct. Additional: referents pairwise distinct and no
+     slot inside `answeredSpans`.
+
+Matched frame + every slot is `accounted`; `complete: true`.
+
+## Cost
+
+`moves = STEP·slots + STEP` (one binding per slot + one edge follow). Not
+`CONCEPT` — byte identity, not halo. `scaffolding` is never reported; a referent
+is explained, not carried for lack of explanation.
+
+`floor` is `STEP+STEP`, investment-disciplined before touching `frames()`.
+
+## Provenance
+
+`provenance: "reference"` with trace steps `bindReferent` / `referenceLicence`.
+
+## Pins
+
+- `test/76-reference-binding` — inventory vs gate split, carried/absorbed/
+  refused, multi-slot licence, `complete` and answered-span guard.
+- `test/76-type-level-company` — type-level halo company underpinning.

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://jsr.io/schema/config-file.v1.json",
   "name": "@hviana/sema",
-  "version": "0.7.3",
+  "version": "0.7.6",
   "exports": "./src/index.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.7.3",
+  "version": "0.7.6",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "repository": {
     "type": "git",

package/src/mind/graph-search.ts

@@ -412,7 +412,11 @@ export class GraphSearch {
     // through (completion is cover, recursively — see {@link recompleteNode}).
     this.recompleteOpen.clear();
     this.recompleteMemo = new Map<number, Uint8Array | null>();
-    return this.solve(
+    // The top cover's derivation sink is threaded into every nested completion
+    // so the recompositions a produced form needs are reported in the same
+    // trace instead of vanishing after the first layer.
+    this.derivationSink = onDerivation;
+    const solved = this.solve(
       queryLen,
       {
         sites,
@@ -426,8 +430,17 @@ export class GraphSearch {
       computedResults,
       onDerivation,
     );
+    // Deepening runs HERE, once, on the derivation the top cover CHOSE — never
+    // inside the nested solve a completion runs.  Nesting the deepening is what
+    // made per-query cost track how densely the corpus interconnects the forms
+    // passed through: every re-cover fanned out into the whole corpus's
+    // continuations instead of following the chain the answer itself licensed.
+    // With deepening only at the top, `recompleteNode` walks the accepted chain
+    // one link at a time (its own memo and stack), so the work is the answer's.
+    return solved === null
+      ? null
+      : { segs: this.deepen(solved.segs), cost: solved.cost };
   }
-
   /** Build the deduction system for one span and return its lightest cover's
    *  chosen spans — the SINGLE routine the query and every produced composite
    *  run through.  `recognition` carries the span's recognised forms; the query
@@ -484,7 +497,7 @@ export class GraphSearch {
       onDerivation(readDerivation(derivation, substitutions !== undefined));
     }
     return derivation
-      ? { segs: this.deepen(readCover(derivation)), cost: derivation.cost }
+      ? { segs: readCover(derivation), cost: derivation.cost }
       : null;
   }
 
@@ -974,53 +987,49 @@ export class GraphSearch {
    *  and recompose into a deeper learnt form (→ FINAL).  This is why a single
    *  edge-target needs no bespoke logic — it routes back through {@link solve}.
    *
-   *  Re-recognition (not the node's tree children) is what surfaces the learnt
-   *  parts: content-defined chunking may cut "p1 p2" as "p1 p"|"2", so only
-   *  recognising the bytes recovers p1 and p2 as the forms the graph knows.
+   *  The produced bytes are decomposed by the machinery that owns their shape:
+   *  the span's LEAVES and SPLITS drive the split rule, which resolves each half
+   *  through findLeaf — so a part that straddles a content-defined cut is still
+   *  recovered even though the node's tree children need not align with the
+   *  learnt parts (the fold cuts "p1 p2" as "p1 p"|"2").  Recognised SITES are
+   *  filtered to the node's own kids: a produced form is completed out of what
+   *  it was built from, never by re-recognising arbitrary forms inside it.  That
+   *  filter is load-bearing — a 37-byte dialogue sentence carries seven hub
+   *  openers, and re-covering them chained through the corpus's whole
+   *  continuation population: 2.5 GB and OOM for `respond("hi.")`.
    *
    *  The recovered answer is accepted only when it MOVED and names a LEARNT node
    *  ({@link resolve}) — the graph itself gates against re-expanding a contained
-   *  form ("ice is cold" ⊅→ "ice is cold is cold").
-   *
-   *  Termination is STRUCTURAL: a produced node is re-covered once, never inside
-   *  another re-cover (see the guard below), so one cover pays at most one
-   *  nested {@link solve} per distinct produced node it actually reaches, and
-   *  {@link recompleteMemo} collapses a repeat to nothing.
+   *  form ("ice is cold" ⊅→ "ice is cold is cold").  An ACCEPTED completion is
+   *  then re-covered in turn, so a chain runs as deep as the graph licenses; a
+   *  rejected one ends its branch, so no work is spent past it.
    *
-   *  This comment used to argue termination from "distinct node ids are finite
-   *  and each finished completion is memoised".  That is a bound of N — the one
-   *  AGENTS §2.8 forbids — and it was load-bearing, not pedantic: nested, the
-   *  recursion reached depth 331 and 9.1 GB on an 18.9M-node store for a 2-byte
-   *  query and did not terminate, which is what killed a 5 h training run at its
-   *  checkpoint recall.  Guard: test/89-completion-recursion.test.mjs. */
+   *  Termination and cost are STRUCTURAL: {@link recompleteOpen} is the chain's
+   *  stack (membership is the cycle guard), {@link recompleteMemo} re-covers each
+   *  node at most once, only accepted completions recurse, and every level
+   *  deepens only the top derivation — so a cover pays for the chain it finds,
+   *  not for how densely the corpus interconnects the forms it passes through.
+   *  Guard: test/89-completion-recursion.test.mjs. */
   private recompleteNode(node: number): Uint8Array | null {
     if (!this.host.recogniseSpan) return null;
     const memo = this.recompleteMemo;
     if (memo.has(node)) return memo.get(node) ?? null;
-    // ONE re-cover per produced node — never a re-cover inside a re-cover.
-    //
     // Re-covering is how a PRODUCED node's bytes enter the search at all: the
-    // cover machinery otherwise only ever sees the QUERY's spans.  That is
-    // needed once.  The alternation of decomposition and recomposition that
-    // follows — parts rewriting several times, siblings fusing, a recomposition
-    // feeding another — is the main search's own fuse/`rcmp` work, not this
-    // recursion's: 15-decomposition-gap §9–§12 all pass with this method
-    // disabled outright, and only §6 (the produced composite "p1 p2", whose
-    // bytes nothing else brings in) needs it.
+    // cover machinery otherwise only ever sees the QUERY's spans.  The recursion
+    // is allowed to nest — a chain IS nested completions — but it is bounded so
+    // the work stays the ANSWER's (AGENTS §2.8): the stack below is the cycle
+    // guard, only ACCEPTED completions recurse, and the nested solve decomposes
+    // the form by its own shape instead of re-recognising the corpus's hub forms
+    // inside it.
     //
-    // Nesting it was the defect.  Each level is a full {@link solve} with its
-    // own agenda and chart, exploring from a node the answer never asked about,
-    // so per-query cost tracked how densely the corpus interconnects the forms
-    // passed through — the growth AGENTS §2.8 forbids.  Measured on an
-    // 18.9M-node store: depth 331 and 9.1 GB for a 2-byte query, not
-    // terminating; and on the guard corpus every one of 125 nested re-covers
-    // was REJECTED by the resolve() gate below, expanding a 70-byte node into a
-    // 374-byte concatenation that names nothing.  All of it was waste.
-    //
-    // `recompleteOpen` is that stack, so a non-empty stack means we are already
-    // inside one.  This subsumes the old cycle guard: a node cannot recurse
-    // back into itself when nothing recurses at all.
-    if (this.recompleteOpen.size > 0) return null;
+    // `recompleteOpen` IS the stack of the chain being built, so MEMBERSHIP is
+    // the cycle guard: a node already open on this chain cannot re-enter it.
+    // Testing the NODE — not the stack's size — is what lets a completion
+    // recurse as deep as the graph licenses, exactly the intrinsic convergence
+    // {@link solve}'s contract states.  Work stays the answer's because the
+    // recursion only ever advances through an ACCEPTED completion (below) and
+    // {@link cover} deepens only the top derivation.
+    if (this.recompleteOpen.has(node)) return null;
 
     // A leaf or single-child node has no parts to recompose; skip before the
     // costly recognition so a plain terminal answer pays nothing.
@@ -1033,20 +1042,51 @@ export class GraphSearch {
     const bytes = this.store.bytesPrefix(node, ALL);
     this.recompleteOpen.add(node);
     try {
-      // Completion is cover: re-cover the produced bytes through the SAME solve
-      // routine, recognising them afresh.  No concepts/connectors (those need the
-      // caller's async pre-resolution) — the recursion explores edges and fusion,
-      // which is what a deeper rewrite chain is made of.
+      // Completion is cover, but the produced form is decomposed by its own
+      // shape.  The LEAVES and SPLITS are kept whole, so the split rule still
+      // recovers a part that straddles a content-defined cut (the fold cuts
+      // "p1 p2" as "p1 p"|"2", and findLeaf still resolves p1 and p2).  The
+      // recognised SITES are filtered to the node's own kids, because
+      // re-recognising arbitrary forms inside the bytes is what let a hub-heavy
+      // utterance explode: a 37-byte dialogue sentence carries seven hub
+      // openers, and re-covering them chained through the corpus's whole
+      // continuation population (2.5 GB and OOM for `"hi."`).  No
+      // concepts/connectors either (those need the caller's async
+      // pre-resolution) — the recursion follows edges and fusion, which is what
+      // a deeper rewrite chain is made of.
+      const rec = this.host.recogniseSpan(bytes);
+      const kids = new Set(nrec.kids);
       const solved = this.solve(
         bytes.length,
-        this.host.recogniseSpan(bytes),
+        {
+          sites: rec.sites.filter((s) => kids.has(s.payload)),
+          leaves: rec.leaves,
+          splits: rec.splits,
+          starts: rec.starts,
+        },
         new Map(),
+        undefined,
+        undefined,
+        undefined,
+        this.derivationSink,
       );
       const answer = solved && concatBytes(solved.segs.map((s) => s.bytes));
-      const out = (answer !== null && !bytesEqual(answer, bytes) &&
-          this.host.resolve(answer) !== null)
-        ? answer
+      // ACCEPT, then CONTINUE THE CHAIN — but only along an accepted
+      // completion.  A re-cover whose result is not itself a learnt node (the
+      // 70→374-byte concatenations that name nothing) ends its branch here
+      // instead of recursing into work the answer never asked for, and an
+      // accepted one names a node that is re-covered in turn.  That is what
+      // keeps a deep chain possible while the work stays proportional to the
+      // chain rather than to the corpus's interconnections.
+      const composed = answer !== null && !bytesEqual(answer, bytes)
+        ? this.host.resolve(answer)
         : null;
+      if (composed === null) {
+        memo.set(node, null);
+        return null;
+      }
+      const deeper = this.recompleteNode(composed);
+      const out = deeper ?? answer!;
       memo.set(node, out);
       return out;
     } finally {
@@ -1058,13 +1098,19 @@ export class GraphSearch {
    *  outs of a long query re-cover each distinct node at most once); reset at the
    *  top of {@link cover}. */
   private recompleteMemo = new Map<number, Uint8Array | null>();
-  /** The node currently being re-completed — the recursion stack, and so also
-   *  the nesting depth.  {@link recompleteNode} refuses to start while it is
-   *  non-empty (one re-cover per produced node, never one inside another), which
-   *  is what keeps a query's cost proportional to its answer rather than to the
-   *  corpus; it therefore holds at most one id.  A Set, not a flag, because it
-   *  states WHICH node is open — the invariant a reader needs to check the
-   *  guard, and what makes the old cycle-guard reading still hold. */
+  /** The derivation sink of the TOP cover, threaded into every nested
+   *  completion so a produced form's own recompositions are reported in the
+   *  same trace instead of vanishing after the first layer.  Undefined when
+   *  nothing is inspecting, so an uninspected response pays nothing. */
+  private derivationSink?: (steps: DerivationStep[]) => void;
+  /** The chain of nodes currently being re-completed — the recursion STACK.
+   *  MEMBERSHIP is the cycle guard ({@link recompleteNode} refuses a node
+   *  already open on this chain), which is what lets a completion recurse as
+   *  deep as the graph licenses while the work stays the answer's: the
+   *  recursion only advances through an ACCEPTED completion, every produced
+   *  form is decomposed into its own kids, and the memo re-covers each node at
+   *  most once per cover.  A Set, not a flag, because it states WHICH node is
+   *  open — the invariant a reader needs to check the guard. */
   private recompleteOpen = new Set<number>();
 
   /** out(i,j,bytes,…): index it for the binary rules, then offer splicing a

package/src/mind/mind.ts

@@ -398,10 +398,24 @@ export class Mind implements MindContext {
       } = (optsOrCfg ?? {}) as MindOptions;
       this._canonOpt = optsCanon ?? null;
       this._profile = optsProfile === true;
+      // `explicitSeed` is read BEFORE resolveConfig folds the default in, so
+      // the store can be consulted only when the caller did not choose.
+      const explicitSeed = (rest as Partial<MindConfig>).seed;
       this.cfg = resolveConfig(rest as Partial<MindConfig>);
       this.store = optsStore ?? new SQliteStore({
         maxGroup: this.cfg.geometry.maxGroup,
       });
+      // THE ARTIFACT'S SEED GOVERNS.  `train.seed` is recovered by the store at
+      // open, exactly like `train.D` and `geometry.maxGroup`.  The seed feeds
+      // `makeKeyring`, `Space.rand` and the `Alphabet` below, so folding a
+      // query under config.ts's default (42) against a store trained with
+      // another seed (e.g. 7) lands in a DIFFERENT vector space than the one
+      // the artifact's nodes were folded into: recognition and resonance then
+      // read the wrong space and every answer degrades silently.  An explicit
+      // caller seed still wins — this only replaces the unconfigured default.
+      if (explicitSeed === undefined && this.store.trainSeed !== null) {
+        this.cfg.seed = this.store.trainSeed;
+      }
       userMechanisms = userMechs ?? [];
       userFactories = userFacts ?? [];
     }

package/src/store-sqlite.ts

@@ -401,6 +401,25 @@ export class SQliteStore extends AbstractStore implements Store {
       }
     }
 
+    // Recover the TRAINING seed exactly as D and maxGroup are recovered.  The
+    // seed seeds the alphabet and the seat keyring (mind.ts), so a Mind that
+    // folds a query under any other seed lands in a different vector space
+    // than the one this artifact's nodes were folded into — recognition,
+    // resonance and every mechanism downstream then read the wrong space.  The
+    // trainer persists `train.seed` and refuses to resume against a store
+    // trained with a different one (example/train_base/main.ts), so the value
+    // is authoritative for this artifact.  Absent on a store that was never
+    // trained, where the caller's configured seed stands.
+    {
+      const row = this.sqlite.prepare(
+        "SELECT val FROM meta WHERE key = 'train.seed'",
+      ).get() as { val: string } | undefined;
+      if (row) {
+        const s = Number(row.val);
+        if (Number.isInteger(s) && s >= 0) this._trainSeed = s;
+      }
+    }
+
     // Persist maxGroup to meta when opening a FRESH store (no rows yet) so
     // indexSubtree always sees the training-time value even when the store is
     // accessed without a Mind / full snapshot.

package/src/store.ts

@@ -285,6 +285,17 @@ export class BoundedMap<K, V> {
 export interface Store {
   readonly D: number;
 
+  /** The seed the artifact was TRAINED with, recovered from the store's own
+   *  `train.seed` metadata, or null for a store that was never trained.
+   *
+   *  This is not decoration: the seed feeds the alphabet and the seat keyring
+   *  (see the Mind constructor), so folding a query under any other seed lands
+   *  in a different vector space than the one the artifact's nodes were folded
+   *  into.  A Mind opening a trained store MUST adopt this seed unless the
+   *  caller explicitly overrides it — the same discipline that recovers
+   *  `train.D` and `geometry.maxGroup` from the metadata. */
+  readonly trainSeed: number | null;
+
   /** The work accumulator for the inference call in flight, or null.  The
    *  Mind attaches one per profiled response and detaches it after (see
    *  src/meter.ts).  A store MUST only ever write to it — no read may reach
@@ -917,6 +928,10 @@ export abstract class AbstractStore implements Store {
 
   protected _D: number;
   protected _maxGroup: number;
+  /** `train.seed` recovered by the backend at open, or null when the store was
+   *  never trained.  A backend that omits it simply reports null, which leaves
+   *  the caller's configured seed in force. */
+  protected _trainSeed: number | null = null;
   protected readonly minHaloMass: number;
   protected readonly efSearch: number;
   protected readonly overfetch: number;
@@ -1091,6 +1106,13 @@ export abstract class AbstractStore implements Store {
     return this._D;
   }
 
+  /** The seed the artifact was trained with, recovered from `train.seed` at
+   *  open.  Null for a store that was never trained.  See
+   *  {@link Store.trainSeed} for why this must govern inference. */
+  get trainSeed(): number | null {
+    return this._trainSeed;
+  }
+
   /** Await the async initialisation performed by the concrete constructor. */
   protected async _ensureReady(): Promise<void> {
     if (!this._ready) throw new Error("Store: not open");

package/test/89-completion-recursion.test.mjs

@@ -77,15 +77,35 @@ const mix = (x) => {
   return (x ^ (x >>> 15)) >>> 0;
 };
 
-/** Four-word windows of the repo's own English prose.  Code fences, inline
- *  code and link targets are stripped so what is left is language, which is
- *  where the fragment overlap lives. */
+/** Four-word windows of the repo's own prose, taken from the CODE's comments
+ *  under src (TypeScript) and test (the suites) — never from documentation.  A
+ *  test that reads docs is coupled to every documentation edit: deleting one
+ *  root file once took its corpus below the non-vacuity guard and broke every
+ *  release.  Code comments are prose too, and the code is always here.
+ *
+ *  Comment markers, code fences, inline code and link targets are stripped so
+ *  what is left is language, which is where the fragment overlap lives. */
 function fragments() {
   const out = [];
-  for (const f of readdirSync(REPO).filter((f) => f.endsWith(".md")).sort()) {
-    let t = readFileSync(join(REPO, f), "utf8");
-    t = t.replace(/```[\s\S]*?```/g, " ").replace(/`[^`]*`/g, " ");
-    t = t.replace(/\[[^\]]*\]\([^)]*\)/g, " ");
+  const files = [];
+  const walk = (dir, exts) => {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      if (
+        e.name.startsWith(".") || e.name === "node_modules" || e.name === "dist"
+      ) continue;
+      const p = join(dir, e.name);
+      if (e.isDirectory()) walk(p, exts);
+      else if (exts.some((x) => e.name.endsWith(x))) files.push(p);
+    }
+  };
+  walk(join(REPO, "src"), [".ts"]);
+  walk(join(REPO, "test"), [".mjs"]);
+  for (const f of files.sort()) {
+    const text = readFileSync(f, "utf8");
+    let t = "";
+    for (const m of text.matchAll(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g)) {
+      t += " " + m[0];
+    }
     t = t.toLowerCase().replace(/[^a-z ]+/g, " ").replace(/\s+/g, " ");
     const w = t.split(" ").filter(Boolean);
     for (let i = 0; i + 4 < w.length; i += 2) {
@@ -140,9 +160,9 @@ const SIZES = [750, 1000, 1500];
 test("completion recursion: per-query work does not grow with the corpus", async () => {
   assert.ok(
     FRAG.length > 4000,
-    `only ${FRAG.length} prose fragments found in ${REPO}/*.md — this test ` +
-      `draws its corpus from the repo's own documentation; with the prose gone ` +
-      `it can no longer exercise the completion recursion at all`,
+    `only ${FRAG.length} prose fragments found in the source comments — this ` +
+      `test draws its corpus from src/**/*.ts and test/**/*.mjs; with the ` +
+      `comments gone it can no longer exercise the completion recursion at all`,
   );
 
   const searches = [], pops = [], answers = [], secs = [];

package/test/97-store-seed.test.mjs

@@ -0,0 +1,105 @@
+// 97-store-seed.test.mjs — a trained store's OWN seed governs the Mind that
+// opens it.
+//
+// `train.seed` is persisted by the trainer (example/train_base/main.ts) and the
+// trainer refuses to resume a store under a different seed, so the value is
+// authoritative for the artifact.  The seed feeds `makeKeyring`, `Space.rand`
+// and the `Alphabet` in the Mind constructor: folding a query under any other
+// seed lands in a DIFFERENT vector space than the one the artifact's nodes were
+// folded into, so recognition and resonance read the wrong space and every
+// answer degrades silently.
+//
+// The store recovers `train.D` and `geometry.maxGroup` from its own metadata at
+// open; `train.seed` must be recovered the same way, and a Mind that did not
+// receive an explicit seed must adopt it.  An explicit caller seed still wins.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DEFAULT_CONFIG, Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+
+/** A store that was never trained carries no seed and leaves the caller's
+ *  configured default in force. */
+test("an untrained store reports no trainSeed and keeps the default seed", async () => {
+  const store = new SQliteStore({ path: ":memory:", D: 256 });
+  const mind = new Mind({ store });
+  assert.equal(store.trainSeed, null);
+  assert.equal(mind.cfg.seed, DEFAULT_CONFIG.seed);
+  await store.close();
+});
+
+/** The artifact's seed is recovered at open and adopted by a Mind that was not
+ *  given one; an explicit seed still overrides it. */
+test("a trained store's seed is recovered and adopted unless overridden", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "sema-seed-"));
+  const stem = join(dir, "trained");
+  const TRAIN_SEED = 7;
+
+  // Build the artifact: ingest under an explicit seed, then persist the seed
+  // exactly as the trainer does.
+  {
+    const store = new SQliteStore({ path: stem, D: 256 });
+    const mind = new Mind({ seed: TRAIN_SEED, store });
+    await mind.ingest([["the sky is blue", "blue"]]);
+    await store.setMeta("train.seed", String(TRAIN_SEED));
+    store.commit();
+    await store.close();
+  }
+
+  // Reopen WITHOUT a seed: the store's own seed must stand.
+  {
+    const store = new SQliteStore({ path: stem, D: 256 });
+    assert.equal(store.trainSeed, TRAIN_SEED);
+    const adopted = new Mind({ store });
+    assert.equal(adopted.cfg.seed, TRAIN_SEED);
+    await store.close();
+  }
+
+  // Reopen WITH an explicit seed: the caller wins over the artifact.
+  {
+    const store = new SQliteStore({ path: stem, D: 256 });
+    const explicit = new Mind({ seed: 3, store });
+    assert.equal(explicit.cfg.seed, 3);
+    await store.close();
+  }
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+/** The adopted seed is the one the answer is computed under: a store ingested
+ *  under seed 7 answers a query identically when reopened without a seed and
+ *  when reopened with seed 7 passed explicitly. */
+test("adopting the artifact seed reproduces the artifact's answer", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "sema-seed-"));
+  const stem = join(dir, "trained");
+  const TRAIN_SEED = 7;
+  const QUESTION = "the sky is blue";
+
+  let artifactAnswer;
+  {
+    const store = new SQliteStore({ path: stem, D: 256 });
+    const mind = new Mind({ seed: TRAIN_SEED, store });
+    await mind.ingest([
+      ["the sky is blue", "blue"],
+      ["the grass is green", "green"],
+    ]);
+    artifactAnswer = (await mind.respondText(QUESTION)).trim();
+    await store.setMeta("train.seed", String(TRAIN_SEED));
+    store.commit();
+    await store.close();
+  }
+  assert.equal(artifactAnswer, "blue");
+
+  {
+    const store = new SQliteStore({ path: stem, D: 256 });
+    const adopted = new Mind({ store });
+    assert.equal(adopted.cfg.seed, TRAIN_SEED);
+    assert.equal((await adopted.respondText(QUESTION)).trim(), artifactAnswer);
+    await store.close();
+  }
+
+  rmSync(dir, { recursive: true, force: true });
+});