@hviana/sema 0.8.1 → 0.8.3

package/test/100-complete-grounding-trace.test.mjs

@@ -0,0 +1,109 @@
+// 100-complete-grounding-trace.test.mjs — a declared-complete grounding SAYS
+// SO in the rationale.
+//
+// THE GAP THIS CLOSES.  `pipeline.ts` ends the derivation when the winning
+// grounding carries `MechanismResult.complete` — the mechanism's own claim that
+// the query IS a stored context, so its continuation is the whole read-out and
+// a further pivot could only chain PAST the fact that produced the answer.  The
+// decision was correct and SILENT: no step, no note.  A reader of the rationale
+// therefore could not tell
+//
+//     "the chain stopped because the query WAS the context"   (complete)
+//
+// apart from
+//
+//     "nothing followed"                                      (no continuation)
+//
+// which are different claims about the same answer.  AGENTS §6 makes that an
+// instrumentation defect rather than a documentation gap: a bound that
+// truncates must be reportable AT THE POINT it truncates, through the one
+// surface that already exists.
+//
+// WHAT IS PINNED HERE.
+//   1. the stop is REPORTED (step `completeGrounding`) when it happens;
+//   2. the stop is REAL — the post-grounding extension did not run (no pivot or
+//      forward-absorb step), so the report cannot rot into a lie;
+//   3. the report does NOT appear for an ordinary grounding, so it names a
+//      decision rather than decorating every response.
+//
+// The fixture is test/76's CARRIED frame: the continuation quotes its filler
+// (`Run gcc <X>`), which is the shape the reference mechanism binds and
+// declares complete.
+
+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 CARRIED = [
+  ["How do I compile hello.c?", "Run gcc hello.c"],
+  ["How do I compile server.c?", "Run gcc server.c"],
+  ["How do I compile parser.c?", "Run gcc parser.c"],
+];
+
+/** The frame fixture — the same one test/76 pins the binding on. */
+async function frame() {
+  const m = new Mind({ seed: 7, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest(CARRIED);
+  return m;
+}
+
+/** A grounding that is NOT declared complete: one plain learnt edge. */
+async function plainChain() {
+  const m = new Mind({ seed: 7, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest([["Eva director", "The director of Eva is Gustaf Molander."]]);
+  return m;
+}
+
+const moves = (steps) => steps.map((s) => s.mechanism.at(-1));
+
+test("a binding that declares itself complete reports the stop", async () => {
+  const m = await frame();
+  const steps = [];
+  await m.respondText("How do I compile main.c?", (s) => steps.push(s));
+
+  const stop = steps.find((s) => s.mechanism.at(-1) === "completeGrounding");
+  assert.ok(stop, "the rationale must report the declared-complete stop");
+  assert.match(
+    stop.note,
+    /declared complete/,
+    "the note must carry the CLAIM, not a description of the answer",
+  );
+});
+
+test("the reported stop is real: the extension did not run", async () => {
+  const m = await frame();
+  const steps = [];
+  const answer = await m.respondText(
+    "How do I compile main.c?",
+    (s) => steps.push(s),
+  );
+
+  // The binding spliced the asker's referent (behaviour under test, asserted
+  // WITHOUT a trace below — a trace can change an answer, so the step and the
+  // bytes are pinned separately).
+  assert.ok(answer.length > 0, "the binding must answer");
+  const seen = moves(steps);
+  assert.equal(
+    seen.includes("pivotStep") || seen.includes("absorbForward"),
+    false,
+    "a complete grounding must not be extended",
+  );
+});
+
+test("the non-traced answer is the spliced one", async () => {
+  const m = await frame();
+  const answer = await m.respondText("How do I compile main.c?");
+  assert.equal(answer.replace(/\0+/g, "").trim(), "Run gcc main.c");
+});
+
+test("an ordinary grounding reports no complete-grounding stop", async () => {
+  const m = await plainChain();
+  const steps = [];
+  await m.respondText("Eva director", (s) => steps.push(s));
+  assert.equal(
+    moves(steps).includes("completeGrounding"),
+    false,
+    "the step names a decision, not every response",
+  );
+});

package/test/101-alignment-gap-bound.test.mjs

@@ -0,0 +1,106 @@
+// 101-alignment-gap-bound.test.mjs — the alignment's gap bound SAYS SO when it
+// bites.
+//
+// THE GAP THIS CLOSES.  `alignAround` matches a query against a stored context
+// by sweeping for the next common run of ≥ W bytes, with each side's gap
+// bounded by `chainReach(W)` = W².  When the sweep ends with material still
+// unmatched on BOTH sides, the alignment stopped because of that BOUND — and
+// nothing reported it: `match.ts` emitted no trace at all.  A reader of the
+// rationale therefore saw a substituted answer (the frame filled with ANOTHER
+// instance's filler) with no way to tell that the answer's own span had been
+// refused by a cap.
+//
+// MEASURED BOUNDARY (W = 4, cap = 16).  Against a learned
+// `Book a table at <filler> tonight.` → `Your table at <filler> is booked.`
+// frame, a NOVEL filler binds while it fits the cap and is replaced by a stored
+// instance's filler once it does not:
+//
+//     filler 7 B  → answer quotes the asker's filler   (bound)
+//     filler 12 B → answer quotes the asker's filler   (bound)
+//     filler 18 B → answer carries ANOTHER filler      (substituted)
+//     filler 30 B → answer carries ANOTHER filler      (substituted)
+//
+// THIS FILE PINS THE REPORT, not the substitution: the step must exist and must
+// carry the derived cap, so the bound is auditable at the point it truncates
+// (AGENTS §6).  The substitution itself is the scope defect a later lot fixes;
+// when it is fixed, this file's behavioural control (a filler inside the cap is
+// quoted back) stays true and the report stays reachable.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { alignAround } from "../dist/src/mind/match.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+
+const WORDS =
+  ("alpha bravo charlie delta echo foxtrot golf hotel india juliet kilo lima " +
+    "mike november oscar papa quebec romeo sierra tango uniform victor whiskey " +
+    "xray yankee zulu amber bronze copper dahlia ember fjord gossamer harbour " +
+    "indigo jasmine kestrel lantern marigold nectar opal pewter quartz ripple " +
+    "saffron thistle umber violet willow xenon yarrow").split(" ");
+
+const short = (i) => `${WORDS[i % 50]}${i}`;
+const long = (i) =>
+  `${WORDS[i % 50]} ${WORDS[(i * 3) % 50]} ${WORDS[(i * 7) % 50]} street ${i}`;
+
+/** The frame whose continuation quotes its filler, with mixed filler widths. */
+async function frame(n = 60, opts = {}) {
+  const store = new SQliteStore({ path: ":memory:", D: 1024 });
+  const mind = new Mind({ seed: 7, store, ...opts });
+  const pairs = [];
+  for (let i = 0; i < n; i++) {
+    const f = i % 3 === 0 ? long(i) : short(i);
+    pairs.push([
+      `Book a table at ${f} tonight.`,
+      `Your table at ${f} is booked.`,
+    ]);
+  }
+  await mind.ingest(pairs);
+  return { store, mind };
+}
+
+/** A novel filler of exactly `len` bytes, never ingested. */
+const novel = (len) => "zephyr quartz lantern ".repeat(3).slice(0, len).trim();
+
+// THE LAW'S ASSERTION, straight on the aligner.  There is no bound to report
+// any more: the sweep's work is proportional to the bytes a run spans, so a
+// divergence far past the old arity bound (chainReach(W) = 16) is simply
+// bridged, on both sides, by finding the next common run.
+test("a divergence far past the old arity bound is bridged, not truncated", () => {
+  const enc = new TextEncoder();
+  const head = "the common head of the frame ";
+  const tail = " and the common tail of the frame";
+  const q = enc.encode(head + "a".repeat(60) + tail);
+  const c = enc.encode(head + "b".repeat(60) + tail);
+  const at = head.length - 1; // the seed: the shared head's own boundary
+  const { matched, gaps } = alignAround(
+    { space: { maxGroup: 4 } },
+    q,
+    c,
+    at,
+    at,
+  );
+  assert.equal(
+    matched.length,
+    2,
+    "both common runs must be found: " + JSON.stringify(matched),
+  );
+  assert.equal(gaps.length, 1, "with exactly one substitution between them");
+  const g = gaps[0];
+  assert.ok(
+    g.qe - g.qs >= 60 && g.ce - g.cs >= 60,
+    "the substitution's extent is the pair's own: " + JSON.stringify(g),
+  );
+});
+
+test("control: a filler inside the cap is quoted back, and the fixture is live", async () => {
+  const filler = novel(12);
+  const { mind } = await frame();
+  const answer = (await mind.respondText(
+    `Book a table at ${filler} tonight.`,
+  )).replace(/\0+/g, "").trim();
+  assert.ok(
+    answer.includes(filler),
+    "inside the cap the frame binds the asker's own filler",
+  );
+});

package/test/102-production-composes-at-scale.test.mjs

@@ -0,0 +1,110 @@
+// 102-production-composes-at-scale.test.mjs — a produced composite is
+// decomposed by ITS OWN TREE, at every corpus size.
+//
+// THE GAP THIS CLOSES.  `recompleteNode` re-covers a node an edge produced, and
+// it seeds that re-cover from `recogniseSpan(bytes)` filtered to the node's own
+// kids.  Above the `atomIsHub` flip the recognition of a produced span returns
+// the WHOLE and deliberately suppresses its atoms (the off-boundary
+// suppression), so the kid filter admitted nothing and the chain ended at the
+// intermediate composite.  Measured on
+//
+//     seed → "p q" → (p→r, q→s) → "r s" → "m n"
+//
+// below the flip it reached "m n" with `fuse`+`recompose`; above it stopped at
+// "p q" with neither, and the trace showed `recognise("p q") ⇒ form "p q"`
+// alone.  The node's own kids ARE its decomposition — the machine that built
+// the composite stated its parts — so they seed the re-cover directly, and a
+// kid recognition already offers is skipped (below the flip the seed set is
+// byte-identical to what it was).
+//
+// WHY THE FIXTURE CROSSES THE FLIP.  The property was never false below it: the
+// whole point is that composition must not depend on corpus size.  The flip sits
+// between N = 3 658 (composes) and N = 4 174 (did not), so the fixture ingests
+// 4 400 filler pairs, exactly as test/99 does for the join.
+//
+// WHAT IS PINNED.
+//   1. the answer above the flip EQUALS the answer below it (scale invariance,
+//      asserted as one comparison rather than two magic strings);
+//   2. above the flip the composition is reported — `fuse` and `recompose`
+//      appear in the rationale, so the fix is visible in the rationale and not
+//      just in the bytes;
+//   3. the chain still ends where the graph ends ("m n"), so the fix does not
+//      invent depth.
+
+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 CHAIN = [
+  ["seed", "p q"],
+  ["p", "r"],
+  ["q", "s"],
+  ["r s", "m n"],
+];
+
+const WORDS =
+  ("alpha bravo charlie delta echo foxtrot golf hotel india juliet kilo lima " +
+    "mike november oscar papa quebec romeo sierra tango uniform victor whiskey " +
+    "xray yankee zulu amber bronze copper dahlia ember fjord gossamer harbour " +
+    "indigo jasmine kestrel lantern marigold nectar opal pewter quartz ripple " +
+    "saffron thistle umber violet willow xenon yarrow").split(" ");
+
+/** One store, ingested past the atomIsHub flip (N > 4 174). */
+async function atScale(fillers = 4400) {
+  const store = new SQliteStore({ path: ":memory:", D: 1024 });
+  const mind = new Mind({ seed: 7, store });
+  const w = (i, n) => WORDS[(i * 7 + n * 13) % WORDS.length];
+  await mind.ingest([
+    ...CHAIN,
+    ...Array.from({ length: fillers }, (_, i) => [
+      `${w(i, 1)} ${w(i, 2)} ${w(i, 3)} ${i}`,
+      `${w(i, 4)} ${w(i, 5)} ${w(i, 6)} ${w(i, 7)} ${i}`,
+    ]),
+  ]);
+  return { store, mind };
+}
+
+/** The same chain BELOW the flip — the behaviour the scaled store must match. */
+async function belowFlip() {
+  const store = new SQliteStore({ path: ":memory:", D: 1024 });
+  const mind = new Mind({ seed: 7, store });
+  await mind.ingest(CHAIN);
+  return { store, mind };
+}
+
+const text = (b) => b.replace(/\0+/g, "").trim();
+
+test("a produced composite composes identically below and above the flip", async () => {
+  const small = await belowFlip();
+  const big = await atScale();
+  const deep = text(await big.mind.respondText("seed"));
+  const shallow = text(await small.mind.respondText("seed"));
+
+  // The property: depth is a fact about the graph, not about the corpus size.
+  assert.equal(deep, shallow, "scale must not change how deep the chain goes");
+  assert.equal(
+    deep,
+    "m n",
+    "and the graph ends at the composite's continuation",
+  );
+});
+
+test("above the flip the composition is reported, not just performed", async () => {
+  const { mind } = await atScale();
+  const steps = [];
+  await mind.respondText("seed", (s) => steps.push(s));
+  const moves = new Set(steps.map((s) => s.mechanism.at(-1)));
+  assert.ok(moves.has("fuse"), "the fused pair must appear in the rationale");
+  assert.ok(
+    moves.has("recompose"),
+    "and the recomposition that names the deeper form",
+  );
+});
+
+test("the fix does not invent depth: the chain still ends at the graph's end", async () => {
+  const { mind } = await atScale();
+  const answer = text(await mind.respondText("seed"));
+  assert.notEqual(answer, "r s", "it must not stop at the parts it followed");
+  assert.notEqual(answer, "z", "nor reach a form the graph never licensed");
+});

package/test/103-alignment-gap-budget.test.mjs

@@ -0,0 +1,89 @@
+// 103-alignment-gap-budget.test.mjs — a learned frame's slot is bounded by the
+// PAIR, not by the write side's arity; the WORK is bounded by a declared budget.
+//
+// THE GAP THIS CLOSES.  `alignAround` bounded each side's gap by
+// `chainReach(W)` = W².  A learnt frame whose slot is longer than that could not
+// be aligned, so the frame binding produced no candidate and a cheaper
+// mechanism answered instead — measured on a
+// `Book a table at <filler> tonight.` → `Your table at <filler> is booked.`
+// frame: at 18, 24, 30 and 36 bytes `bindReference` reported the cap and the
+// answer came back carrying ANOTHER instance's filler ("bravo1").
+//
+// Bounding the work instead is the fix, and the two questions are genuinely
+// different: the gap's LENGTH is how far the two byte strings actually diverge
+// (a fact about the pair), while the WORK is how many (queryGap, contextGap)
+// pairs the sweep examines, which is what a cost bound must limit — reaching a
+// gap of size G costs about G²/2 pairs, so a length bound is a work bound only
+// by accident, and at the wrong scale.
+//
+// WHAT IS PINNED: the asker's OWN filler comes back.  The old defect used to be
+// reproduced by injecting a tiny budget; that knob is gone because there is no
+// budget any more — the sweep indexes the context's windows and walks the
+// query's, so its work is proportional to the bytes a run spans and its reach is
+// the bytes' own.  There is nothing to make artificially small, and nothing that
+// silently drops a far continuation:
+//
+//     filler 18/20/24 B   → the asker's own filler   (the pair's own extent spans it)
+//
+// Beyond what the frame's own instances can span (measured: from ~30 bytes) a
+// DIFFERENT cause takes over — the frame inventory drops to a single instance,
+// and the licence correctly refuses to voice from one exemplar.  That is the
+// reference mechanism's own gate, not this bound, and it is not asserted here.
+
+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 WORDS =
+  ("alpha bravo charlie delta echo foxtrot golf hotel india juliet kilo lima " +
+    "mike november oscar papa quebec romeo sierra tango uniform victor whiskey " +
+    "xray yankee zulu amber bronze copper dahlia ember fjord gossamer harbour " +
+    "indigo jasmine kestrel lantern marigold nectar opal pewter quartz ripple " +
+    "saffron thistle umber violet willow xenon yarrow").split(" ");
+
+const short = (i) => `${WORDS[i % 50]}${i}`;
+const long = (i) =>
+  `${WORDS[i % 50]} ${WORDS[(i * 3) % 50]} ${WORDS[(i * 7) % 50]} street ${i}`;
+
+/** A frame whose continuation quotes its filler, plus the Mind options. */
+async function frame(opts = {}, n = 60) {
+  const store = new SQliteStore({ path: ":memory:", D: 1024 });
+  const mind = new Mind({ seed: 7, store, ...opts });
+  const pairs = [];
+  for (let i = 0; i < n; i++) {
+    const f = i % 3 === 0 ? long(i) : short(i);
+    pairs.push([
+      `Book a table at ${f} tonight.`,
+      `Your table at ${f} is booked.`,
+    ]);
+  }
+  await mind.ingest(pairs);
+  return { store, mind };
+}
+
+/** A novel filler of exactly `len` bytes, never ingested. */
+const novel = (len) => "zephyr quartz lantern ".repeat(4).slice(0, len).trim();
+
+const answer = async (mind, filler) =>
+  (await mind.respondText(`Book a table at ${filler} tonight.`))
+    .replace(/\0+/g, "").trim();
+
+test("the default budget spans it, and the answer quotes the ASKER's filler", async () => {
+  const filler = novel(24);
+  const { mind } = await frame();
+  const got = await answer(mind, filler);
+  assert.ok(
+    got.includes(filler),
+    "the pair's own extent must be reachable: the asker's bytes, not the corpus's",
+  );
+});
+
+test("an 18-byte slot is spanned too — the boundary moved off W²", async () => {
+  const { mind } = await frame();
+  for (const len of [18, 20, 24]) {
+    const filler = novel(len);
+    const got = await answer(mind, filler);
+    assert.ok(got.includes(filler), `${len} B must be spanned`);
+  }
+});

package/test/104-composition-is-reported.test.mjs

@@ -0,0 +1,90 @@
+// 104-composition-is-reported.test.mjs — every composition of an answer is
+// VISIBLE in the rationale.
+//
+// THE GAP THIS CLOSES.  `joinWithBridge` (resonance.ts) is the composition step
+// every out-of-search assembly shares: it asks the corpus for a learnt
+// connector between two pieces, and on a miss it joins them BARE and emits a
+// `bridgeMiss` step — never silent.  CAST's projection-to-continuation join
+// bypassed it with a bare `concat2`, and that single bypass is the whole of the
+// gluing the study measured: `"Steel is hard"` + `"wet"` came back as
+// `"hardwet"`, `"eva director father"` + `"The father of Gustaf Molander…"` as
+// `"fatherThe"`, the real store's `"Dutch.na"`.  The house rule is NOT "never
+// join bare" — it is "joined bare, and REPORTED", so that a reader of the
+// rationale can see the seam and its pieces.  The bypass made the seam
+// invisible, which is why the gluing survived an audit that read rationales.
+//
+// WHAT IS PINNED.  On the fixture below the join IS a miss (this tiny corpus
+// attests no connector between the two pieces), so the step must exist and must
+// name BOTH pieces.  The answer must still USE the followed content — test/39
+// pins that the follow is unaffected, and a fix that refuses the join instead
+// of reporting it would silently drop the evidence.
+
+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";
+
+/** test/39's corpus: a projection that must follow onto genuinely new content. */
+async function fixture() {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store });
+  await mind.ingest([
+    ["Ice is cold", "cold"],
+    ["Fire is hot", "hot"],
+    ["Steel is hard", "hard"],
+    ["Water is wet", "wet"],
+    ["Ice is cold", "Water is wet"],
+    ["Something else entirely", "Water is wet"],
+  ]);
+  return mind;
+}
+
+const text = (resp) => new TextDecoder().decode(resp.bytes).replace(/\0+/g, "");
+
+test("a composed seam is reported: the miss names its two pieces", async () => {
+  const mind = await fixture();
+  const steps = [];
+  const answer = text(
+    await mind.respond("What if steel were cold?", (s) => steps.push(s)),
+  );
+
+  const misses = steps.filter((s) => s.mechanism.at(-1) === "bridgeMiss");
+  assert.ok(
+    misses.length > 0,
+    "the composition must be visible: the shared joiner reports a miss",
+  );
+  // The seam this lot exists for: the followed continuation is joined on.
+  // The INTERNAL seam — the join the mechanism itself made — names the two
+  // pieces as they were BEFORE the join: the projection and the followed
+  // continuation, side by side.  The answer-level assembly can only report the
+  // bytes it is handed, so this step is what makes the gluing auditable.
+  const internal = misses.some((s) => {
+    const parts = (s.inputs ?? []).map((i) => String(i.text));
+    return parts.some((t) => t.trim() === "wet") &&
+      parts.some((t) => t.includes("cold"));
+  });
+  assert.ok(internal, "the internal seam must be named, pre-join");
+  // Reporting, not refusing: the follow's content is still used (test/39).
+  assert.ok(
+    answer.includes("wet"),
+    `the followed content must still be used, got "${answer}"`,
+  );
+  await mind.store.close();
+});
+
+test("an in-search composition keeps its own trace (no report invented)", async () => {
+  // A query the corpus answers directly composes nothing that needs a bridge:
+  // cover's own steps are the report, so no `bridgeMiss` is fabricated.
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store });
+  await mind.ingest([["Ice is cold", "Water is wet"]]);
+  const steps = [];
+  await mind.respond("Ice is cold", (s) => steps.push(s));
+  const misses = steps.filter((s) => s.mechanism.at(-1) === "bridgeMiss");
+  assert.equal(misses.length, 0, "a stored answer is not a composition");
+  assert.ok(
+    steps.some((s) => s.mechanism.at(-1) === "ground"),
+    "and the derivation that did answer is still traced",
+  );
+  await mind.store.close();
+});

