@hviana/sema 0.8.0 → 0.8.2

package/test/109-the-pivot-is-counted.test.mjs

@@ -0,0 +1,60 @@
+// 109-the-pivot-is-counted.test.mjs — how far the reasoner hopped is a
+// BEHAVIOUR, so it is observable without a rationale.
+//
+// WHY THIS EXISTS.  EXTENSION (the study's gap 3): the pivot does not stop when
+// the question is already satisfied — it hops on while the answer still contains
+// an unconsumed learnt context (`reasoning.ts`: the loop breaks only on a null
+// pivot, a null forward step, an unchanged answer, or a restatement).  That is a
+// property of how far the chain went, and until now it was visible only through
+// `pivotStep` in the rationale — which PERTURBS the search (measured: appending
+// text to a refusal note changed a traced answer).  `meter.ts` is the untraced
+// view and the one home for a counter name (AGENTS §6).
+//
+// WHAT IS PINNED.  The pivot is counted on the fixture where the multi-hop
+// genuinely needs it (test/23's two-fact chain), untraced.  The assertion is
+// "at least one", so it stays true whether or not the EXTENSION fix changes how
+// many hops a satisfied question takes — the drift itself gets its own test
+// once the criterion for "satisfied" is measured.
+
+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/23's two-fact chain: the pivot is what crosses the hop. */
+async function pivotFixture() {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest([
+    ["What is the capital of France", "The capital of France is Paris"],
+    ["Paris", "Paris is famous for the Eiffel Tower"],
+  ]);
+  return mind;
+}
+
+test("the pivot is counted, with no rationale attached", async () => {
+  const mind = await pivotFixture();
+  const out = await mind.respondText(
+    "What is the capital of France famous for",
+  );
+  assert.ok(
+    out.includes("Eiffel"),
+    `the multi-hop must still chain, got ${JSON.stringify(out)}`,
+  );
+  assert.ok(
+    (mind.lastCost?.counters.pivotSteps ?? 0) > 0,
+    "the hop was taken, so it must be counted",
+  );
+  await mind.store.close();
+});
+
+test("a query that needs no hop counts none", async () => {
+  const mind = await pivotFixture();
+  await mind.respondText("What is the capital of France");
+  assert.equal(
+    mind.lastCost?.counters.pivotSteps ?? 0,
+    0,
+    "a directly answered question pivots nowhere",
+  );
+  await mind.store.close();
+});

package/test/110-the-reasoner-stops-when-the-question-is-answered.test.mjs

