@hviana/sema 0.4.7 → 0.5.1

package/src/mind/types.ts

@@ -20,23 +20,18 @@ import type {
   Site,
 } from "./graph-search.js";
 import type { Rationale } from "./rationale.js";
-import type { Grid, StableFold } from "../geometry.js";
+import type { ContentFold, Grid } from "../geometry.js";
 
-/** One {@link MindContext._depositTrees} entry — see that field's doc. */
+/** One {@link MindContext._depositTrees} entry — see that field's doc.
+ *
+ *  A PURE WORK CACHE.  It carries the already-folded content segments of a
+ *  deposited stream so a longer stream sharing its byte prefix can skip
+ *  refolding them.  It holds no turn boundaries and no continuation proof
+ *  because the deposit fold imposes nothing: reuse is bit-identical to a cold
+ *  fold, so a hit can only save time, never change a tree. */
 export interface DepositCacheEntry {
-  /** Turn boundaries accumulated over this content's deposit chain —
-   *  strictly increasing proper offsets, each a previously-deposited
-   *  whole-context length.  Empty for a first-seen (single-turn) input. */
-  boundaries: number[];
-  /** Stable-prefix segment folds (grown-context inputs only). */
-  stable?: StableFold;
-  /** The continuation bytes this ctxInput was paired with in ingestPair, if
-   *  any — the ONLY thing that makes a later, longer ctxInput a genuine next
-   *  TURN of the same conversation rather than an unrelated fact that
-   *  happens to share this one's byte prefix (e.g. "2+2" vs. "2+2=5").  A
-   *  later deposit only takes this entry as its stable-prefix `prev` when
-   *  its own suffix bytes-equal this exactly. */
-  nextBytes?: Uint8Array;
+  /** The plain content fold's reusable segment state. */
+  content: ContentFold;
 }
 import { bytesEqual, concatBytes, indexOf } from "../bytes.js";
 import { dominates } from "../geometry.js";
