@hviana/sema 0.8.0 → 0.8.2

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,113 @@
+// 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",
+  );
+  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();
+});

package/test/106-the-join-fires.test.mjs

@@ -0,0 +1,94 @@
+// 106-the-join-fires.test.mjs — DIRECTION: the join reaches the subject the
+// query never wrote.
+//
+// THE GAP THIS CLOSES.  `deriveThrough` derives the answer THROUGH a produced
+// fact: the fact carries the subject the query never named, and the query's
+// remaining tail names the relation to follow FROM that subject.  Measured, the
+// rule never fired — and the report added for it (test/105) named the gate:
+// `leading.length === 0`.  The cause was then measured exactly: the recognition
+// of the fact's bytes returns EXACTLY ONE site — the fact itself — because a
+// STORED WHOLE stops the sweep, so the interior entity the join exists for was
+// never proposed, and the query was answered by gluing the intermediate KEY to
+// the fact (`The director of Eva is Gustaf Molander.gustaf molander country`).
+//
+// WHAT IS PINNED.
+//   1. the join FIRES: the answer is the second fact, reached through the
+//      subject the query never wrote (`The country of Gustaf Molander is
+//      Sweden.`);
+//   2. the rationale says so (`derive-through` is the move that reached it);
+//   3. the intermediate KEY never appears in the answer — the glued reading is
+//      what the query got before, and it is not an answer;
+//   4. a query with no tail is not a join at all: it is answered directly, and
+//      the move must not be claimed.
+//
+// The `canonicalQueryNodes` exclusion (the query's OWN subject, canonically) is
+// what keeps test/99's TRAP refused: its `Eiffel Tower country` is a deposited
+// node in canonical form while the query writes it capitalised, so a raw byte
+// test re-admitted it and the answer came back about Eiffel Tower.
+
+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.";
+
+/** The measured chain, filed the way the real store files a fact: under BOTH
+ *  the entity and the key it was learnt with. */
+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],
+  ]);
+  return mind;
+}
+
+const text = (resp) => new TextDecoder().decode(resp.bytes).replace(/\0+/g, "");
+
+test("the join reaches the subject the query never wrote", async () => {
+  const mind = await chain();
+  const moves = [];
+  const out = text(
+    await mind.respond(
+      "eva director country",
+      (s) => moves.push(s.mechanism.at(-1)),
+    ),
+  );
+  assert.equal(out.trim(), F2);
+  assert.ok(
+    moves.includes("derive-through"),
+    `expected the join to be the move that reached it, got ${
+      [...new Set(moves)].join(", ")
+    }`,
+  );
+  await mind.store.close();
+});
+
+test("the intermediate key is never the answer", async () => {
+  const mind = await chain();
+  const out = text(await mind.respond("eva director country"));
+  assert.ok(
+    !out.includes("gustaf molander country"),
+    `the key is not an answer, got ${JSON.stringify(out)}`,
+  );
+  await mind.store.close();
+});
+
+test("a query with no tail is answered directly, not by a join", async () => {
+  const mind = await chain();
+  const moves = [];
+  const out = text(
+    await mind.respond("eva director", (s) => moves.push(s.mechanism.at(-1))),
+  );
+  assert.equal(out.trim(), F1);
+  assert.ok(
+    !moves.includes("derive-through"),
+    "there is nothing to join through when the query ends at the fact",
+  );
+  await mind.store.close();
+});

package/test/107-the-join-is-counted.test.mjs