@@ -0,0 +1,91 @@
+// 110-the-reasoner-stops-when-the-question-is-answered.test.mjs — EXTENSION: a
+// further chain link must not change the answer to a question already answered.
+//
+// THE GAP THIS CLOSES.  Every stopping condition in the pivot loop judged the
+// ANSWER; none asked whether the QUESTION was satisfied (reasoning.ts says so
+// in its own words).  Measured on a three-link chain, the reasoner took ONE hop
+// MORE than the question needed and REPLACED the satisfying answer:
+//
+//   elos=2  pivots=1 → "Paris is famous for the Eiffel Tower"   (the answer)
+//   elos=3  pivots=2 → "the Eiffel Tower is in Paris"           (one hop past it)
+//
+// THE INVARIANT (and the acceptance test, relational — no magic string):
+//
+//   adding a link to the corpus must NOT change the answer to a question the
+//   shorter corpus already answered.
+//
+// WHAT MAKES IT PRINCIPLED, and what each candidate cost.  Eight formulations
+// were measured and refuted before this one — including a count of extensions,
+// which is not a reason.  This one uses two data the mind already has:
+//   • the cost ladder's own `unaccounted` spans (what the grounding left
+//     uncovered) — passed to the reasoner by the pipeline;
+//   • the mind's own line between chance and evidence — one W-byte window —
+//     so an extension counts as progress only if it carries a window of the
+//     uncovered material;
+//   • and the pipeline's EXISTING condition for who owns a shape: "only a
+//     mechanism carrying its own `used` set (cast/join) gets this" — which is
+//     exactly `voiced.length > 0`, since `voiced` is what the mechanism
+//     withheld.  A producer owns its answer (test/29 C3's hop inside the
+//     comparison's seat fires); the reasoner's own extensions do not.
+//
+// It terminates by a real argument — the uncovered material is finite and each
+// taken extension must carry some of it — never by a depth limit.
+
+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 QUERY = "What is the capital of France famous for";
+
+/** The chain with `n` links: each fact's subject continues into the next. */
+const LINKS = [
+  ["What is the capital of France", "The capital of France is Paris"],
+  ["Paris", "Paris is famous for the Eiffel Tower"],
+  ["the Eiffel Tower", "the Eiffel Tower is in Paris"],
+];
+
+async function chain(n) {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest(LINKS.slice(0, n));
+  return mind;
+}
+
+const text = (resp) => new TextDecoder().decode(resp.bytes).replace(/\0+/g, "");
+
+test("a longer corpus does not change an answer already given", async () => {
+  const short = await chain(2);
+  const long = await chain(3);
+  const answered = text(await short.respond(QUERY)).trim();
+  const extended = text(await long.respond(QUERY)).trim();
+  assert.equal(
+    extended,
+    answered,
+    "adding a link must not push the chain past the answer",
+  );
+  // The expected answer is the fixture's OWN second link — the relation the
+  // question asked for — not a string copied into the test.
+  assert.equal(answered, LINKS[1][1]);
+  await short.store.close();
+  await long.store.close();
+});
+
+test("the counters agree: one hop, not two — with no rationale attached", async () => {
+  const mind = await chain(3);
+  await mind.respond(QUERY);
+  assert.equal(
+    mind.lastCost?.counters.pivotSteps ?? 0,
+    1,
+    "the satisfying hop is taken and the drift is not",
+  );
+  await mind.store.close();
+});
+
+test("a question the first link already answers still takes no hop", async () => {
+  const mind = await chain(3);
+  const out = text(await mind.respond("What is the capital of France"));
+  assert.equal(out.trim(), "The capital of France is Paris");
+  assert.equal(mind.lastCost?.counters.pivotSteps ?? 0, 0);
+  await mind.store.close();
+});

package/test/111-the-cover-assembly-is-counted.test.mjs

@@ -0,0 +1,74 @@
+// 111-the-cover-assembly-is-counted.test.mjs — the connector assembly is
+// countable without a rationale.
+//
+// WHY THIS EXISTS.  LIMIT (the study's gap 4): a hub query's `cover.run` is 91%
+// of its time (`"Hello."`: 2.7 s of 3.0 s) and holds its ~270 MB peak, and none
+// of it was countable — `searchPushes` (3130) and `candidates` (2) do not see
+// the connector assembly, and the rationale perturbs the search.  `meter.ts` is
+// the untraced view and the one home for a counter name (AGENTS §6).
+//
+// WHAT THE COUNTERS IMMEDIATELY SETTLED, and it is why they exist: `"Hello."`
+// makes TWO bridge calls with 59 bytes of allowance — three orders of magnitude
+// below its ~270 MB peak — so the connector assembly is NOT that peak.  A
+// hypothesis dies to a counter instead of to an afternoon of profiling.
+//
+// WHAT IS PINNED.  Both counters are published, exercised by a fixture small
+// enough to be a fixture (two touching contexts), and deterministic across
+// identical calls.  They stay true whatever the LIMIT fix turns out to be.
+
+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";
+
+async function fixture(pairs) {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest(pairs);
+  return mind;
+}
+
+test("the pairwise assembly is counted, with no rationale attached", async () => {
+  // Two contexts that TOUCH in the query (`ab`|`cd`), so the cover must bridge
+  // them pairwise.
+  const mind = await fixture([
+    ["ab", "x"],
+    ["cd", "y"],
+  ]);
+  const out = await mind.respondText("abcd");
+  const c = mind.lastCost?.counters ?? {};
+  assert.ok(
+    (c.coverBridges ?? 0) > 0,
+    "the cover bridged touching sites, so the calls must be counted",
+  );
+  assert.ok(out.length > 0, "and the answer still composes");
+  await mind.store.close();
+});
+
+test("the n-ary interior's allowance is counted", async () => {
+  // Three sites in one query: the n-ary path passes an allowance that grows
+  // with the intermediate answers' bytes — the quantity that would grow with a
+  // hub query's answers.
+  const mind = await fixture([
+    ["ab", "x"],
+    ["cd", "y"],
+    ["ab cd", "z"],
+  ]);
+  await mind.respondText("ab cd");
+  const c = mind.lastCost?.counters ?? {};
+  assert.ok(
+    (c.coverAllowanceBytes ?? 0) > 0,
+    "the n-ary interior ran, so its allowance must be counted",
+  );
+  await mind.store.close();
+});
+
+test("the counters are deterministic across identical calls", async () => {
+  const a = await fixture([["ab", "x"], ["cd", "y"]]);
+  const b = await fixture([["ab", "x"], ["cd", "y"]]);
+  await a.respondText("abcd");
+  await b.respondText("abcd");
+  assert.deepEqual(a.lastCost?.counters, b.lastCost?.counters);
+  await a.store.close();
+  await b.store.close();
+});

