@hviana/sema 0.7.3 → 0.7.5

package/docs/mechanisms/cover.md

@@ -0,0 +1,54 @@
+# Cover — Lightest Derivation over the Query
+
+Cover is graph search. Its axioms are the query's own decomposition and its goal
+is the cheapest cover of the query's bytes. It runs first so a computed-backed
+cover becomes a near-zero-cost incumbent.
+
+## Matcher — `locate` / recognition sites (`src/mind/recognition.ts`)
+
+Sites are spans of the query that name a node already in the store. Cover
+consumes them directly; any site whose bytes overlap a computed span is masked
+(computation always wins).
+
+## Projection — edges + conceptHop (`src/mind/match.ts`, `src/mind/graph-search.ts`)
+
+- `formRules` follow continuation edges (`GraphSearch.formRules`): each hop
+  costs `STEP` (1). Forks across all continuations up to the hub bound;
+  disambiguation is distributional, not heuristic.
+- Edge-less forms may hop via a halo sibling (`conceptHop` / `resolveConcepts`
+  in `src/mind/mechanisms/cover.ts`) at `CONCEPT` (10), borrowing a synonym's
+  continuation.
+
+## Gate — `leadsSomewhere` (`src/mind/traverse.ts`)
+
+A site participates only if it leads somewhere: it bears an edge (`hasNext`) or
+a halo (`hasHalo`). Forms that lead nowhere contribute nothing to any derivation
+and are filtered during recognition.
+
+## Cost (`src/mind/graph-search.ts`)
+
+| Symbol    | Value       | Rule                                            |
+| --------- | ----------- | ----------------------------------------------- |
+| `STEP`    | 1           | per edge hop                                    |
+| `CONCEPT` | 10          | abandoning a chain / synonym hop                |
+| `PASS`    | 1000 / byte | each unaccounted byte                           |
+| `MICRO`   | 1e-3        | per-byte A* heuristic (`h = (len-right)*MICRO`) |
+
+Mechanism weight is `moves + PASS * unaccounted_bytes`; comparison is at `STEP`
+grade, then by `scaffolding` bytes, then list order.
+
+## Pre-resolution (`src/mind/mechanisms/cover.ts`)
+
+`resolveConcepts` and `resolveConnectors` pre-resolve the async maps the
+synchronous search cannot gather: concept targets and learnt connectors, keyed
+by node pair. Bridges (`bridge`) splice connectors between rewrites.
+
+## Provenance
+
+`cover` for the query's own cover; `join` when fusing fragments into a deeper
+learned form.
+
+## Pins
+
+- `test/09-edges.test.mjs` — edge following and hop semantics
+- `test/19-nd.test.mjs` — form rules and multi-hop chains

package/docs/mechanisms/extraction.md

@@ -0,0 +1,53 @@
+# Extraction — Skill-Framed Span Read-out
+
+Extraction transfers a learnt span-in-context skill to an unseen query. A skill
+exemplar is a stored fact whose answer is a span of its context (or of its
+pieces); extraction locates the exemplar's framing bytes in the query and reads
+what sits between them.
+
+## Matcher — `skillExemplar` / `isSpanShaped` / `containsSpan` (`src/mind/match.ts`)
+
+An exemplar is span-shaped when its answer is an in-order embedding of its
+context. `isSpanShaped` is the open reading (sparse subsequence, any gaps) used
+to accept candidates; `answerRunsInContext` is the strong reading (greedy
+longest contiguous runs) used to decompose the answer for projection. Candidates
+are ranked anchors from `climbAttentionAll` (`Precomputed.spanShapedOf`), tried
+in order up to `pre.k`; sub-quantum (`< W = maxGroup`) or unanchored results are
+skipped.
+
+## Projection — read between located frames (`src/mind/mechanisms/extraction.ts`)
+
+`answerRunsInContext` splits the exemplar answer into pieces within its context.
+For each piece, the `W`-bounded pre-frame (and post-frame or next-piece
+pre-frame) is `locate`d in the query at recognition sites. Located frames define
+`start`/`end`; the bytes `query[start:end]` are read out. Multi-piece skills
+concatenate reads in order.
+
+## Gate — both borders located to account (`src/mind/mechanisms/extraction.ts`)
+
+Frames are evidence only when `locate` succeeds. An unanchored read (no frame
+located, `accounted === []`) is discarded — not an extraction. An open-ended
+read (only one border located) stays unaccounted.
+
+## Cost (`src/mind/graph-search.ts`)
+
+Mechanism weight is `moves + PASS * unaccounted_bytes` with
+`moves = CONCEPT + STEP * accounted.length`. Comparison is at `STEP` grade, then
+scaffolding, then list order.
+
+## Selective accounting
+
+Frames are always accounted when located. The read span between them is
+accounted only when bounded on both sides (`preBounded && postBounded`);
+otherwise it is PASS-priced like uncovered bytes, so a correct bounded
+extraction can outweigh an echoing juxtaposition.
+
+## Provenance
+
+`extract` (single-piece) or synthesised multi-piece read.
+
+## Pins
+
+- `test/00-extract.test.mjs` — skill transfer across values and relations
+- `test/68-extraction-unanchored.test.mjs` — unanchored gate (empty accounted is
+  silence)