@@ -336,9 +331,23 @@ export interface MindContext extends GraphSearchHost {
   /** Subtree-resolution cache: Sema node → its store id and byte length.
    *  Populated by {@link foldTree} during inference; checked before
    *  walking children.  When a conversation's pyramid reuses prefix
-   *  subtrees, this cache lets {@link recognise} skip them entirely —
-   *  O(suffix) instead of O(context).  Mind-lifetime (WeakMap keys are
-   *  the Sema objects the pyramid keeps alive). */
+   *  subtrees, this cache names them without a store probe.  It does NOT let
+   *  {@link recognise} skip them: recognise walks with a `visit` callback and
+   *  emits its sites from it, so a skipped descent would mean fewer sites on
+   *  a warm cache than a cold one.  foldTree short-circuits only for
+   *  visitor-less walks (O(suffix) there); a visiting walk stays O(context)
+   *  and banks the elided probes.  Mind-lifetime (WeakMap keys are the Sema
+   *  objects the pyramid keeps alive).
+   *
+   *  THAT REUSE IS A PRECONDITION, NOT A GIVEN: the keys are node IDENTITIES,
+   *  so it hits only while the conversation's fold hands back the SAME Sema
+   *  objects for the unchanged prefix.  `_growContext` rebuilt the whole tree
+   *  with `bytesToTree` on every turn, so every key was fresh and this cache
+   *  could not hit even once — the O(suffix) claim above described an
+   *  intention rather than the code.  It now grows the context through
+   *  {@link stablePrefixFoldIncremental}, which reuses each already-folded
+   *  segment: measured over four turns, turn 4 shared 69 of its 95 nodes with
+   *  turn 3 (26 new ≈ the new turn's own size). */
   _resolvedSubtrees: WeakMap<Sema, { id: number; len: number }> | null;
   /** Completed assistant-turn byte spans in the current cumulative query.
    *  Empty for ordinary respond(); response-scoped structural context for
@@ -436,49 +445,100 @@ export function segRestatesQuery(
  *  (lo/hi) decision and the final concatenation: it is stale, not a second
  *  answer, but the OTHER spans a derivation chose are independent evidence
  *  and must not be discarded along with it. */
-export function liftAnswer(
+/** The spans {@link liftAnswer} actually concatenates, in order — the answer
+ *  before it is joined.  Exposed so a caller can ask what the lifted answer is
+ *  MADE OF without re-deriving the selection: in particular how much of it is
+ *  SCAFFOLDING (a `rec: false` span — query bytes carried through verbatim
+ *  because nothing explained them, the same spans the liftAnswer trace labels
+ *  "scaffolding" rather than "chosen").
+ *
+ *  That quantity is load-bearing for the grounding decision.  Two candidates
+ *  can leave the SAME number of query bytes unaccounted and therefore grade
+ *  identically, while one of them pads its answer with those bytes and the
+ *  other does not — measured on test/22's two-fact chain, cover and recall
+ *  both graded 11001 with 11 bytes unexplained, and cover won the tie only on
+ *  consideration order, answering "The capital of France is Paris famous for"
+ *  where recall had crossed the hop.  Carrying an unexplained span into the
+ *  answer is strictly weaker than not explaining it: it manufactures fluency
+ *  out of the asker's own words.  See the tie-break in pipeline.ts. */
+export function liftAnswerParts(
   segs: Seg[],
   queryLen: number,
   query: Uint8Array,
   W: number,
-): Uint8Array | null {
+): Seg[] {
   const restated = segs.map((s) => segRestatesQuery(s, query, queryLen, W));
   const recognised: number[] = [];
   for (let k = 0; k < segs.length; k++) {
     if (segs[k].rec && !restated[k]) recognised.push(k);
   }
-  if (recognised.length === 0) return null;
+  if (recognised.length === 0) return [];
 
   if (recognised.length === 1) {
     const s = segs[recognised[0]];
-    // A COMPUTED span's query-side width is operand digit-count, not
-    // evidence of how much of the query's meaning it accounts for — the
-    // half-dominance check below (built for a genuinely RECOGNISED learned
-    // form) is not a valid framing signal for it (see the `computed` field
-    // doc on Seg/GItem): "1000 - 421" outweighs "what is …?" by width only
-    // because the operands are big, not because the framing matters less.
-    // A LITERAL PREFIX before a computed span is unambiguous framing
-    // regardless of width — an arithmetic expression is never itself
-    // preceded by more literal computed content, so anything literal before
-    // it is question wording ("what is ", "compute ") to lift clear of.
-    // With no prefix (s.i === 0) the span is judged by the ordinary
-    // half-dominance rule below, which already correctly keeps a short
-    // trailing glue byte ("2+2." → "4.", the span dominates a 4-byte query).
-    if (s.computed && s.i > 0) return s.bytes;
+    if (s.computed && s.i > 0) return [s];
     if (dominates(s.j - s.i, queryLen)) {
-      return concatBytes(
-        segs.filter((_, k) => !restated[k]).map((x) => x.bytes),
-      );
+      return segs.filter((_, k) => !restated[k]);
     }
-    return s.bytes;
+    return [s];
   }
   const lo = recognised[0];
   const hi = recognised[recognised.length - 1];
-  return concatBytes(
-    segs.slice(lo, hi + 1).filter((_, k) => !restated[lo + k]).map((x) =>
-      x.bytes
-    ),
-  );
+  return segs.slice(lo, hi + 1).filter((_, k) => !restated[lo + k]);
+}
+
+/** The SCAFFOLDING byte count of a lifted answer: how many of its bytes come
+ *  from spans nothing recognised (see {@link liftAnswerParts}).
+ *
+ *  ONLY RUNS OF AT LEAST ONE RIVER WINDOW COUNT.  Not all carried-through
+ *  bytes are a failure to explain: a period, a question mark, the space
+ *  between two fused topics are GLUE — they belong to the answer's surface,
+ *  and dropping them to look better-derived would be a worse answer, not a
+ *  more honest one.  A substantive phrase the derivation never explained
+ *  ("famous for") is a different claim entirely.
+ *
+ *  W is the line between them, and it is the same line the rest of the mind
+ *  already draws: below one river window byte overlap is chance, not evidence
+ *  (see identityBar, the bridge's attestedQ, and recognition's site floor).
+ *  Counting every scaffolding byte instead — which is what this did first —
+ *  made punctuation preservation lose a tie it should win, and test/00's
+ *  "period preserved" / "question mark preserved" caught it immediately. */
+export function liftedScaffolding(
+  segs: Seg[],
+  queryLen: number,
+  query: Uint8Array,
+  W: number,
+): number {
+  // MEASURED PER CONTIGUOUS RUN, not per span.  A PASS span is one BYTE — the
+  // cover charges unrecognised bytes individually — so asking whether a single
+  // span reaches W would find no run ever, whatever the query.  " famous for"
+  // arrives as eleven one-byte spans in a row and is one eleven-byte run.
+  let n = 0;
+  let run = 0;
+  const close = () => {
+    if (run >= W) n += run;
+    run = 0;
+  };
+  for (const s of liftAnswerParts(segs, queryLen, query, W)) {
+    if (s.rec) close();
+    else run += s.bytes.length;
+  }
+  close();
+  return n;
+}
+
+export function liftAnswer(
+  segs: Seg[],
+  queryLen: number,
+  query: Uint8Array,
+  W: number,
+): Uint8Array | null {
+  // ONE selection rule, in {@link liftAnswerParts} — this is its join.  The
+  // two used to be separate copies of the same lo/hi/restated reasoning, which
+  // is exactly how an answer and the accounting OF that answer drift apart.
+  const parts = liftAnswerParts(segs, queryLen, query, W);
+  if (parts.length === 0) return null;
+  return concatBytes(parts.map((x) => x.bytes));
 }
 
 /** The CHANGED NODES of a freshly-perceived `tree` against the node ids a previous

package/src/store.ts

@@ -325,6 +325,10 @@ export interface Store {
   contentLen(id: NodeId, cap?: number): number;
   findLeaf(bytes: Uint8Array): NodeId | null;
   findBranch(kids: NodeId[]): NodeId | null;
+  /** {@link findBranch} for a run of single-byte leaves, addressed by the raw
+   *  bytes — the allocation-free probe span scanners use.  Optional: a store
+   *  without it is simply probed through `findBranch`. */
+  findFlatBranch?(bytes: Uint8Array): NodeId | null;
   /** The branch nodes that list `id` among their children — the reverse of
    *  `get(id).kids`. Lets the structural DAG be climbed upward, from a
    *  recognised fragment to the larger learned forms that contain it. */
@@ -1269,6 +1273,27 @@ export abstract class AbstractStore implements Store {
     return id;
   }
 
+  /** {@link findBranch} for a run of SINGLE-BYTE leaves, addressed by the
+   *  bytes themselves — no kid array, no key string, no copy.
+   *
+   *  A flat branch stores its children as {@link flatKidsBytes}, and that
+   *  encoding is the identity on single-byte leaves: kid id −(b+1) IS byte b.
+   *  So for such a run the kid array and the byte span are the same object in
+   *  two spellings, and `findBranch(leafIds.slice(i, j))` and this call are
+   *  the same lookup — except that the array path allocates the slice, then
+   *  `kids.join(",")`, then the flat bytes, all O(span), for a probe whose
+   *  answer is usually "no".  The bloom filter behind `_dbFindBranchByLeaf`
+   *  answers most of those with no I/O at all, so the allocations dominated.
+   *
+   *  Pass a subarray: it is a view, so a caller scanning spans of a query
+   *  allocates nothing per probe.  Deliberately NOT memoized — its callers
+   *  probe many spans that miss, and a key string per probe is the cost this
+   *  exists to remove. */
+  findFlatBranch(bytes: Uint8Array): NodeId | null {
+    if (this.meter) this.meter.branchLookups++;
+    return this._dbFindBranchByLeaf(hashOf(bytes), bytes);
+  }
+
   findBranch(kids: NodeId[]): NodeId | null {
     if (this.meter) this.meter.branchLookups++;
     const key = kids.join(",");

package/test/13-conversation.test.mjs

@@ -18,6 +18,19 @@
 // accumulated bytes at inference.  The Conversation API tracks turn-boundary
 // offsets explicitly so no separator character is needed — the geometry never
 // inspects content to find turn boundaries.
+//
+// "NO SEPARATOR IS NEEDED" ≠ "A SEPARATOR IS A PROBLEM".  This file joins its
+// turns with nothing; example/train_base.ts joins its oasst2 turns with "\n".
+// Both are correct, and neither is a convention the other has to match: a
+// separator is CORPUS CONTENT, folded like any other byte, while a turn
+// boundary is an OFFSET the API carries beside the bytes.  A harness replaying
+// a "\n"-joined corpus simply passes `"\n" + turnText` to addTurn and gets the
+// trained byte stream back exactly.  See Mind.addTurn's "ON SEPARATORS" note
+// for the full statement — it exists because a review read the mismatch
+// between this file's join and the trainer's as an architectural
+// incompatibility, and it is not one.  If you are comparing this harness to a
+// corpus and getting poor recall, check that you are feeding the bytes that
+// were actually trained before concluding anything about the engine.
 // ─────────────────────────────────────────────────────────────────────────
 
 import { test } from "node:test";

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