package/test/112-the-exploration-does-not-grow-with-the-hub.test.mjs

@@ -0,0 +1,89 @@
+// 112-the-exploration-does-not-grow-with-the-hub.test.mjs
+//
+// THE OFFER IS THE CORPUS'S STRUCTURE.  A chain hop offers the continuations the
+// corpus holds, and the search pays for exploring them on the ladder (every hop
+// costs STEP).  What must NOT happen is a combinatorial explosion: the work must
+// not grow with the SQUARE of the hub's degree.
+//
+// This file used to pin an offer CAP (`exploreCap`, with its invented
+// `PLURALITY` floor).  That cap is gone: it was a short-circuit — it bounded what
+// a hop could OFFER instead of charging for it — and it was not needed.  In the
+// regime where it used to bite (`hubBound = ceil(√N)` greater than the hub's
+// degree, reached here by choosing the degree below √N, so no trained store is
+// needed) the measured shape without it is LINEAR: degrees 35/70/120 gave offers
+// 52/84/120, pushes 262/296/332, perceptions 530/592/757 — while the peak was
+// identical with and without the cap (218/415/689 MB against 215/410/662),
+// because the peak is set by the store, not by the fan-out.  What made that hop
+// expensive was never the breadth of the offer: it was per-offer work, two
+// duplicate/oversized computations since removed.
+//
+// The residual, stated: the trained store's hub (degree 1 083) is an
+// EXTRAPOLATION from this linear shape, not a measurement.
+
+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 QUERY = "alpha beta";
+
+/** `alpha` leads to `beta`, and `beta` is a hub of `degree` continuations.
+ *
+ *  The filler keeps `edgeSourceCount()` above the square of the degree, so the
+ *  READ bound (`hubBound = ceil(√N)`) exceeds the hub's degree — the regime in
+ *  which the removed cap used to change the offer. */
+async function hub(degree) {
+  const store = new SQliteStore({ path: ":memory:", D: 1024 });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  const pairs = [
+    ["alpha", "beta"],
+    ["beta", "gamma"],
+  ];
+  for (let i = 0; i < degree; i++) {
+    pairs.push(["beta", `continuation number ${i} of this hub`]);
+  }
+  const filler = Math.ceil(degree * degree * 1.4);
+  for (let i = 0; i < filler; i++) {
+    pairs.push([`filler ${i} note`, `unrelated filler body ${i} here`]);
+  }
+  await mind.ingest(pairs);
+  return mind;
+}
+
+const pushes = (mind) => mind.lastCost?.counters.searchPushes ?? 0;
+const offers = (mind) => mind.lastCost?.counters.chainOffers ?? 0;
+
+test("the work does not explode with the hub's degree", async () => {
+  const small = await hub(20);
+  const big = await hub(80);
+  await small.respond(QUERY);
+  await big.respond(QUERY);
+  const a = pushes(small);
+  const b = pushes(big);
+  // The degree grows 4x.  An explosion multiplies the work by the SQUARE of
+  // that ratio — 16x — so the bound needs no invented number: it is the ratio's
+  // own square, and the measured shape is linear (about 4x).
+  assert.ok(
+    offers(big) > offers(small),
+    "the offer must follow the corpus's continuations: " +
+      `${offers(small)} → ${offers(big)}`,
+  );
+  assert.ok(
+    b < a * 16,
+    "work must not explode with the degree (4x degree would be 16x work): " +
+      `${a} → ${b}`,
+  );
+  await small.store.close();
+  await big.store.close();
+});
+
+test("and the hub still leads somewhere the chain can use", async () => {
+  const mind = await hub(40);
+  const out = (await mind.respondText(QUERY)).replace(/\0+/g, "").trim();
+  assert.ok(
+    out.length > 0,
+    `the hub must still be reachable, got ${JSON.stringify(out)}`,
+  );
+  assert.ok(offers(mind) > 0, "and the chain hop must have been taken");
+  await mind.store.close();
+});