@@ -0,0 +1,81 @@
+// 107-the-join-is-counted.test.mjs — the join's outcome is observable WITHOUT a
+// rationale.
+//
+// WHY THIS EXISTS.  Everything known about the fact join's refusals came from
+// the rationale, and the rationale PERTURBS the search: appending text to a
+// refusal note changed the answer of a traced response (measured, 386293e), and
+// the "key leads nowhere" refusal chased for four rounds turned out to be a
+// trace artifact — untraced, every refusal is a missing KEY, never a key whose
+// continuation is missing: a key that leads nowhere is not the relation at all,
+// so the scan moves on and there is no counter for it (the branch that reported
+// it was unreachable, and an adversarial review said so).
+// A work counter is the untraced view, and `meter.ts` is its one home
+// (AGENTS §6: a counter name exists in exactly one place).
+//
+// WHAT IS PINNED.  The four outcomes are published in the cost report with no
+// rationale attached.  The assertions stay TRUE when the join is fixed — they
+// check that the counters exist, that a join that fires is counted as fired, and
+// that a query whose join does not fire reports WHY in the counters — never that
+// a particular refusal still happens.
+
+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.";
+
+async function chain() {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest([
+    ["eva", F1],
+    ["eva director", F1],
+    ["gustaf molander", F2],
+    ["gustaf molander country", F2],
+    ["sweden", F3],
+    ["sweden capital", F3],
+  ]);
+  return mind;
+}
+
+const counters = (mind) => mind.lastCost?.counters ?? {};
+
+test("a join that fires is counted, with no rationale attached", async () => {
+  const mind = await chain();
+  await mind.respondText("eva director country"); // no inspectRationale
+  const c = counters(mind);
+  assert.ok(
+    (c.joinFired ?? 0) > 0,
+    "the join reached the second fact, so it must be counted as fired",
+  );
+  await mind.store.close();
+});
+
+test("a query whose join does not fire reports WHY, untraced", async () => {
+  const mind = await chain();
+  await mind.respondText("eva director country capital"); // no rationale
+  const c = counters(mind);
+  const refusals = (c.joinNoKey ?? 0) + (c.joinNoEntity ?? 0);
+  assert.ok(
+    refusals > 0,
+    "a join that did not fire must say so in the counters",
+  );
+  await mind.store.close();
+});
+
+test("the counters are deterministic across identical calls", async () => {
+  const a = await chain();
+  const b = await chain();
+  await a.respondText("eva director country capital");
+  await b.respondText("eva director country capital");
+  assert.deepEqual(
+    counters(a),
+    counters(b),
+    "same query + same store ⇒ same counted work",
+  );
+  await a.store.close();
+  await b.store.close();
+});

package/test/108-the-join-chains.test.mjs

@@ -0,0 +1,78 @@
+// 108-the-join-chains.test.mjs — DIRECTION, the other half: the result of one
+// join feeds the next.
+//
+// THE GAP THIS CLOSES.  The join's conclusion covered the WHOLE remaining tail
+// (`j = queryLen`), so it consumed everything and could only ever conclude: a
+// three-relation query got one join and stopped.  The whole-tail key was the
+// same defect seen from the key side — a two-relation tail names no learnt key
+// at all.
+//
+// THE FIX, and the measurement that found the last piece of it.  The key is the
+// SHORTEST tail prefix that BOTH resolves and leads somewhere, and the
+// conclusion covers only that prefix, leaving the rest of the tail for the next
+// step.  Resolving is not enough: a dry run of these very primitives showed the
+// first prefix that resolves for the candidate `Sweden` is the key `Sweden `
+// (trailing space) — which leads NOWHERE — while the key that names the fact
+// (`sweden capital`) sat one prefix further; accepting the first resolving key
+// refused the join.
+//
+// WHAT IS PINNED, untraced (a rationale perturbs the search — test/107):
+//   1. the answer is the THIRD fact, reached through two joins;
+//   2. `joinFired` counts exactly two — the counters are the untraced view;
+//   3. the two-relation query still counts exactly one, so chaining did not
+//      turn every join into a chain.
+
+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.";
+
+async function chain() {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest([
+    ["eva", F1],
+    ["eva director", F1],
+    ["gustaf molander", F2],
+    ["gustaf molander country", F2],
+    ["sweden", F3],
+    ["sweden capital", F3],
+  ]);
+  return mind;
+}
+
+const text = (resp) => new TextDecoder().decode(resp.bytes).replace(/\0+/g, "");
+
+test("a three-relation query reaches the third fact, through two joins", async () => {
+  const mind = await chain();
+  const out = text(await mind.respond("eva director country capital"));
+  assert.equal(out.trim(), F3, "the chain must reach the capital fact");
+  await mind.store.close();
+});
+
+test("the counters agree, with no rationale attached", async () => {
+  const mind = await chain();
+  await mind.respond("eva director country capital");
+  assert.equal(
+    mind.lastCost?.counters.joinFired ?? 0,
+    2,
+    "two joins reached it — the untraced view must agree with the answer",
+  );
+  await mind.store.close();
+});
+
+test("a two-relation query still joins exactly once", async () => {
+  const mind = await chain();
+  const out = text(await mind.respond("eva director country"));
+  assert.equal(out.trim(), F2);
+  assert.equal(
+    mind.lastCost?.counters.joinFired ?? 0,
+    1,
+    "chaining must not turn a single join into a chain",
+  );
+  await mind.store.close();
+});