package/docs/mechanisms/prefix-completion.md

@@ -0,0 +1,54 @@
+# Prefix Completion — Literal Opening of One Trained Form
+
+The query is a proper prefix of exactly one trained form. That form is voiced
+whole; nothing is invented.
+
+## Gate — exactly one opener
+
+A candidate is a form whose bytes literally open with the query (every query
+byte matched in order from offset zero). Grounding requires **exactly one
+distinct continuation** over the candidate set:
+
+- **Candidates** = `formsOpenedBy` (content-addressed window index) ∪ memoised
+  `resonance` top-k — evaluated as one union so an exact-index ambiguity cannot
+  be hidden by the approximate tier.
+- **Distinctness** is by continuation bytes, not form id.
+- **Zero or ≥2 distinct continuations → refuse** (the prefix trap).
+
+## Cost (`src/mind/graph-search.ts`)
+
+| Symbol | Value | Rule                                              |
+| ------ | ----- | ------------------------------------------------- |
+| `STEP` | 1     | maximal claim: every query byte literally matched |
+
+`floor` returns `STEP`; `run` returns one candidate with `moves = STEP`,
+`accounted = [[0, query.length]]`, `bytes = form`.
+
+## `complete` flag
+
+The result carries `complete` semantics: the grounded bytes are a trained form
+reached by identity. Post-grounding (`reason` → `fuse`) must not extend them.
+
+## Guards (from `src/mind/mechanisms/prefix-completion.ts`)
+
+1. **Unreadable veto** — a saturating `bytesPrefix` read is a standing
+   disagreement; if any candidate saturates, none is licensed.
+2. **One grouping window** — continuation must be ≥ `W` (`maxGroup`);
+   sub-quantum tails are unvoiceable and also count as disagreement.
+3. **Uniqueness** — as above.
+
+Structural pre-check (`floor`): `query.length * W < query.length + W` → `null`
+(no room for a perceivable continuation).
+
+## Where it runs
+
+Last grounding mechanism in `defaultMechanisms` (`mind/pipeline.ts`); registered
+after recall so an exact self-match (`IDENTITY`) wins ties. Shares
+`formsOpenedBy` (`mind/traverse.ts`) and `Precomputed.resonance()`.
+
+## Pins
+
+- `test/70-prefix-completion.test.mjs` — literal prefix, ambiguity, sub-quantum,
+  saturating-read veto, determinism.
+- `test/72-prefix-candidate-supply.test.mjs` — `formsOpenedBy` ∪ `resonance`
+  union supply; resonance alone cannot rank a proper prefix.

package/docs/mechanisms/recall.md

