@hviana/sema 0.8.2 → 0.8.3

package/src/mind/recognition.ts

@@ -535,7 +535,10 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
         // emitted, so a caller can retry a trimmed edge on the miss path only.
         if (end - start < W) return false;
         if (flatProbe(start, end) === null) {
-          if (!canonBudget) return false;
+          if (!canonBudget) {
+            if (ctx.meter) ctx.meter.canonProbesDenied++;
+            return false;
+          }
           if (!canonAdmits(start, end)) return false;
         }
         const id = resolveSpan(start, end);
@@ -556,13 +559,6 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
       // endpoints in order and running out partway along the query.  A form
       // longer than that is out of this tier's reach — but so is a form the
       // chain cannot span, and that is exactly the trade the budget prices.
-      // The factor is chainReach(W), the same W² scale the chain already
-      // trusts; no new constant.
-      // The factor is chainReach(W) — the same W² scale the chain itself
-      // trusts — so the cap is derived from the fold's geometry, never tuned.
-      // (It was briefly an environment variable while the cost was being
-      // measured; an env-read here would make inference non-reproducible,
-      // which the determinism contract forbids outright.)
       // The factor is chainReach(W) — the same W² scale the chain itself
       // trusts — so the cap is derived from the fold's geometry, never tuned.
       // (It was briefly an environment variable while the cost was being

package/src/mind/resonance.ts

@@ -329,7 +329,14 @@ export async function pivotInto(
   consumed: ReadonlySet<number>,
   voiced: readonly Uint8Array[] = [],
 ): Promise<number | null> {
-  const k = ctx.cfg.recallQueryK;
+  // The pivot's OWN shortlist capacity — not `recallQueryK`: they are different
+  // quantities (a mechanical sweep's probe budget vs the bridge's candidate-read
+  // allowance), and one number serving both means tightening either silently
+  // starves the other.  The reason is the duplication, NOT a measured strangle:
+  // an earlier version of this comment claimed "at recallQueryK 1 the pivot finds
+  // no pivot", and that was probed and is FALSE on test/23's fixture — the
+  // strangle is fixture-specific, so it is not the evidence for this split.
+  const k = ctx.cfg.pivotProbeK;
   // ONE perception of the answer, shared by the probe budget and the walk —
   // this used to fold the same bytes twice, back to back, on every hop.
   const tree = perceive(ctx, answer);
@@ -365,6 +372,17 @@ export async function pivotInto(
     }
     for (const c of n.kids) queue.push(c); // breadth-first: larger regions first
   }
+  // The sweep's two FACTS, untraced (meter.ts contract 1: a counter never
+  // reaches a decision).  `probes` is the work done; the shortfall is the
+  // capacity the cap withheld — the branches the breadth-first order never got
+  // to.  Whether that withheld anything that mattered is NOT said here: the
+  // order spends the largest regions first, and recognition below still
+  // contributes every exact containment candidate regardless of the budget.
+  if (ctx.meter) {
+    ctx.meter.pivotProbes += probes;
+    const unprobed = branchCount - probeCap;
+    if (unprobed > 0) ctx.meter.pivotBranchesUnprobed += unprobed;
+  }
   // THE FULL recognition, memo-shared with every other reader of these bytes.
   // A "skip the edge trims here" variant was refuted (see recognise's own
   // note): those trims are what find a WHOLE trained form embedded at an

package/src/mind/trace.ts