package/test/113-the-rationale-payload-is-bounded.test.mjs

@@ -0,0 +1,84 @@
+// 113-the-rationale-payload-is-bounded.test.mjs — a step reports a BOUNDED
+// sample and the COUNT, never the whole field.
+//
+// THE GAP THIS CLOSES.  The study measured a rationale step carrying 1082 items
+// and another 1559 — the hub's degree and `hubBound`'s own size, both on the
+// trained store.  The step that does it is `disambiguate`: it weighed a hub's
+// continuations and emitted EVERY candidate it considered as an output item.
+// A rationale that carries the entire field is not an explanation, it is a dump:
+// what explains the choice is the pick, the count that says how wide the field
+// was, and a bounded sample of what it was chosen from.
+//
+// WHAT IS PINNED, and neither number is invented here:
+//   1. the sample is bounded by the DECLARED candidate budget (`recallQueryK`,
+//      config.ts — a capacity/budget, which is all that file holds);
+//   2. the note still carries the TOTAL, so nothing is lost — measured in the
+//      fixture below: 27 continuations weighed, 12 itemised;
+//   3. the choice itself is untouched (the inputs still name the pick).
+
+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 { DEFAULT_CONFIG } from "../dist/src/config.js";
+
+// The DECLARED capacity, read from the config — no number is copied here.
+const BUDGET = DEFAULT_CONFIG.rationaleSampleK;
+
+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(" ");
+
+/** A hub of 40 continuations, plus filler so `hubBound` exceeds the budget. */
+async function hub() {
+  const store = new SQliteStore({ path: ":memory:", D: 1024 });
+  // RECALL's budget is deliberately enormous: the rationale's sample must not
+  // follow it (found by an adversarial review — sharing `recallQueryK` meant
+  // this very setting un-bounded the payload).
+  const mind = new Mind({
+    seed: 7,
+    store,
+    profile: true,
+    recallQueryK: 100000,
+  });
+  const w = (i, n) => WORDS[(i * 7 + n * 13) % WORDS.length];
+  const pairs = [];
+  for (let i = 0; i < 40; i++) {
+    pairs.push(["beta", `continuation number ${i} of this hub`]);
+  }
+  for (let i = 0; i < 900; i++) {
+    pairs.push([
+      `${w(i, 1)} ${w(i, 2)} ${w(i, 3)} ${i}`,
+      `${w(i, 4)} ${w(i, 5)} ${w(i, 6)} ${w(i, 7)} ${i}`,
+    ]);
+  }
+  await mind.ingest(pairs);
+  return mind;
+}
+
+test("a step reports a bounded sample, and the count of the whole field", async () => {
+  const mind = await hub();
+  const steps = [];
+  await mind.respondText("beta", (s) => steps.push(s));
+  const dis = steps.filter((s) => s.mechanism.at(-1) === "disambiguate");
+  assert.ok(dis.length > 0, "the fixture must make the decider weigh a hub");
+  const step = dis[0];
+  const outs = step.outputs ?? [];
+  assert.ok(
+    outs.length <= BUDGET,
+    `the sample must fit the declared budget, got ${outs.length}`,
+  );
+  const total = Number(
+    /(\d+)\s+continuations/.exec(String(step.note))?.[1] ?? 0,
+  );
+  assert.ok(total > 0, "the note must say how wide the field was");
+  assert.ok(
+    total >= outs.length,
+    "the count is the WHOLE field, not the sample",
+  );
+  assert.equal((step.inputs ?? []).length, 1, "the pick is still named");
+  await mind.store.close();
+});