@@ -0,0 +1,69 @@
+# Recall — Nearest Stored Form
+
+Recall resonates the whole query's gist against the content index and grounds
+the nearest learned form. Resonance proposes; bytes decide.
+
+## Gist and budget
+
+Query gist is `pre.guide`; the single top-k read is `pre.resonance()` shared
+across the response. `Precomputed.k = 2·recallQueryK` tiers 0b/1/2/3 through it;
+the last tier re-folds bytes.
+
+## Tiers (degrading)
+
+| Tier | Name                  | Gate                                                                                                                                                       | Action                                                                                                            |
+| ---- | --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
+| 0    | Exact identity        | `pre.queryResolved` exists                                                                                                                                 | Reverse-recall (`reverseContext`) to best-resonating predecessor at `STEP`                                        |
+| 0b   | RC8 argument binding  | One maximal `≥2W` edge-source constituent, no substantial `≥2W` form outside it                                                                            | `follow` its continuation; refuses if result is a subspan of the query                                            |
+| 1    | Clean resonance       | `score ≥ identityBar(D,W,len)` per hit                                                                                                                     | `project` hit; restating hits (bytes or `canon`-equivalent) only via reverse-recall                               |
+| 2    | Scaffolding-dominated | `score ≥ significanceBar(D)` and consensus-climb anchor clears `consensusFloor(N)` or `dominates(breadth,1) && peak>ln2`, and query is not all-scaffolding | `project` anchor at `CONCEPT`; refuses if continuation voices the anchor's displaced filler or is a query subspan |
+| 3    | Last resort + bridge  | Query-relative fraction `max(0,cos−sig)·√(lenG/lenQ) ≥ reachThreshold(W)`                                                                                  | Best grounded `project` hit at `STEP`                                                                             |
+
+W = `maxGroup` (river window); bars from `src/geometry.ts`.
+
+## Echo — the refusing tail
+
+If no tier grounded, the exact cosine of the top hit is re-folded (`gistOf` on
+its bytes). Decision uses that exact value in the same query-relative,
+chance-corrected fraction — never the RaBitQ estimate. Below `reach` → silence;
+restating → silence; otherwise the hit's own bytes are returned as an ungrounded
+echo.
+
+## Provenance
+
+Grounded answers carry `recall`; the echo carries `recall-echo` (`echoed: true`
+on `RecallResult`). Consumers distinguish a continuation through learned edges
+from a near-identity echo.
+
+## Substitution bridge — refusal-path only (`src/mind/bridge.ts`)
+
+Runs only after every gist tier failed, reusing the same top-k proposals (the
+bridge's cap is `2·recallQueryK`; every proposal is byte-verified). A candidate
+context is byte-aligned around the rarest stored W-windows. A mismatch becomes a
+corroborated substitution only when its query span is corpus-attested (every
+W-window stored, one reused ≥2 containers), its geometry clears
+`conceptThreshold(D)` or its halo clears `significanceBar(D)`, its frame is
+unanimous, and the raw gap is length-balanced. Coverage must dominate the query
+and no dismissed gap may hide known content (`dismissedKnownContent` gate). Cost
+is `CONCEPT` per substitution plus `STEP`; accounted spans include matched and
+substituted ranges (so a 28/29-byte paraphrase is not charged `PASS` per
+substituted byte — observed double-charge that let `cast` outbid the bridge).
+Zero-substitution identity bridges carry `complete: true` (the whole read-out);
+substituted bridges do not.
+
+Scaffolding-only queries abstain: when every stored window that could anchor is
+saturated (corpus-global scaffolding, `allWindowsAreScaffolding`), the bridge
+returns nothing — a single substituted word cannot carry the semantic load.
+
+## Cost
+
+Tiers 0/1/3 price `STEP` (one hop); tier 2 and the bridge price `CONCEPT` per
+substitution/scaffold step. Mechanism `floor` is `STEP`; weight is
+`moves + PASS·unaccounted`.
+
+## Pins
+
+- `test/03-recall.test.mjs` — exact identity and reverse-recall
+- `test/16-bridge.test.mjs` — corroborated substitutions
+- `test/73-scaffolding-only-bridge-abstains.test.mjs` — scaffolding-only queries
+  stay silent

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.5",
   "exports": "./src/index.ts"
 }

package/package.json

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

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 });
+});