package/test/105-derive-through-reports-its-refusal.test.mjs

@@ -0,0 +1,137 @@
+// 105-derive-through-reports-its-refusal.test.mjs — the join rule says WHY it
+// did not join.
+//
+// THE GAP THIS CLOSES.  DIRECTION (the study's gap 2): a produced fact carries
+// the subject the query never wrote, and the query's remaining tail names the
+// relation to follow FROM it — but on the measured chain the rule never fired
+// and nothing said why.  `deriveThrough` yields no rule when it refuses, and a
+// rule that yields nothing leaves no step, so the gate was invisible from
+// outside: four fixtures changed the SYMPTOM (`"eva director country"` answered
+// with the intermediate KEY's bytes glued to the fact) without ever reaching the
+// rule.  AGENTS §6: a gap in instrumentation is a defect IN the instrumentation
+// — close it there, once, through the rationale, never a channel of its own.
+//
+// WHAT IS PINNED.
+//   1. the refusal is REPORTED, and it names the two pieces it tried (the fact
+//      and the tail), so the gate is readable in the rationale;
+//   2. it is reported ONLY for a form: the search asks this rule for every
+//      finalized out with a node, one-byte outs included — measured, 68
+//      refusals for a single 3-relation query, all letters.  W is the line the
+//      mind already draws between a chance overlap and a form, and a report per
+//      letter is noise, not instrumentation;
+//   3. a fully covered query (no tail) is not a refusal at all — the rule does
+//      not apply, and it must not be reported as a miss.
+
+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 F1 = "The director of Eva is Gustaf Molander.";
+const F2 = "The country of Gustaf Molander is Sweden.";
+const F3 = "The capital of Sweden is Stockholm.";
+
+/** The measured chain: every relation filed under BOTH the entity and its key,
+ *  which is how the real store files a fact (the study's round-3 dump). */
+async function chain() {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store });
+  await mind.ingest([
+    ["eva", F1],
+    ["eva director", F1],
+    ["gustaf molander", F2],
+    ["gustaf molander country", F2],
+    ["sweden", F3],
+    ["sweden capital", F3],
+  ]);
+  return mind;
+}
+
+const misses = (steps) =>
+  steps.filter((s) => s.mechanism.at(-1) === "deriveThroughMiss");
+
+test("the join's refusal is reported, naming the candidate and tail it tried", async () => {
+  const mind = await chain();
+  // The THREE-relation query: the second join is still refused (the rule
+  // concludes terminal — the study's other half), so this is where the refusal
+  // is observable.  The two-relation one now JOINS (measured, and pinned by
+  // test/99's spec), which is why this test moved here.
+  const steps = [];
+  await mind.respond("eva director country capital", (s) => steps.push(s));
+  const got = misses(steps);
+  assert.ok(got.length > 0, "the join must say why it did not join");
+  const named = got.some((s) => {
+    const parts = (s.inputs ?? []).map((i) => String(i.text));
+    return parts.some((t) => t.includes("gustaf molander")) &&
+      parts.some((t) => t.includes("country"));
+  });
+  assert.ok(named, "the report must name the candidate and the tail it tried");
+  // …and WHERE the candidate came from: a refusal that names only bytes leaves
+  // the next reader guessing which proposal path produced them (three chained-
+  // join attempts were spent fixing paths that never proposed the offender).
+  assert.ok(
+    got.some((s) => /#\d+, from the .* source/.test(String(s.note))),
+    "the report must name the candidate's node and its source",
+  );
+  // …and the bytes it actually tried, EXACTLY.  The `text` rendering cannot
+  // stand in for them: it decodes UTF-8 and DROPS NUL bytes, so a key carrying
+  // one is unrecoverable from it — which is why a refusal could not be tested
+  // exactly without re-encoding, and why this assertion reads BYTES.
+  //
+  // The relation is the rule's own: key = fact ‖ prefix(tail).
+  const carried = got.filter((s) => {
+    const raw = (s.inputs ?? []).map((i) => i.bytes);
+    if (raw.length < 3) return false;
+    const [fact, tail, key] = raw;
+    if (![fact, tail, key].every((b) => b instanceof Uint8Array)) return false;
+    if (key.length < fact.length) return false;
+    if (!fact.every((b, k) => key[k] === b)) return false;
+    const rest = key.subarray(fact.length);
+    return rest.every((b, k) => tail[k] === b);
+  });
+  assert.equal(
+    carried.length,
+    got.length,
+    `every refusal must carry its OWN bytes (key = fact ‖ prefix of tail), not ` +
+      `only a rendering — ${
+        got.length - carried.length
+      } of ${got.length} did not`,
+  );
+  await mind.store.close();
+});
+
+test("a report per LETTER is noise: only forms are reported", async () => {
+  const mind = await chain();
+  const steps = [];
+  await mind.respond("eva director country capital", (s) => steps.push(s));
+  const got = misses(steps);
+  assert.ok(got.length > 0, "the real fact's refusal is still reported");
+  // STRUCTURAL, not a count: a report is only made for a FORM, so every report
+  // carries a piece at least one window long — no one-byte out reports a miss.
+  // `W` is the fixture's own geometry (the Mind's default maxGroup), the same
+  // line the rule uses.
+  const W = 4;
+  for (const m of got) {
+    const longest = Math.max(
+      0,
+      ...(m.inputs ?? []).map((i) => String(i.text ?? "").length),
+    );
+    assert.ok(
+      longest >= W,
+      `a report must be about a form, got pieces of at most ${longest} bytes`,
+    );
+  }
+  await mind.store.close();
+});
+
+test("a fully covered query is not a refusal", async () => {
+  const mind = await chain();
+  const steps = [];
+  await mind.respond("eva director", (s) => steps.push(s));
+  assert.equal(
+    misses(steps).length,
+    0,
+    "with no tail there is nothing to join through — not a miss",
+  );
+  await mind.store.close();
+});