package/test/114-alignment-budget-is-per-sweep.test.mjs

@@ -0,0 +1,93 @@
+// 114-alignment-budget-is-per-sweep.test.mjs — each alignment sweep owns its
+// budget, so the NEAREST continuation survives either side's exhaustion.
+//
+// THE DEFECT THIS CLOSES (found by an adversarial review of the E3 commit).
+// `alignAround` bounds the work it may spend on (queryGap, contextGap) pairs.
+// The counter was shared between the RIGHT sweep and the LEFT sweep, so once the
+// right side spent the whole budget the left loop's guard was false on entry:
+// zero iterations, and the NEAREST left continuation was lost — the exact
+// opposite of the law the commit states ("an exhausted budget drops the FAR
+// continuations and never the near ones").  It was a regression against the
+// pre-change tree, which bounded each sweep independently.
+//
+// WHAT IS PINNED, structurally and with no magic number: a pair whose two
+// divergent flanks both exceed the work budget still aligns on BOTH sides of the
+// anchor — the left match is present as its own query span, and so is the right.
+// Before the fix the left one is missing, whatever the budget.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { alignAround } from "../dist/src/mind/match.js";
+
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+
+/** The minimal context `alignAround` reads.  There is no budget to inject any
+ *  more: the sweep's work is proportional to the bytes a run spans. */
+const ctxWith = () => ({ space: { maxGroup: 4 } });
+
+/** A shared head, a shared anchor, and divergent flanks on both sides. */
+function pair(flankLen) {
+  const q = `MATCH${"a".repeat(6)}SEED${"Q".repeat(flankLen)}`;
+  const c = `MATCH${"b".repeat(11)}SEED${"W".repeat(flankLen)}`;
+  return { q, c, at: q.indexOf("SEED") };
+}
+
+const spansOf = (res, text, needle) => {
+  const target = enc.encode(needle);
+  return res.matched.filter(([s, e]) => {
+    const got = enc.encode(text).subarray(s, e);
+    return got.length >= target.length &&
+      dec.decode(got).includes(needle);
+  });
+};
+
+test("both sides of the anchor align even when each flank exceeds the budget", () => {
+  // The budget must be reachable for the NEAR left continuation (its own
+  // 6+11-byte gap costs on the order of a hundred pair-explorations) and must be
+  // EXHAUSTED by the right flank (40x40 divergent bytes cost many hundreds).
+  // 512 sits between the two: it is the range where a shared counter starves the
+  // left sweep and a per-sweep one does not.
+  const { q, c, at } = pair(40);
+  for (const budget of [512, 4096]) {
+    const res = alignAround(
+      ctxWith(budget),
+      enc.encode(q),
+      enc.encode(c),
+      at,
+      at,
+    );
+    assert.ok(
+      spansOf(res, q, "MATCH").length > 0,
+      `the nearest LEFT continuation must survive the right sweep's budget ` +
+        `(budget ${budget}, matched ${JSON.stringify(res.matched)})`,
+    );
+    assert.ok(
+      spansOf(res, q, "SEED").length > 0,
+      "and the anchor itself is of course still matched",
+    );
+  }
+});
+
+test("the run chosen is the one with the smallest total gap", () => {
+  // The criterion the enumeration used to compute, now computed by the walk:
+  // smallest qGap + cGap, ties to the smaller query gap.  Two continuations are
+  // offered at different totals and the NEARER one must win.
+  const enc = new TextEncoder();
+  const head = "common head ";
+  const far = "FAR";
+  const near = "NEAR";
+  const q = enc.encode(
+    head + "x".repeat(4) + near + "q" + "z".repeat(30) + far,
+  );
+  const c = enc.encode(head + "y".repeat(9) + near + "c");
+  const at = head.length - 1;
+  const { matched } = alignAround(ctxWith(), q, c, at, at);
+  const got = matched.map(([a, b]) =>
+    new TextDecoder().decode(q.subarray(a, b))
+  );
+  assert.ok(
+    got.includes("NEAR"),
+    "the nearest continuation must be found: " + JSON.stringify(got),
+  );
+});