@@ -18,6 +18,7 @@ export function rItem(
 ): RationaleItem {
   return {
     text: decodeText(bytes),
+    bytes,
     role,
     node: node ?? undefined,
     span,

package/src/mind/traverse.ts

@@ -10,6 +10,13 @@ import { cosine, Vec } from "../vec.js";
 import type { AncestorReach, MindContext, SaturationStop } from "./types.js";
 import { gistOf, read } from "./primitives.js";
 import { canonicalWindows, leafIdPrefix, leafIdRun } from "./canonical.js";
+// Imported at the TOP, where every other import is.  They used to sit 800 lines
+// down under a note claiming the position mattered ("before trace module is
+// loaded") — it does not: an ES module's static imports are HOISTED, so the
+// file's line order never decides load order.  The note described an intention
+// the runtime does not honour; the imports move and the claim goes.
+import { decodeText } from "./rationale.js";
+import type { RationaleItem } from "./rationale.js";
 
 // ── Session structural memo ─────────────────────────────────────────────
 //
@@ -824,11 +831,6 @@ export function chooseAmong(
     : { id: candidates[0], score: -Infinity };
 }
 
-// ── Trace shim (used by chooseNext before trace module is loaded) ────────
-
-import { decodeText } from "./rationale.js";
-import type { RationaleItem } from "./rationale.js";
-
 function rItemShort(
   ctx: MindContext,
   id: number,

package/src/mind/types.ts

@@ -65,15 +65,21 @@ export interface GraphSearchHost {
     starts: ReadonlySet<number>;
   };
   chooseNext?(node: number): number | undefined;
-  /** The boundary positions of `bytes` under the engine's ONE boundary rule
-   *  (geometry.ts's `contentBoundaries`), or undefined when the host has no
-   *  space to ask.  The join's key is an entity plus a prefix of the tail, and
-   *  the prefix that names a stored relation ENDS on one of these boundaries —
-   *  measured, 5 of 5 accepted keys over four join-firing queries, where the
-   *  byte-by-byte scan spent 153 probes for 14 boundaries.  Boundaries are
-   *  content-defined and STABLE under prefix extension, which is why a corpus
-   *  key's end is a boundary of the query's own fold of the same bytes. */
-  contentCuts?(bytes: Uint8Array): readonly number[];
+  /** The lengths `p` for which `prefix ‖ tail[0..p]` IS A STORED NODE, ascending
+   *  — the join's candidate set, in the tail's own coordinates.  Optional: a host
+   *  that cannot answer makes the join fall back to every prefix, which is exact
+   *  and complete but pays a `resolve` per offset.
+   *
+   *  WHY NOT THE FOLD'S CUTS.  A key names a relation exactly when the
+   *  concatenation is a node, and a node's end is the end of ITS OWN stream —
+   *  where the fold never emits a cut (geometry's `emit` guards `at >= n`).  So a
+   *  key can end strictly inside the tail with no boundary anywhere near it:
+   *  measured, "stockholm mayor" exists, leads on to the mayor fact, and its
+   *  boundary 6 is in neither the tail's cuts ([4,7]) nor the concatenation's.
+   *  The fold's boundaries are a SUBSET of the real ends, not a proxy for them,
+   *  and using them skipped the shortest names first — which is a semantic law,
+   *  not an optimisation (test/106, test/108 pin it). */
+  contentKeyEnds?(prefix: Uint8Array, tail: Uint8Array): readonly number[];
   /** The admission predicate — `traverse.ts`'s `leadsSomewhere`, its ONE
    *  definition: does this node bear an edge or a halo?  Optional, so a bare
    *  host (a raw Store and nothing else) still works; when present, the search
@@ -145,11 +151,28 @@ export interface Attention {
    *  strength and its place.
    *  `vote` is a sum over every region that agreed, so it grows with how many
    *  places corroborated; `peak` is what the strongest one of them said on its
-   *  own.  A consumer holding this point to consensusFloor(N) — a bar that
-   *  prices ONE region's maximally-discriminative evidence — must read `peak`,
-   *  not `vote`: six scaffolding regions summing past the floor is not the
-   *  same claim as one region clearing it. */
+   *  own.  THIS USED TO PRESCRIBE THE WRONG OPERAND.  It read: "a consumer
+   *  holding this point to consensusFloor(N) — a bar that prices ONE region's
+   *  maximally-discriminative evidence — must read `peak`, not `vote`."  The
+   *  engine reads the POOLED vote, and thresholds.md §2 derives the floor for
+   *  exactly that ("Pooled-vote significance floor": one maximally-specific
+   *  region contributes at most ln N, and ln(N)+1/2 demands corroboration
+   *  BEYOND one region).  MEASURED across 27 anchors on 6 queries: all 11
+   *  admissions cleared the floor by the sum and NONE by `peak` alone — a gate
+   *  reading `peak` would refuse every root the engine elects.  `peak` remains
+   *  what it is: the strongest SINGLE region's contribution. */
   peak: number;
+  /** The IDF-WEIGHTED sum behind this point — the quantity `consensusFloor` is
+   *  derived for, and therefore the one the floor gates must read.  It is
+   *  MODE-INDEPENDENT by construction (its per-region weight is
+   *  `mutual · idf / roots`, never the mode-dependent `wf`), so gating on it
+   *  makes an anchor's admission the same in `inverse`, `direct` and `combined`.
+   *  In `inverse` — the only mode the engine runs — it equals `vote` exactly
+   *  (measured, test/55 test 17), so nothing about today's verdicts changes.
+   *  MEASURED before this field existed: gating on `vote` DID flip a verdict,
+   *  anchor 87 of test/55's query (inverse 2.682 admitted, direct 1.468
+   *  refused, floor 2.292). */
+  idfVote: number;
   /** SCALE-INVARIANT confidence: the fraction of the query's OWN regions
    *  whose evidence this point accounts for (Σ RegionVote.absorbed among
    *  its contributors, over the query's total region count) — read PER-

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

@@ -73,6 +73,30 @@ test("the join's refusal is reported, naming the candidate and tail it tried", a
     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();
 });
 

package/test/118-the-join-reaches-a-key-off-the-cut.test.mjs

@@ -0,0 +1,74 @@
+// 118-the-join-reaches-a-key-off-the-cut.test.mjs — a deposited, CONTINUING key
+// must be reachable even when its boundary is not a fold cut of the tail.
+//
+// WHY THIS EXISTS.  The join builds `key = fact.bytes ‖ tail[0..len]` and used to
+// try only the tail's own fold boundaries (plus its end).  A boundary is not a
+// proxy for a stored key's end: a deposited member's end is the end of ITS OWN
+// stream, and the fold never emits a cut at a stream's end (geometry's `emit`
+// guards `at >= n`) — so the boundary that names a real stored key can sit
+// between cuts, or beyond every one of them.  Measured on the five-fact chain
+// below: the fourth hop's key "stockholm mayor" exists (resolve() finds it), its
+// continuation is the mayor fact, and its boundary (p = 6) is NOT among the
+// tail's cuts ([4,7]) — so the join could not try it and the answer stopped at
+// the third fact.
+//
+// The candidate ends are now the prefixes that ARE stored nodes, ascending, from
+// the host's `contentKeyEnds` — so the shortest name still wins, and every
+// deposited key is reachable.
+//
+// WHAT IS PINNED.  The chain reaches the FIFTH fact, and the join fires at least
+// four times.  The counters are the untraced view (AGENTS §6: profile without a
+// trace attached).
+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.";
+const F4 = "The mayor of Stockholm is Karin Wanngard.";
+const F5 = "The party of Karin Wanngard is the Social Democrats.";
+
+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],
+    ["stockholm", F4],
+    ["stockholm mayor", F4],
+    ["karin wanngard", F5],
+    ["karin wanngard party", F5],
+  ]);
+  return { mind, store };
+}
+
+const text = (resp) => new TextDecoder().decode(resp.bytes).replace(/\0+/g, "");
+
+test("a five-fact chain reaches the fifth fact, through four joins", async () => {
+  const { mind, store } = await chain();
+  const out = text(
+    await mind.respond("eva director country capital mayor party"),
+  ).trim();
+  const fired = mind.lastCost?.counters.joinFired ?? 0;
+  await store.close();
+
+  assert.equal(
+    out,
+    F5,
+    `the chain must reach the fifth fact. A key that EXISTS and LEADS ON ` +
+      `("stockholm mayor" → the mayor fact) was not tried because its boundary ` +
+      `is not a cut of the tail alone — the join was asked to extend from the ` +
+      `third fact and stopped (joinFired=${fired})`,
+  );
+  assert.ok(
+    fired >= 4,
+    `the join must fire once per licensed hop (measured ${fired}); four hops ` +
+      `were available: eva→gustaf molander→sweden→stockholm→karin wanngard`,
+  );
+});

package/test/119-the-work-does-not-grow-with-the-corpus.test.mjs

@@ -0,0 +1,122 @@
+// 119-the-work-does-not-grow-with-the-corpus.test.mjs — the derivation's work
+// must be FLAT in the corpus for a byte-identical answer.
+//
+// THE LAW.  bounded-reads.md forbids per-query work that grows with N: a bigger
+// store may answer differently (a better derivation can exist), but it must not
+// buy arbitrary COMPUTATION for the same answer.  test/89 measures this for the
+// completion recursion against real prose, test/14 for recall reads; this closes
+// the loop for the derivation as a whole after the F3/F4 migrations, where the
+// hop allowance stopped deciding depth and the pivot's probe sweep got its own
+// capacity.
+//
+// THE BARS ARE THE REPO'S OWN, not new numbers (trap 4).  test/89 asserts
+// `k < 0.6` for its `searches` (nested solve() calls — the recursion, which its
+// fix governs end to end; measured 1.28 unfixed → 0.38 fixed) and `k < 1` for
+// agenda pops — "only outright linear growth is the forbidden case … so this
+// asserts the law itself", measured 1.40 unfixed → 0.54 fixed.  Same helper as
+// test/14 (`logLogSlope`), copied because suites here are standalone.
+//
+// MEASURED BEFORE THIS TEST EXISTED, on the fixture below, one call per size:
+// pops 338 / 338 / 338 / 338 (k = 0.000), searches 2 everywhere, one pivot, and
+// a byte-identical answer — flat, and flat by a wide margin.
+
+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";
+
+/** Power-law exponent k in t ≈ c·n^k, by log–log least squares.
+ *  k≈0 flat · k≈1 linear · k≈2 quadratic.  (test/14's helper.) */
+function logLogSlope(sizes, times) {
+  const n = sizes.length;
+  const xs = sizes.map(Math.log), ys = times.map(Math.log);
+  const mx = xs.reduce((a, b) => a + b, 0) / n;
+  const my = ys.reduce((a, b) => a + b, 0) / n;
+  let num = 0, den = 0;
+  for (let i = 0; i < n; i++) {
+    num += (xs[i] - mx) * (ys[i] - my);
+    den += (xs[i] - mx) ** 2;
+  }
+  return num / den;
+}
+
+const WORDS =
+  ("alpha bravo charlie delta echo foxtrot golf hotel india juliet kilo lima " +
+    "mike november oscar papa").split(" ");
+
+/** A three-fact chain the query closes through (test/110's LINKS), plus `n`
+ *  unrelated pairs so the corpus grows without touching the derivation. */
+const QUERY = "What is the capital of France famous for";
+
+async function measure(n) {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  const pairs = [
+    ["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"],
+  ];
+  for (let i = 0; i < n; i++) {
+    pairs.push([
+      `note ${i} about ${WORDS[i % 16]} ${WORDS[(i * 3) % 16]}`,
+      `the ${WORDS[i % 16]} of ${WORDS[(i * 5) % 16]} is ${
+        WORDS[(i * 7) % 16]
+      } ${i}`,
+    ]);
+  }
+  await mind.ingest(pairs);
+  const answer = String(await mind.respondText(QUERY)).trim();
+  const c = mind.lastCost.counters;
+  await store.close();
+  return { answer, pops: c.searchPops ?? 0, searches: c.searches ?? 0 };
+}
+
+test("a bigger corpus does not buy more work for the same answer", async () => {
+  const base = 250;
+  const sizes = [];
+  const pops = [];
+  const searches = [];
+  const answers = [];
+  for (const mult of [1, 2, 4, 8]) {
+    const n = base * mult;
+    const r = await measure(n);
+    sizes.push(n);
+    pops.push(r.pops);
+    searches.push(r.searches);
+    answers.push(r.answer);
+    console.log(
+      `    N=${n} → pops ${r.pops}, searches ${r.searches}, ` +
+        `answer "${r.answer.slice(0, 32)}"`,
+    );
+  }
+
+  // The answer is the CONTROL: same answer, eight times the corpus.  Without
+  // this the exponents below could be flat because the query stopped being
+  // answered at all.
+  assert.equal(
+    new Set(answers).size,
+    1,
+    `the answer must not move with the corpus (got ${JSON.stringify(answers)})`,
+  );
+
+  const kSearches = logLogSlope(sizes, searches);
+  const kPops = logLogSlope(sizes, pops);
+  console.log(
+    `    growth exponents over N→8N: searches k=${kSearches.toFixed(2)}, ` +
+      `pops k=${kPops.toFixed(2)}`,
+  );
+
+  assert.ok(
+    kSearches < 0.6,
+    `nested searches grew with exponent k=${kSearches.toFixed(2)} in corpus ` +
+      `size (${searches.join(" → ")}) for a byte-identical answer`,
+  );
+  assert.ok(
+    kPops < 1,
+    `agenda pops grew with exponent k=${kPops.toFixed(2)} in corpus size ` +
+      `(${
+        pops.join(" → ")
+      }) for a byte-identical answer — k≈1 is work LINEAR ` +
+      `in the corpus, which bounded-reads.md forbids outright`,
+  );
+});

package/test/120-composition-is-consequence.test.mjs

@@ -0,0 +1,132 @@
+// 120-composition-is-consequence.test.mjs — the composition matrix.
+//
+// THE LAW.  A derivation is closed when the structure it built accounts for the
+// query's remainder; every transition is then an item that produced BYTES and a
+// NODE, priced on the one ladder, and the next mechanism consumes it like any
+// other premise.  This file records, for the roadmap's fourteen pairs, which
+// law permits the composition and which one forbids it — from the CODE, never
+// from "this mechanism does not call that one" (which the roadmap refuses to
+// accept as a reason).
+//
+// THE CLASSIFICATION, each with the code fact that decides it:
+//
+//   VALID — the second transition consumes the first's conclusion:
+//     fact → join           the join resolves its own key (resolve ?? canonResolve)
+//     fact → completion     a produced form's continuation is charged MICRO (rcmp)
+//     completion → join     VALID for a completion that IS a stored node
+//     join → completion     the join concludes a `form` carrying its own node
+//     completion → recompletion   the recursion itself (recompleteOpen, memo)
+//     recomposition → completion  rcmp: following the fused whole completes it
+//     recompose → join      `fuse` names the FUSED whole's node (concat of both)
+//     entity → join         deriveThrough's premise IS the entity's node
+//
+//   INVALID_BY_IDENTITY — the identity of the premise cannot carry the step:
+//     join → recompose      the composite's `node` is a PART's, so decomposing it
+//                           would return another object's structure
+//     completion → join     for a node-less `out`: a computed value is not a
+//                           corpus subject, so no stored relation exists through it
+//
+//   NOT ON THE FRONTIER — semantically fine, structurally out of the chart
+//   (no taxonomy label exists for this; stated rather than forced):
+//     pivot → join          reason() runs after grounding (pipeline.ts:579) and
+//                           its result is the ANSWER, not a GItem on a frontier
+//     alignment → join      a connector leaves the cover as a mechanism PAYLOAD
+//                           (cover.ts:163 `return links`), not as an item
+//
+//   UNKNOWN — the code does not decide, so no claim is made:
+//     join → alignment      the two live in different layers (the cover's chart
+//                           vs recall's candidate list); whether a legitimate
+//                           composition exists there is not settled by the code
+//
+// THE INVARIANT THIS FILE PINS, and the reason it is not a duplicate of
+// test/118: composition means the NEXT step's premise is the PREVIOUS step's
+// conclusion.  The join ATTEMPTS name their candidate entity, and on a five-fact
+// chain those candidates ADVANCE through the chain's subjects — measured:
+// "gustaf molander" → "gustaf molander" → "sweden" → "stockholm", never the
+// query's own subject.  test/118 pins that the chain completes and counts the
+// joins that SUCCEED; this pins that the attempts ADVANCE.
+//
+// SCOPE, measured rather than assumed: this assertion SATURATES.  A vacuity
+// experiment on truncated chains gave 2 facts → ["gustaf molander"] (fails),
+// 3 → ["gustaf molander", "sweden"] (fails), and 4 and 5 → the same three
+// subjects (passes).  So it proves the premise advances through at least three
+// subjects and never stands on the query's own; it does NOT pin the last hop,
+// because a SUCCESSFUL join is not reported under a `deriveThrough` step name —
+// the count of successes is test/118's assertion, cited here rather than
+// pretended.
+
+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 FACTS = [
+  "The director of Eva is Gustaf Molander.",
+  "The country of Gustaf Molander is Sweden.",
+  "The capital of Sweden is Stockholm.",
+  "The mayor of Stockholm is Karin Wanngard.",
+  "The party of Karin Wanngard is the Social Democrats.",
+];
+const KEYS = [
+  ["eva director", 0],
+  ["gustaf molander country", 1],
+  ["sweden capital", 2],
+  ["stockholm mayor", 3],
+  ["karin wanngard party", 4],
+];
+const QUERY = "eva director country capital mayor party";
+
+test("a join chain's attempts advance through the chain's subjects", async () => {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  const pairs = [];
+  for (const [key, i] of KEYS) {
+    pairs.push([key.split(" ").slice(0, -1).join(" "), FACTS[i]], [
+      key,
+      FACTS[i],
+    ]);
+  }
+  await mind.ingest(pairs);
+
+  const steps = [];
+  const answer = String(await mind.respondText(QUERY, (s) => steps.push(s)))
+    .trim();
+
+  // The candidate each join attempt stood on.  The FIRST input of a
+  // derive-through step is the entity; taking it from the item's own bytes
+  // keeps this structural — no parsing of note text, which would be a magic
+  // string (the adversarial checklist names it).
+  const candidates = steps
+    .filter((s) => (s.mechanism ?? []).join("/").includes("deriveThrough"))
+    .map((s) => String((s.inputs ?? [])[0]?.text ?? ""));
+
+  assert.ok(
+    candidates.length >= 3,
+    `the chain must attempt several hops, got ${candidates.length}`,
+  );
+  const distinct = new Set(candidates);
+  assert.ok(
+    distinct.size >= 3,
+    `the premise must ADVANCE, not repeat the query's subject — candidates ` +
+      `${JSON.stringify([...distinct])}`,
+  );
+  // The chain's own subjects, and NOT the query's (composition means leaving
+  // the question's own subject behind and standing on what the last step found).
+  assert.ok(
+    !distinct.has("eva"),
+    `no hop may stand on the query's own subject; got ${
+      JSON.stringify([...distinct])
+    }`,
+  );
+  assert.ok(
+    distinct.has("sweden") && distinct.has("stockholm"),
+    `later hops must stand on the chain's subjects; got ${
+      JSON.stringify([...distinct])
+    }`,
+  );
+  assert.ok(
+    answer.includes("Social Democrats"),
+    `and the chain must reach the last fact, got ${JSON.stringify(answer)}`,
+  );
+  await store.close();
+});

package/test/121-the-extension-does-not-grow-with-the-corpus.test.mjs

@@ -0,0 +1,128 @@
+// 121-the-extension-does-not-grow-with-the-corpus.test.mjs — the POST-GROUNDING
+// extension must be flat in the corpus too.
+//
+// THE LAW, applied one layer out.  test/119 pins that the DERIVATION's work does
+// not grow with the corpus.  But the answer also passes through the post-grounding
+// extension (`reason()`), and bounded-reads.md does not care which layer does the
+// work: a bigger store may answer differently, never buy arbitrary computation for
+// the same answer.
+//
+// MEASURED BEFORE THIS TEST EXISTED, one call per size:
+//
+//     N= 250 / 500 / 1000 / 2000  ⇒  reasonSteps 1, reasonCarriedBytes 11,
+//                                     pops 338 (k = 0.000), same answer
+//
+// THE BARS ARE THE REPO'S OWN (trap 4 — no new numbers): test/89 asserts k < 1 for
+// agenda pops ("only outright linear growth is the forbidden case … so this asserts
+// the law itself", measured 1.40 unfixed → 0.54 fixed).  The exponent helper is
+// test/14's `logLogSlope`, copied because suites here are standalone.
+//
+// THE ANTI-VACUITY GUARD IS THE POINT: `reasonSteps ≥ 1` at every size.  Most
+// fixtures in this repository answer before the extension can run — measured five
+// times over in the closure work — and a flat curve for an extension that never
+// runs would prove nothing at all.
+
+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";
+
+/** Power-law exponent k in t ≈ c·n^k, by log–log least squares.
+ *  k≈0 flat · k≈1 linear · k≈2 quadratic.  (test/14's helper.) */
+function logLogSlope(sizes, times) {
+  const n = sizes.length;
+  const xs = sizes.map(Math.log), ys = times.map(Math.log);
+  const mx = xs.reduce((a, b) => a + b, 0) / n;
+  const my = ys.reduce((a, b) => a + b, 0) / n;
+  let num = 0, den = 0;
+  for (let i = 0; i < n; i++) {
+    num += (xs[i] - mx) * (ys[i] - my);
+    den += (xs[i] - mx) ** 2;
+  }
+  return num / den;
+}
+
+const WORDS =
+  ("alpha bravo charlie delta echo foxtrot golf hotel india juliet kilo lima " +
+    "mike november oscar papa").split(" ");
+
+/** test/109's two-fact chain — the pivot is what crosses the hop — plus `n`
+ *  unrelated pairs so the corpus grows without touching the extension. */
+const QUERY = "What is the capital of France famous for";
+
+async function measure(n) {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  const pairs = [
+    ["What is the capital of France", "The capital of France is Paris"],
+    ["Paris", "Paris is famous for the Eiffel Tower"],
+  ];
+  for (let i = 0; i < n; i++) {
+    pairs.push([
+      `note ${i} about ${WORDS[i % 16]} ${WORDS[(i * 3) % 16]}`,
+      `the ${WORDS[i % 16]} of ${WORDS[(i * 5) % 16]} is ${
+        WORDS[(i * 7) % 16]
+      } ${i}`,
+    ]);
+  }
+  await mind.ingest(pairs);
+  const answer = String(await mind.respondText(QUERY)).trim();
+  const c = mind.lastCost.counters;
+  await store.close();
+  return {
+    answer,
+    steps: c.reasonSteps ?? 0,
+    carried: c.reasonCarriedBytes ?? 0,
+    pops: c.searchPops ?? 0,
+  };
+}
+
+test("a bigger corpus does not buy more extension work for the same answer", async () => {
+  const base = 250;
+  const sizes = [];
+  const pops = [];
+  const steps = [];
+  const answers = [];
+  for (const mult of [1, 2, 4, 8]) {
+    const n = base * mult;
+    const r = await measure(n);
+    sizes.push(n);
+    pops.push(r.pops);
+    steps.push(r.steps);
+    answers.push(r.answer);
+    console.log(
+      `    N=${n} → reasonSteps ${r.steps}, reasonCarriedBytes ${r.carried}, ` +
+        `pops ${r.pops}`,
+    );
+  }
+
+  // ANTI-VACUITY: the extension must be what is being measured.  Without this,
+  // a flat curve would just mean the reasoner never ran.
+  assert.ok(
+    steps.every((s) => s >= 1),
+    `the extension must run at every size (got ${JSON.stringify(steps)})`,
+  );
+  assert.equal(
+    new Set(answers).size,
+    1,
+    `the answer must not move with the corpus (got ${JSON.stringify(answers)})`,
+  );
+  assert.equal(
+    new Set(steps).size,
+    1,
+    `and the extension must take the same number of steps (got ${
+      JSON.stringify(steps)
+    })`,
+  );
+
+  const kPops = logLogSlope(sizes, pops);
+  console.log(`    growth exponent over N→8N: pops k=${kPops.toFixed(2)}`);
+  assert.ok(
+    kPops < 1,
+    `agenda pops grew with exponent k=${kPops.toFixed(2)} in corpus size ` +
+      `(${
+        pops.join(" → ")
+      }) for a byte-identical answer — k≈1 is work LINEAR ` +
+      `in the corpus, which bounded-reads.md forbids outright`,
+  );
+});