@hviana/sema 0.4.7 → 0.5.0

package/test/57-fusion-order.test.mjs

@@ -82,6 +82,71 @@ test("2. reversing the question reverses the fused answer", async () => {
   await mind.store.close();
 });
 
+test("2b. a topic is never ECHOED back instead of answered", async () => {
+  // The failure this pins: "What is the capital of France? And what is the
+  // largest planet?" answered "The capital of France is Paris.What is the
+  // largest planet?" — one topic answered, the other repeated verbatim.
+  //
+  // It hinged on CASE. The comparison schema seats a directly-aligned analog
+  // by its own bytes rather than chasing a forward edge, which is correct when
+  // those bytes are an answer (test/43 pins that) and an echo when they are
+  // the question the asker just asked. The guard against that is a restatement
+  // check, and a BYTE-EXACT one missed here: the trained node is "What is the
+  // largest planet?" while the query says "And what is the largest planet?" —
+  // the same words, one capital apart. The check now reads the response's own
+  // injected canon, so it sees what the rest of the mind sees.
+  //
+  // SCOPE: this asserts only that nothing is echoed. Whether BOTH topics get
+  // fused is a separate, corpus- and seed-dependent property of the consensus
+  // climb — at this file's seed the second point is sometimes not committed at
+  // all, which is why test 1 above guards its ordering assertion on both names
+  // being present. Answering one topic and staying silent about the other is a
+  // coverage limit; answering one and parroting the other is a defect.
+  //
+  // Asserted in BOTH orders because the echo appeared in only one: which topic
+  // got echoed depended on whether the climb landed on the question node or
+  // the answer node, so a single-order test passes while the bug is live.
+  // ITS OWN CORPUS, DELIBERATELY. The file's shared `trained()` fixture cannot
+  // reproduce this: with five same-frame facts the climb often commits only
+  // ONE point, so there is no second topic to echo and the test would pass
+  // against the unfixed code (verified — it did). The echo needs exactly two
+  // topics, each a bare question node whose answer hangs off a forward edge.
+  const mind = new Mind({
+    seed: 7,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  await mind.ingest([
+    ["What is the capital of France?", "The capital of France is Paris."],
+    ["What is the largest planet?", "The largest planet is Jupiter."],
+  ]);
+  for (
+    const q of [
+      "What is the capital of France? And what is the largest planet?",
+      "What is the largest planet? And what is the capital of France?",
+    ]
+  ) {
+    const a = await mind.respondText(q);
+    assert.ok(
+      !/And what is/i.test(a),
+      `the query was echoed rather than answered: ${JSON.stringify(a)} for ${
+        JSON.stringify(q)
+      }`,
+    );
+    assert.ok(
+      a.includes("Paris") && a.includes("Jupiter"),
+      `both topics must be ANSWERED, got ${JSON.stringify(a)} for ${
+        JSON.stringify(q)
+      }`,
+    );
+    // Nor may an answer be a bare restatement of one of the asked questions.
+    assert.ok(
+      !/^\s*What is the (largest planet|capital of France)\?\s*$/i.test(a),
+      `the answer is just the question restated: ${JSON.stringify(a)}`,
+    );
+  }
+  await mind.store.close();
+});
+
 test("3. a single-topic answer is unchanged by the ordering rule", async () => {
   const mind = await trained();
   assert.match(

package/test/66-query-edge-whitespace.test.mjs

@@ -0,0 +1,99 @@
+// 66-query-edge-whitespace.test.mjs — a query's leading/trailing whitespace is
+// presentation, not part of the question, and must not decide whether a trained
+// fact is reachable.
+//
+// canon.ts's contract: "a span's leading or trailing separator belongs BETWEEN
+// forms, not to the form".  canon itself PRESERVES edge whitespace, and must,
+// because the hazard it cites is a recognised SUB-span swallowing the boundary
+// byte that separates it from its neighbour ("ice " matching the stored "ice").
+// At the outer edges of a WHOLE input there is no neighbour, so that hazard
+// cannot arise — which is why respond() may trim there and canon may not.
+// test/44 already relies on the same reading for recognise()'s miss path.
+//
+// THE GAP THIS CLOSES (measured on the 15.7M-node trained store): ONE leading
+// space took `Who wrote Romeo and Juliet?` and `What is the chemical symbol for
+// water?` from answered to silent, because a shift re-seats every fold boundary
+// (cos(query, query shifted 1 byte) = 0.68 against a 0.875 reach bar).  That was
+// the whole of analyze_training.ts's K2 phase-robustness gap: 15/18 → 18/18.
+//
+// WHY A RETRY AND NOT A PRE-FILTER — the regression this file pins.  Trimming
+// the query up front is ASYMMETRIC: it normalises the query but not the stored
+// forms, so it breaks byte-exact identity for a form trained WITH edge
+// whitespace.  Verified: pre-filtering broke test/04's ["  ice  ", "cold"] case.
+// The exact bytes are therefore tried FIRST and the trim is reached only when
+// they grounded nothing — which also means the retry costs nothing on any
+// answering path.
+//
+// NOTE ON WHAT IS AND IS NOT TESTABLE HERE.  The padded-query WIN cannot be
+// reproduced in a miniature fixture: a small store answers a padded query on the
+// first pass anyway (an earlier tier catches it), so the retry never fires and
+// an end-to-end assertion passes with or without the fix — verified, an earlier
+// version of this file did exactly that and guarded nothing.  What a fixture CAN
+// pin is the trim's own contract and the asymmetry regression, which is what
+// these tests do; the win itself is evidenced on the real store.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+import { textEdgeTrim } from "../dist/src/canon.js";
+
+const enc = (s) => new TextEncoder().encode(s);
+const dec = new TextDecoder();
+const trim = (s) => dec.decode(textEdgeTrim(enc(s)));
+
+test("1. textEdgeTrim drops only the outer spacing run", () => {
+  assert.equal(trim("  ice  "), "ice");
+  assert.equal(trim("\tice\n"), "ice");
+  assert.equal(trim("ice"), "ice");
+  // INTERIOR whitespace is content and is never touched.
+  assert.equal(trim("  a  b  "), "a  b");
+  // All-separator and empty inputs collapse to empty rather than throwing.
+  assert.equal(trim("   "), "");
+  assert.equal(trim(""), "");
+  // The untouched case must return the SAME object (no copy on the hot path).
+  const b = enc("ice");
+  assert.equal(textEdgeTrim(b), b);
+});
+
+test("2. a form trained WITH edge whitespace still answers when asked exactly", async () => {
+  // The asymmetry regression: trimming the query but not the store would make
+  // this query miss its own deposited form.
+  const m = new Mind({ seed: 7 });
+  await m.ingest([["  ice  ", "cold"]]);
+  assert.equal(await m.respondText("  ice  "), "cold");
+});
+
+test("3. whitespace-only and empty queries are silent, not errors", async () => {
+  const m = new Mind({ seed: 7, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest([["what is ice?", "ice is frozen water"]]);
+  for (const q of ["", " ", "   ", "\t\n"]) {
+    assert.equal(
+      await m.respondText(q),
+      "",
+      `expected silence for ${JSON.stringify(q)}`,
+    );
+  }
+  await m.store.close();
+});
+
+test("4. a padded query never answers something the unpadded one would not", async () => {
+  // The retry may add REACH, never licence: whatever padding does, it must not
+  // ground a fact for a question the store cannot answer.
+  const m = new Mind({ seed: 7, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest([
+    ["what is the capital of France?", "The capital of France is Paris."],
+    ["what is the capital of Spain?", "Madrid is the capital of Spain."],
+  ]);
+  for (const q of ["  Who wrote the Iliad?  ", "  xyzzy plugh quux  "]) {
+    const a = await m.respondText(q);
+    assert.doesNotMatch(
+      a,
+      /Paris|Madrid/,
+      `padding manufactured an answer for ${JSON.stringify(q)}: ${
+        JSON.stringify(a)
+      }`,
+    );
+  }
+  await m.store.close();
+});

package/test/67-climb-anchor-breadth.test.mjs

@@ -0,0 +1,113 @@
+// 67-climb-anchor-breadth.test.mjs — recall's scaffolding-dominated tier
+// trusts a consensus-climb anchor on its SCALE-INVARIANT breadth as well as on
+// its absolute IDF vote, and a breadth-qualified anchor must also be
+// DISCRIMINATIVE.
+//
+// WHY THE ABSOLUTE VOTE IS NOT ENOUGH.  Attention.breadth's own contract
+// (types.ts) already says it: the IDF vote is "an absolute, ln(N)-scaled
+// quantity that means 'strong' on a small store and 'weak' on a large one for
+// the SAME degree of genuine consensus", while breadth is "the fraction of the
+// query's OWN regions whose evidence this point accounts for" and "a point
+// whose breadth clears `dominates` … is real consensus".  Attention.peak's
+// contract makes the same point from the other side: a floor that prices ONE
+// region's evidence may not be compared against a POOLED SUM.
+//
+// Measured on the 15.7M-node trained store (N=325,615, floor = ln N + ½ =
+// 13.19).  The climb picked the RIGHT context and the floor discarded it, while
+// a junk attractor for a query that must stay SILENT outvoted every correct
+// anchor:
+//
+//   anchor the climb picked             vote   breadth  correct?
+//   "What is the chemical formula …"    10.60    0.556   RIGHT
+//   "Qual é a capital de França?"        8.19    0.667   RIGHT
+//   "Who wrote the play Romeo …?"        8.25    0.833   RIGHT
+//   "How do you say "good morning" …"   10.77    0.800   RIGHT
+//   "What is the commercial capital …"  12.69    0.333   Zamunda — MUST be silent
+//   "Menene sunan ginin mafi tsayi …"   12.79    0.214   wrong (Hausa)
+//
+// No vote threshold separates those; breadth > ½ separates them exactly.  On
+// that store the old floor was never cleared at all, so the tier was dead code
+// and 12 probes fell through to silence.
+//
+// WHAT MUST NOT REGRESS, and why the gate is an OR of two guarded readings:
+//
+//   • REPLACING the vote test with the breadth test broke 7 tests.  On a small
+//     store ln(N) is low, so the vote bar is the reading that legitimately
+//     fires there; and Attention.clusters' contract warns that "breadth starves
+//     a genuine, evenly-split multi-topic query, since no root in a real N-way
+//     split can exceed half the vote" — the two-topic fusion tests are exactly
+//     that shape.  Each reading is sufficient on its own evidence.
+//   • BREADTH ALONE fabricates.  On a one-context store every region trivially
+//     corroborates the only anchor there is, so breadth is 1 while the anchor's
+//     IDF is 0 — test/31 A2 answered a lone cat fact for "explain quantum
+//     chromodynamics".  Hence the companion condition: a region's IDF for an
+//     anchor reached through c of N contexts is ln(N/c), so requiring it past
+//     ln 2 requires c·2 < N — the same half-dominance reading in IDF units.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+
+const mk = () =>
+  new Mind({ seed: 1, store: new SQliteStore({ path: ":memory:" }) });
+
+test("1. a one-context store never grounds an unrelated query (breadth alone must not decide)", async () => {
+  // Breadth is trivially 1 when there is only one anchor to corroborate, but
+  // that anchor's IDF is 0 — it says nothing.  VERIFIED to bite: dropping the
+  // `peak > ln 2` companion makes this fail (and test/31 A2 with it).  The
+  // fixture matches A2's exactly — `new Mind({ seed: 7 })`, the default store —
+  // because the same shape over a SQliteStore did NOT reproduce it.
+  const m = new Mind({ seed: 7 });
+  await m.ingest([["what is a cat?", "a cat is a small feline"]]);
+  const r = await m.respond("explain quantum chromodynamics");
+  assert.equal(
+    r.v,
+    null,
+    "a lone low-IDF anchor must not ground a foreign query",
+  );
+  assert.equal(r.provenance, undefined);
+});
+
+test("2. an evenly-split multi-topic query still fuses (breadth must not be required)", async () => {
+  // The shape Attention.clusters' contract says breadth starves: no root in a
+  // real N-way split can hold more than half the query's regions, so a
+  // breadth-only gate would refuse both topics.
+  const m = mk();
+  await m.ingest([
+    ["ice", "cold"],
+    ["fire", "hot"],
+    ["what is ice?", "ice is frozen water"],
+    ["what is fire?", "fire is rapid oxidation"],
+  ]);
+  const a = await m.respondText("ice fire");
+  assert.ok(a.length > 0, "a two-topic query must still ground something");
+  await m.store.close();
+});
+
+test("3. honest silence survives on an unrelated corpus", async () => {
+  const m = mk();
+  await m.ingest([
+    ["what is the capital of France?", "The capital of France is Paris."],
+    ["what is the capital of Spain?", "Madrid is the capital of Spain."],
+    ["what is the capital of Italy?", "Rome is the capital of Italy."],
+  ]);
+  for (const q of ["xyzzy plugh quux baz?", "qq8f3kz9 vv2m1x7w?"]) {
+    const a = await m.respondText(q);
+    assert.equal(a, "", `gibberish must stay silent, got ${JSON.stringify(a)}`);
+  }
+  await m.store.close();
+});
+
+test("4. a trained fact still answers (the tier did not displace an earlier one)", async () => {
+  const m = mk();
+  await m.ingest([
+    ["what is the capital of France?", "The capital of France is Paris."],
+    ["what is the capital of Spain?", "Madrid is the capital of Spain."],
+  ]);
+  assert.match(
+    await m.respondText("what is the capital of France?"),
+    /Paris/,
+  );
+  await m.store.close();
+});

package/test/68-extraction-unanchored.test.mjs

@@ -0,0 +1,79 @@
+// 68-extraction-unanchored.test.mjs — an extraction that located NO frame of its
+// exemplar in the query is not an extraction, and must not answer.
+//
+// extractBySkill's own contract says `accounted` carries "the located frames AND
+// any read span BOUNDED by located frames on both sides", while an open-ended
+// read "remains a guess about where the span stops — it stays unaccounted".
+// EMPTY accounted is the degenerate case: no frame was located at all, so
+// nothing ties the bytes just read to this question.  isSpanShaped is
+// deliberately permissive (a sparse-subsequence check) and will accept an
+// exemplar whose relation to the query is coincidental gap-matching; requiring
+// at least one located frame is the structural evidence it leaves out.
+//
+// THE CASE (analyze_training.ts F, the battery's ONLY wrong non-silent answer,
+// on the 15.7M-node store): "Which city is France's seat of government?"
+// answered "Which ci" — a fragment of the query itself — from the exemplar
+// "What is dll", with accounted=[] and pieces=1.  A/B verified: without the gate
+// the answer is "Which ci"; with it, silence.  The battery went from
+// 31✓/1 weak/10 empty to 31✓/0 weak/11 empty, and `extract` left the provenance
+// census entirely — no wrong answers remain anywhere in it.
+//
+// WHY THE GATE LIVES HERE AND NOT IN THE PIPELINE.  The same test at the
+// pipeline's post-grounding density check was tried and REVERTED: `accounted` is
+// passed empty BY CONVENTION on recall's own tiers (recall.ts ground(…, [], …)),
+// so a density veto there refused six legitimate reverse-recall groundings
+// (seat symmetry, bidirectional chain, E9 turn parity, C1 reverse-recall …).
+// Inside extraction the field is this mechanism's own output and carries its
+// documented meaning, so the test is sound exactly where the convention cannot
+// reach it.
+//
+// NOT REPRODUCIBLE IN A FIXTURE: a miniature corpus yields ANCHORED extractions
+// (a frame IS located, accounted non-empty), which this gate correctly permits —
+// verified across seeds 1/7/42.  So what this file pins is the other side: the
+// gate must not block a located-frame extraction.  The wrong-answer fix itself is
+// evidenced by the real-store A/B above.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+
+/** Span-shaped exemplars: the answer is a subsequence of its context, so the
+ *  learnt skill is "read the thing the frame wraps". */
+const TRAIN = [
+  ["What is dll?", "dll"],
+  ["What is api?", "api"],
+  ["What is ram?", "ram"],
+  ["What is cpu?", "cpu"],
+  ["What is gpu?", "gpu"],
+  ["What is ssd?", "ssd"],
+];
+
+test("1. an extraction whose frame IS located still answers (gate must not over-block)", async () => {
+  for (const seed of [1, 7, 42]) {
+    const m = new Mind({ seed, store: new SQliteStore({ path: ":memory:" }) });
+    await m.ingest(TRAIN);
+    const a = await m.respondText("Which colour is the deepest ocean?");
+    assert.ok(
+      a.length > 0,
+      `seed ${seed}: a located-frame extraction must survive the unanchored gate`,
+    );
+    await m.store.close();
+  }
+});
+
+test("2. the learnt skill still reads its own trained frame", async () => {
+  const m = new Mind({ seed: 7, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest(TRAIN);
+  assert.match(await m.respondText("What is dll?"), /dll/);
+  await m.store.close();
+});
+
+test("3. gibberish stays silent — the gate adds refusal, never licence", async () => {
+  const m = new Mind({ seed: 7, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest(TRAIN);
+  for (const q of ["qq8f3kz9 vv2m1x7w?", "xyzzy plugh quux baz?"]) {
+    assert.equal(await m.respondText(q), "", `expected silence for ${q}`);
+  }
+  await m.store.close();
+});

package/test/69-frame-filler.test.mjs

@@ -0,0 +1,115 @@
+// 69-frame-filler.test.mjs — the frame-filler tier must not fire without its
+// evidence, and must refuse an ambiguous subject.
+//
+// WHAT THE MECHANISM DOES (src/mind/frame-filler.ts): when every other tier has
+// declined, take the query's described span, put a corroborated filler from a
+// trained context in its place, and require the STORE to already hold that key
+// byte-exactly.  "We invent a lookup KEY, never an answer" — the answer is the
+// trained continuation of a form the store verifiably has.
+//
+// THE WIN IS REAL-STORE EVIDENCE, NOT A FIXTURE.  On the 15.7M-node trained
+// store, `What is the capital of the country where the Eiffel Tower is?` goes
+// from silence to "The capital of France is Paris." (provenance `recall`), taking
+// analyze_training.ts's section G from 33.3% to 66.7% and the battery from 73.8%
+// to 76.2% with `0 weak` intact.  A/B on warm caches: +50 ms on that query,
+// +16 ms on a refusing query that runs 480 probes, and +0 ms on
+// `What is the capital of Zamunda?` (guard 1 exits before probing) and on every
+// query that answers earlier.
+//
+// WHY NO POSITIVE FIXTURE TEST EXISTS — measured, not assumed.  The mechanism
+// keys on corpus RARITY (container counts, the same reading the bridge's anchor
+// picking uses).  At fixture scale that signal is absent and even inverted: in a
+// 21-deposit store `capital` reports 1 container and `landmark` reports 9, while
+// on the trained store `Eiffel` is 54 against `What` at 1,586.  So a fixture
+// cannot make the query's rarest word land inside the description, which guard 1
+// requires — three fixture shapes were tried (bare, 21-deposit, and one with an
+// attested long word in the description) and none reached the positive path.
+// What a fixture CAN pin is the refusal side, which is what this file does.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+import { frameFillerSubstitution } from "../dist/src/mind/frame-filler.js";
+
+const enc = (s) => new TextEncoder().encode(s);
+const FRAME = [
+  ["What is the capital of France?", "Paris is the capital of France."],
+  ["What is the capital of Spain?", "Madrid is the capital of Spain."],
+  ["What is the capital of Italy?", "Rome is the capital of Italy."],
+  ["What is the capital of Japan?", "Tokyo is the capital of Japan."],
+];
+const LINK = [
+  "What is the most famous landmark in France?",
+  "The most famous landmark in France is the Eiffel Tower.",
+];
+const LINK2 = [
+  "What is the tallest structure in Spain?",
+  "The tallest structure in Spain is the Eiffel Tower.",
+];
+const Q = "What is the capital of the country where the Eiffel Tower is?";
+
+async function fixture(train) {
+  const mind = new Mind({
+    seed: 1,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  await mind.ingest(train);
+  return mind;
+}
+/** Call the tier the way recall does: the query plus recall's ranked hit ids. */
+async function tier(mind, q) {
+  const hits = await mind.store.resonate(mind.perceive(q).v, 24);
+  return frameFillerSubstitution(mind, enc(q), hits.map((h) => h.id));
+}
+
+test("1. no linking evidence — the tier does not fire", async () => {
+  // The frame is attested, but nothing in the store ties the description's
+  // content to any filler.  Guard 1 has nothing to qualify.
+  const m = await fixture(FRAME);
+  assert.equal(await tier(m, Q), null);
+  await m.store.close();
+});
+
+test("2. an AMBIGUOUS subject is refused", async () => {
+  // Two trained contexts hold the description's content and each proposes a
+  // different filler.  Guard 4: neither is licensed.
+  const m = await fixture([...FRAME, LINK, LINK2]);
+  assert.equal(await tier(m, Q), null);
+  await m.store.close();
+});
+
+test("3. an unrelated query never grounds a frame neighbour", async () => {
+  // The fabrication shape: a fictional filler in an attested frame.  On the real
+  // store this query resolves 24 keys (Chile, India, Japan, Italy …) once the
+  // guards are weakened, so it is the case that most needs pinning.
+  const m = await fixture([...FRAME, LINK]);
+  for (
+    const q of [
+      "What is the capital of Zamunda?",
+      "xyzzy plugh quux baz?",
+      "qq8f3kz9 vv2m1x7w?",
+    ]
+  ) {
+    assert.equal(await tier(m, q), null, `expected refusal for ${q}`);
+  }
+  await m.store.close();
+});
+
+test("4. the tier is deterministic and side-effect free", async () => {
+  const m = await fixture([...FRAME, LINK]);
+  const a = await tier(m, Q);
+  const b = await tier(m, Q);
+  assert.deepEqual(a, b);
+  // Running it must not disturb the answers of forms that ground normally.
+  assert.match(await m.respondText("What is the capital of France?"), /Paris/);
+  await m.store.close();
+});
+
+test("5. end to end, the fixture's own trained forms still answer", async () => {
+  const m = await fixture([...FRAME, LINK]);
+  assert.match(await m.respondText("What is the capital of Spain?"), /Madrid/);
+  assert.match(await m.respondText("What is the capital of Japan?"), /Tokyo/);
+  assert.equal(await m.respondText("qq8f3kz9 vv2m1x7w?"), "");
+  await m.store.close();
+});

package/test/70-prefix-completion.test.mjs

@@ -0,0 +1,170 @@
+// 70-prefix-completion.test.mjs — a query that IS the opening of one trained
+// form is completed by that form's remainder; anything less is refused.
+//
+// WHAT THE MECHANISM DOES (src/mind/prefix-completion.ts): when every other
+// tier has declined, scan the candidate list recall's refusal path has ALREADY
+// fetched and look for a trained form whose bytes literally BEGIN with the whole
+// query.  The answer is that form's own remainder — never an invention.
+//
+// WHY IT IS NEEDED, measured on the 15.7M-node trained store:
+// `The capital of France is` grounded nothing, while
+// `The capital of France is Paris.` is trained and reads back byte-exact.  Two
+// independent reasons the earlier tiers cannot reach it:
+//   * `resolve(prefix)` is null — a proper prefix has no branch of its own.
+//   * the form is absent from `resonate(k)` at k = 24, 256 AND 2048, while forms
+//     scoring LOWER are returned (cos 0.5752 for the target against Germany
+//     0.5670, Yemen 0.5591).  `k` only reorders within the IVF clusters already
+//     probed, so no k recovers it; with `exhaustive` it ranks 8.
+// It is a RETRIEVABILITY gap, not a semantic one.
+//
+// COST — A/B on the trained store, counting resonate calls directly: the tier
+// adds ZERO exhaustive calls.  F-prefix already made exactly one (for the
+// substitution bridge) and returned silence; with the tier it makes the same one
+// and answers.  Battery: F 0% → 25%, overall 76.2% → 78.6%, `0 weak`, all three
+// honest-silence probes still silent, median latency 0.63s → 0.57s.
+//
+// Unlike test/69, a POSITIVE fixture IS constructible here: the mechanism keys
+// on literal byte containment, not on corpus rarity, and rarity is the signal
+// that collapses at fixture scale.
+//
+// The mechanism has NO notion of text: no separator, no character class, no
+// "word".  Its only structural quantity is W, the river's grouping window.  So
+// these fixtures are readable prose only for the reader's benefit -- every
+// assertion below is about bytes and geometry.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+import { prefixCompletion } from "../dist/src/mind/prefix-completion.js";
+
+const enc = (s) => new TextEncoder().encode(s);
+const dec = new TextDecoder();
+
+async function fixture(train) {
+  const mind = new Mind({
+    seed: 1,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  await mind.ingest(train);
+  return mind;
+}
+/** Call the tier the way recall does: the query plus a ranked hit list. */
+async function tier(mind, q, k = 64) {
+  const hits = await mind.store.resonate(mind.perceive(q).v, k);
+  return prefixCompletion(mind, enc(q), hits.map((h) => h.id));
+}
+
+const FACTS = [
+  "The capital of France is Paris.",
+  "The capital of Japan is Tokyo.",
+  "The capital of Germany is Berlin.",
+];
+
+test("1. the sole form opening with the query is completed by its remainder", async () => {
+  const m = await fixture(FACTS);
+  const hit = await tier(m, "The capital of France is");
+  assert.notEqual(hit, null, "the trained form opens with the query");
+  assert.equal(dec.decode(hit.form), "The capital of France is Paris.");
+  await m.store.close();
+});
+
+test("2. AMBIGUITY is refused — the prefix trap", async () => {
+  // Two trained forms open with the same words and continue differently.  The
+  // corpus does not say which completion the asker means, so neither is
+  // licensed.  This is the documented prefix trap, and it is real — it simply
+  // does not hold for EVERY prefix, which is what test 1 pins.
+  const m = await fixture([
+    "The capital city is Paris.",
+    "The capital city is Berlin.",
+  ]);
+  assert.equal(await tier(m, "The capital city is"), null);
+  await m.store.close();
+});
+
+test("3. the same completion via two forms is ONE answer, not an ambiguity", async () => {
+  // Uniqueness is judged on the remainder BYTES, not on the candidate id.
+  const m = await fixture([
+    "The capital of France is Paris.",
+    "The capital of France is Paris.",
+  ]);
+  const hit = await tier(m, "The capital of France is");
+  assert.notEqual(hit, null);
+  assert.equal(dec.decode(hit.form), "The capital of France is Paris.");
+  await m.store.close();
+});
+
+test("4. a SUB-QUANTUM continuation is refused", async () => {
+  // Observed on the trained store: `What is the capital of France?` opens a
+  // trained `What is the capital of France??`, which continues by ONE byte.
+  // Below W the continuation is sub-quantum -- the fold groups nothing from it
+  // -- and voicing it is the degenerate reply of the battery's section M.
+  // The bar is the grouping window, not a punctuation class.
+  const m = await fixture(["What is the capital of France??"]);
+  assert.equal(await tier(m, "What is the capital of France?"), null);
+  await m.store.close();
+});
+
+test("5. a query no trained form opens with is refused", async () => {
+  const m = await fixture(FACTS);
+  for (
+    const q of [
+      "The capital of Zamunda is",
+      "xyzzy plugh quux",
+      "Paris is the capital of",
+    ]
+  ) {
+    assert.equal(await tier(m, q), null, q);
+  }
+  await m.store.close();
+});
+
+test("6. a query that is a whole trained form is not 'completed' by itself", async () => {
+  // An exact form has an EMPTY remainder, which no guard should let through —
+  // and the exact tiers own that query anyway.
+  const m = await fixture(FACTS);
+  assert.equal(await tier(m, "The capital of France is Paris."), null);
+  await m.store.close();
+});
+
+test("7. the tier is deterministic and side-effect free", async () => {
+  const m = await fixture(FACTS);
+  const q = "The capital of France is";
+  const before = m.store.nodeCount();
+  const a = await tier(m, q);
+  const b = await tier(m, q);
+  assert.equal(dec.decode(a.form), dec.decode(b.form));
+  assert.equal(a.id, b.id);
+  assert.equal(
+    m.store.nodeCount(),
+    before,
+    "the tier must not intern anything",
+  );
+  await m.store.close();
+});
+
+test("9. a form that continues past the read bound vetoes", async () => {
+  // Reads are bounded (query.length * W).  A candidate that opens with the
+  // query but SATURATES the read continues out of sight, so it is a standing
+  // disagreement -- NOT something to skip.  Skipping it is what manufactures a
+  // fragment: it removes the only evidence contradicting an interior fold node
+  // that happens to fit under the cap.
+  const q = "The capital of France is";
+  const long = q + " Paris, and the country's largest city by a wide margin, " +
+    "a global centre for art, fashion, gastronomy and culture.";
+  assert.ok(long.length > q.length * 4, "the fixture must exceed the cap");
+  const m = await fixture([long]);
+  assert.equal(await tier(m, q), null);
+  await m.store.close();
+});
+
+test("8. end to end, the fixture's own trained forms still answer", async () => {
+  // The tier sits on the refusal path; it must not disturb normal grounding.
+  const m = await fixture([
+    "What is the capital of France?",
+    "The capital of France is Paris.",
+  ]);
+  const r = await m.respond("What is the capital of France?");
+  assert.ok(r.bytes.length > 0, "a trained question still answers");
+  await m.store.close();
+});