package/test/116-the-extension-is-gated-by-the-pipelines-own-remainder.test.mjs

@@ -0,0 +1,100 @@
+// 116-the-extension-is-gated-by-the-pipelines-own-remainder.test.mjs — EXTENSION
+// judges the question by the pipeline's remainder, with the pipeline's W floor.
+//
+// TWO CORRECTIONS FROM THE ADVERSARIAL REVIEW, in one definition:
+//
+//  M3 — the reasoner's `uncovered` was built from the ladder's `accounted`, a
+//  COST quantity.  The pipeline itself documents that `accounted` can be EMPTY
+//  while nothing is unexplained (a query fully explained by one computed span
+//  plus bridged connectors), and it already builds the genuine remainder as
+//  `[...decided.accounted, ...pre.computed]`.  The reasoner now uses that same
+//  reading — computed once, used by both the extension gate and the fuse gate.
+//
+//  M4 — the boundary.  The pipeline treats a remainder under W as bridging
+//  punctuation, and the reasoner inherits that floor.  The subtlety the review
+//  raised is that a one-word tail CARRIES ITS SEPARATOR: `" why"` is exactly W
+//  bytes, so it IS a remainder and licenses no extension, while `" famous for"`
+//  is well over and does.  Both sides are pinned here, because the boundary is
+//  where the reviewer's own demonstration sat.
+
+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 LINKS = [
+  ["What is the capital of France", "The capital of France is Paris"],
+  ["Paris", "Paris is famous for the Eiffel Tower"],
+];
+
+/** The test/110 chain: the second link is reachable only by hopping. */
+async function chain() {
+  const store = new SQliteStore({ path: ":memory:", D: 1024 });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest(LINKS);
+  return mind;
+}
+
+const text = (resp) =>
+  new TextDecoder().decode(resp.bytes).replace(/\0+/g, "").trim();
+
+test("a remainder the pipeline calls real licenses the hop", async () => {
+  const mind = await chain();
+  const out = text(
+    await mind.respond("What is the capital of France famous for"),
+  );
+  assert.equal(
+    out,
+    LINKS[1][1],
+    "a remainder well over one window must still reach the next link",
+  );
+  await mind.store.close();
+});
+
+test("a one-word remainder is exactly one window, and licenses nothing", async () => {
+  // `" why"` is W bytes once its separator is counted: per the pipeline's own
+  // floor it is a remainder, and per the extension law a remainder the step
+  // cannot carry licenses no hop — so the grounded fact stands, AND the refusal
+  // is visible: a brake that leaves no trace is the silent cut AGENTS §6
+  // forbids, so the rationale must say the extension was declined for want of
+  // question material.
+  const mind = await chain();
+  const steps = [];
+  const out = text(
+    await mind.respond(
+      "What is the capital of France why",
+      (s) => steps.push(s),
+    ),
+  );
+  assert.equal(
+    out,
+    LINKS[0][1],
+    "a step carrying none of the remainder must not be taken",
+  );
+  const refused = steps.find((s) => s.mechanism.at(-1) === "pivotRefused");
+  assert.ok(refused, "the refusal must be reported, not silent");
+  assert.match(
+    String(refused.note),
+    /carries none of the question material/,
+    "and it must say why it refused",
+  );
+  assert.ok(
+    (refused.outputs ?? []).length > 0,
+    "and name the material it left uncovered",
+  );
+  await mind.store.close();
+});
+
+test("a computed-span query has no phantom remainder (M3)", async () => {
+  // A pure computation: the ladder's `accounted` is not a coverage reading, so
+  // the reasoner must not see a remainder the pipeline says is not there.  The
+  // check is that the answer is the computed one and the engine is not dragged
+  // into an unrelated chain.
+  const mind = await chain();
+  const out = text(await mind.respond("2+2"));
+  assert.ok(
+    out.length > 0,
+    `a computation must still be answered, got ${JSON.stringify(out)}`,
+  );
+  await mind.store.close();
+});