@hviana/sema 0.8.9 → 0.9.1

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

@@ -46,15 +46,18 @@ test("the pairwise assembly is counted, with no rationale attached", async () =>
 });
 
 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.
+  // Three touching sites in one query, each answered: 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.  The connectors are bridged
+  // only for the pairs the search REACHES (ConnectorLicence), so the lightest
+  // cover must stand on all three answers: a query recognised whole (an
+  // `ab cd` learnt as its own context) never reaches its parts' pair.
   const mind = await fixture([
     ["ab", "x"],
     ["cd", "y"],
-    ["ab cd", "z"],
+    ["ef", "z"],
   ]);
-  await mind.respondText("ab cd");
+  await mind.respondText("abcdef");
   const c = mind.lastCost?.counters ?? {};
   assert.ok(
     (c.coverAllowanceBytes ?? 0) > 0,

package/test/128-the-leads-somewhere-pair-agrees.test.mjs

@@ -1,17 +1,18 @@
 // 128-the-leads-somewhere-pair-agrees.test.mjs — THE PAIR, PINNED
 //
-// "Does this node lead somewhere?" is answered in TWO homes, and they cannot
-// share a name: `traverse.ts`'s `leadsSomewhere` is `cachedHasNext || hasHalo`,
-// and `primitives.ts` spells out `hasNext || hasHalo` because `traverse.ts`
-// imports that file (a cycle) — the comment there says so.  Two spellings of
-// one predicate is a drift risk, so this pins the AGREEMENT, node by node,
-// through the observable surface only: `mind.leadsSomewhere(id)` against
-// `store.hasNext(id) || store.hasHalo(id)`.
+// "Does this node lead somewhere?" has ONE raw definition — the store's
+// `leadsSomewhere` (`hasNext || hasHalo`) — and ONE memoised reading of it,
+// `traverse.ts`'s `leadsSomewhere` (`cachedHasNext || hasHalo`), which the Mind
+// lends to the search.  The callers that used to spell the pair out by hand
+// (`primitives.ts`, the search's bare-host fallback) now ask the store.  This
+// pins the AGREEMENT, node by node, through the observable surface only:
+// `mind.leadsSomewhere(id)` against `store.leadsSomewhere(id)`, and both against
+// the two probes the definition is made of.
 //
 // It is NOT a claim that the two are the same function: one reads a memo, the
 // other reads the store.  The claim is that the memoised reading and the store
-// reading agree — what makes the spelled-out copy correct, and what would break
-// first if `cachedHasNext` ever outlived a store write.
+// reading agree — what would break first if `cachedHasNext` ever outlived a
+// store write.
 //
 // THE REACH OF THIS PIN, said as it is: halos are poured on the WRITE side, so
 // a synthetic corpus of this shape carries NONE (measured: 0 nodes with a halo
@@ -49,16 +50,21 @@ test("the two homes of 'leads somewhere' agree, node by node", async () => {
   let withHalo = 0;
   for (let id = 0; id < total; id++) {
     const named = m.leadsSomewhere(id);
-    const spelled = m.store.hasNext(id) || m.store.hasHalo(id);
+    const stored = m.store.leadsSomewhere(id);
     const hasEdge = m.store.hasNext(id);
     const hasHalo = m.store.hasHalo(id);
     if (hasEdge) withEdge++;
     if (hasHalo) withHalo++;
+    assert.equal(
+      stored,
+      hasEdge || hasHalo,
+      `node ${id}: the store's definition must be its two probes`,
+    );
     assert.equal(
       named,
-      spelled,
+      stored,
       `node ${id}: traverse.leadsSomewhere says ${named}, ` +
-        `primitives' spelling says ${spelled} (hasNext=${hasEdge}, hasHalo=${hasHalo})`,
+        `the store says ${stored} (hasNext=${hasEdge}, hasHalo=${hasHalo})`,
     );
   }
 

package/test/136-the-two-named-limits.test.mjs

@@ -77,8 +77,9 @@ test("136.1 the fuse gate asks the LAW — one condition, one home, one less sum
   );
   assert.match(
     src,
-    /const fused = closed\(state\)/,
-    "the fuse gate must ask the law's `closed(state)` — the condition the state " +
+    /engages: \(d: DerivationState\) => !closed\(d\)/,
+    "the fuse gate must ask the law's `closed` of the state fusion is offered " +
+      "against (the fusion layer engages only while it is open) — the condition the state " +
       "already carries.  If it went back to summing `unaccounted(explained)`, that " +
       "is a second reading of one condition AND an extra sum per response: 136.3 " +
       "measures the equivalence, so re-read it before restoring the total",

package/test/137-the-law-lives-once-and-below.test.mjs

@@ -398,3 +398,24 @@ test("137.6 no export is genuinely dead — the triage, as a guard", async () =>
     "genuinely dead exports found — remove them, or state where they are consumed",
   );
 });
+
+test("137.7 no transition of the derivation is built by hand outside the law", async () => {
+  // `advance` is the ONLY transition (derivation.ts).  A state spread with a new
+  // product — `{ ...state, product: … }` — is a transition the law never saw:
+  // the fusion used to hand-build one when the law refused it, which is exactly
+  // the bypass a fixed point exists to forbid.  Comments are stripped, so prose
+  // that DESCRIBES the shape cannot satisfy or break this.
+  const { text } = await graph();
+  const offenders = [...text.entries()]
+    .filter(([f]) => f !== "src/mind/derivation.ts")
+    .filter(([, s]) =>
+      /\.\.\.\s*(?:state|d0|d|reasoned|closed_)\s*,\s*product\s*:/.test(s)
+    )
+    .map(([f]) => f);
+  assert.deepEqual(
+    offenders,
+    [],
+    "a derivation state is advanced by hand outside derivation.ts — offer the " +
+      "step to the law (`admissible` + `advance`) instead",
+  );
+});

package/test/148-exact-shortcuts-agree.test.mjs

@@ -0,0 +1,188 @@
+// 148-exact-shortcuts-agree.test.mjs — two shortcuts that are EXACT, pinned
+// against the definitions they shortcut.
+//
+// 148.1 THE SEGMENT PROBE DECIDES A MISS EXACTLY.  `exactNode` (primitives.ts)
+//       answers "which stored node are these bytes?" without building the fold
+//       when a level-0 content segment is not a stored flat branch: a fold
+//       names a branch only when every child is named, and a segment is one
+//       flat node over single-byte atoms.  So the answer must equal
+//       `foldTree(perceive(bytes))` on EVERY span — hits, misses, edges — and
+//       this walks every sub-span of real deposits and of noise to show it.
+//
+// 148.3 THE IDENTITY FOLD HAS THE VECTOR FOLD'S SHAPE.  `exactNode` names a
+//       stream through `contentIdentity` (geometry.ts), which groups the same
+//       way the vector fold does but reads an item's gist only where the shape
+//       does — the eight coordinates `itemKey` hashes inside an over-long row —
+//       and computes those lazily.  Pinned with an interning namer, so every
+//       node is named and the two folds must agree on EVERY node of the tree,
+//       over streams long and repetitive enough to force over-long rows (low
+//       entropy keeps the cut levels flat, so the split falls to `itemKey`).
+//
+// 148.2 THE ASCII CANON IS THE UNICODE CANON.  `textCanon` takes a byte loop
+//       for ASCII input instead of decode → NFKC → lowercase → regex → encode.
+//       NFKC is the identity on ASCII and the regex's ASCII whitespace is
+//       TAB..CR and SPACE, so the two must agree byte for byte; the reference
+//       here is the general reading, spelled out, over random ASCII drawn from
+//       an alphabet that is mostly whitespace and case.
+
+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 { exactNode, foldTree, perceive } from "../dist/src/mind/primitives.js";
+import { textCanon } from "../dist/src/canon.js";
+import { bytesToTree, contentIdentity } from "../dist/src/geometry.js";
+
+const enc = new TextEncoder();
+const dec = new TextDecoder("utf-8", { fatal: false });
+
+/** Deterministic generator — the suite forbids Math.random in fixtures. */
+function lcg(seed) {
+  let x = seed >>> 0;
+  return () => {
+    x = (Math.imul(x, 1664525) + 1013904223) >>> 0;
+    return x / 0x100000000;
+  };
+}
+
+test("148.1 exactNode agrees with the full fold on every sub-span", async () => {
+  const mind = new Mind({
+    seed: 3,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  const facts = [
+    ["The director of Eva is Gustaf Molander.", "Gustaf Molander"],
+    ["gustaf molander country", "The country of Gustaf Molander is Sweden."],
+    ["What is the capital of France", "The capital of France is Paris"],
+    ["ice", "cold"],
+  ];
+  await mind.ingest(facts);
+
+  const rand = lcg(148);
+  const noise = Array.from(
+    { length: 6 },
+    () =>
+      Array.from(
+        { length: 24 },
+        () => "abcdefghij ETAOIN.,"[Math.floor(rand() * 19)],
+      ).join(""),
+  );
+  const streams = [...facts.flat(), ...noise].map((t) => enc.encode(t));
+
+  let hits = 0, misses = 0;
+  for (const bytes of streams) {
+    for (let a = 0; a < bytes.length; a++) {
+      for (let b = a + 1; b <= bytes.length; b++) {
+        const span = bytes.subarray(a, b);
+        const full = foldTree(mind, perceive(mind, span), 0).node;
+        assert.equal(
+          exactNode(mind, span),
+          full,
+          `span "${
+            dec.decode(span)
+          }": the segment probe disagrees with the fold`,
+        );
+        if (full === null) misses++;
+        else hits++;
+      }
+    }
+  }
+  // Non-vacuity: both outcomes must be exercised, or agreement proves nothing.
+  assert.ok(hits > 50, `too few hits to pin the agreement (${hits})`);
+  assert.ok(misses > 1000, `too few misses to pin the agreement (${misses})`);
+  await mind.store.close();
+});
+
+test("148.2 the ASCII canon equals the Unicode canon, byte for byte", () => {
+  const reference = (bytes) =>
+    enc.encode(
+      dec.decode(bytes).normalize("NFKC").toLowerCase().replace(
+        /(\S)\s+(?=\S)/g,
+        "$1 ",
+      ),
+    );
+  // Mostly the characters the rule is about: every ASCII whitespace, both
+  // cases, punctuation, plus the control bytes JS's \s does NOT include.
+  const alphabet = [
+    0x20,
+    0x09,
+    0x0a,
+    0x0b,
+    0x0c,
+    0x0d,
+    0x1c,
+    0x1f,
+    0x00,
+    0x7f,
+    ..."aZ.,'Q9 ".split("").map((c) => c.charCodeAt(0)),
+  ];
+  const rand = lcg(2);
+  const cases = [
+    "",
+    " ",
+    "  lead",
+    "trail  ",
+    "a  b\t\tc\n\nD",
+    "\t\v\f\r",
+    "ALL CAPS",
+  ].map((t) => enc.encode(t));
+  for (let i = 0; i < 4000; i++) {
+    const n = Math.floor(rand() * 14);
+    cases.push(
+      Uint8Array.from(
+        { length: n },
+        () => alphabet[Math.floor(rand() * alphabet.length)],
+      ),
+    );
+  }
+  for (const c of cases) {
+    assert.deepEqual(
+      [...textCanon(c)],
+      [...reference(c)],
+      `canon of ${JSON.stringify(dec.decode(c))} diverged`,
+    );
+  }
+});
+
+test("148.3 the identity fold groups exactly as the vector fold", () => {
+  const mind = new Mind({
+    seed: 5,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  const ids = new Map();
+  const intern = (key) => {
+    let id = ids.get(key);
+    if (id === undefined) ids.set(key, id = ids.size);
+    return id;
+  };
+  const atoms = (bytes) => Array.from(bytes, (b) => -(b + 1)).join(",");
+  /** foldTree's naming, over the vector fold's tree. */
+  const name = (n) =>
+    n.kids === null ? -(n.leaf[0] + 1) : intern(n.kids.map(name).join(","));
+  const rand = lcg(1483);
+  const alphabets = ["ab", "aab", "abc ", "0123456789", "the quick brown fox "];
+  let streams = 0;
+  for (const alpha of alphabets) {
+    for (let t = 0; t < 40; t++) {
+      const n = 2 + Math.floor(rand() * 1500);
+      const bytes = Uint8Array.from(
+        { length: n },
+        () => alpha.charCodeAt(Math.floor(rand() * alpha.length)),
+      );
+      const viaVectors = name(bytesToTree(mind.space, mind.alphabet, bytes));
+      const viaIdentity = contentIdentity(
+        mind.space,
+        mind.alphabet,
+        bytes,
+        (from, to) =>
+          to - from === 1
+            ? -(bytes[from] + 1)
+            : intern(atoms(bytes.subarray(from, to))),
+        (kids) => intern(kids.join(",")),
+      );
+      assert.equal(viaIdentity, viaVectors, `${alpha} stream of ${n} bytes`);
+      streams++;
+    }
+  }
+  assert.equal(streams, 200);
+});

package/test/149-the-closure-engine.test.mjs

@@ -0,0 +1,138 @@
+// 149-the-closure-engine.test.mjs — one closure, over layers.
+//
+// `closeOver` (derivation.ts) closes a derivation under the law, layer by layer:
+// each layer OFFERS, the law admits, and the state a layer reaches is the state
+// the next one is offered against.  The pipeline's post-grounding stage is that
+// engine with two layers (the walk, the fusion), so the gates it used to spell
+// by hand are now the law's or the layer's.  Pinned:
+//
+//   149.1 ¬FIXED is the engine's, applied before any layer pays: a fixed state
+//         enters no layer — no offer is asked, nothing is wrapped.
+//   149.2 layers are PHASES, in order, never revisited: the second layer is
+//         offered the first one's final state, and the first is not asked again.
+//   149.3 a layer that does not ENGAGE is not entered at all.
+//   149.4 the law's refusal ends THAT layer's walk, not the closure.
+//   149.5 the pipeline asks the engine, and sequences no layer by hand.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { closeOver } from "../dist/src/mind/derivation.js";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const enc = new TextEncoder();
+const QUERY = enc.encode("ABCDEFGHIJKL");
+const W = 4;
+const state = (extra = {}) => ({
+  product: new Uint8Array(0),
+  accounted: [],
+  remainder: [[0, 12]],
+  cost: 0,
+  ...extra,
+});
+/** A layer that offers the given products, one per ask, then nothing. */
+const layer = (name, products, log, extra = {}) => {
+  let i = 0;
+  return {
+    name,
+    offer: async (d) => {
+      log.push(`${name}:ask:${new TextDecoder().decode(d.product)}`);
+      if (i >= products.length) return null;
+      return {
+        product: enc.encode(products[i++]),
+        contains: true,
+        reaches: true,
+        cost: 1,
+      };
+    },
+    ...extra,
+  };
+};
+
+test("149.1 a fixed state enters no layer", async () => {
+  const log = [];
+  const entered = [];
+  const out = await closeOver(
+    state({ fixed: true }),
+    QUERY,
+    W,
+    [layer("a", ["x"], log)],
+    async (name, walk) => {
+      entered.push(name);
+      return walk();
+    },
+  );
+  assert.deepEqual(log, [], "no offer may be asked of a fixed state");
+  assert.deepEqual(entered, [], "no layer may be entered for a fixed state");
+  assert.equal(out.fixed, true);
+});
+
+test("149.2 layers are phases, in order, never revisited", async () => {
+  const log = [];
+  const out = await closeOver(state(), QUERY, W, [
+    layer("a", ["a1", "a2"], log),
+    layer("b", ["b1"], log),
+  ]);
+  assert.deepEqual(log, [
+    "a:ask:",
+    "a:ask:a1",
+    "a:ask:a2",
+    "b:ask:a2",
+    "b:ask:b1",
+  ]);
+  assert.equal(new TextDecoder().decode(out.product), "b1");
+  assert.equal(out.cost, 3, "every admitted step is priced");
+});
+
+test("149.3 a layer that does not engage is not entered", async () => {
+  const log = [];
+  const entered = [];
+  await closeOver(
+    state(),
+    QUERY,
+    W,
+    [layer("a", ["a1"], log, { engages: () => false }), layer("b", [], log)],
+    async (name, walk) => {
+      entered.push(name);
+      return walk();
+    },
+  );
+  assert.deepEqual(entered, ["b"]);
+  assert.deepEqual(log, ["b:ask:"]);
+});
+
+test("149.4 the law's refusal ends that layer, not the closure", async () => {
+  const log = [];
+  const refused = [];
+  const ends = [];
+  // `a` offers a step that neither carries nor reaches: the law refuses it.
+  const a = {
+    name: "a",
+    offer: async () => ({ product: enc.encode("zz"), contains: true, cost: 1 }),
+    onRefused: () => refused.push("a"),
+    onEnd: (from, to) => ends.push(["a", from === to]),
+  };
+  const out = await closeOver(state(), QUERY, W, [a, layer("b", ["b1"], log)]);
+  assert.deepEqual(refused, ["a"]);
+  assert.deepEqual(ends, [["a", true]], "a refused layer ends where it began");
+  assert.equal(new TextDecoder().decode(out.product), "b1");
+});
+
+test("149.5 the pipeline asks the engine and sequences no layer by hand", async () => {
+  const src = await readFile(
+    join(here, "..", "src", "mind", "pipeline.ts"),
+    "utf8",
+  );
+  const code = src.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
+  assert.match(code, /closeOver\(/, "the post-grounding stage is the engine");
+  assert.ok(
+    !/\breason\(|\bfuseAttention\(/.test(code),
+    "the pipeline calls a layer's walk directly again — offer it to the engine",
+  );
+  assert.ok(
+    !/decided\.complete\s*\?/.test(code),
+    "a complete grounding is the law's FIXED clause, applied by the engine",
+  );
+});

package/test/150-the-join-is-output-sensitive.test.mjs

@@ -0,0 +1,66 @@
+// 150-the-join-is-output-sensitive.test.mjs — the join is priced for the facts
+// a derivation STANDS ON, never for every fact the exploration REACHES.
+//
+// THE TRAP.  `deriveThrough` used to fire for every finalized out with a node.
+// A chain hop forks across every continuation (trap 13: the offer is the
+// corpus's own structure), so a form whose continuation is a hub reaches every
+// one of that hub's fixpoints — and each paid an entity scan, and each join it
+// fired was a new fact to scan.  Measured on the 31.7M-node store: a 46-byte
+// dialogue query reached 2,000+ fixpoints in a minute and passed 10 GB.  It is
+// the trap `recompleteNode` records, and the cure is `deepen`'s: the solve runs
+// to its lightest derivation, licenses the facts THAT derivation stood on, and
+// re-runs with their joins as ordinary rules, until no licensed fact joins.
+//
+// Pinned:
+//   150.1 the facts priced do not grow with the hub's degree — the same query
+//         over a hub of 8 continuations and of 32 prices the same facts;
+//   150.2 the answer is unchanged by the degree (the derivation is the same).
+
+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";
+
+/** "hello" → "hi there" (one first hop), then "hi there" forks across `n`
+ *  distinct replies — each a fixpoint fact the search reaches.  The filler
+ *  raises the corpus scale N so the hop's READ cap (√N) admits all `n`: on a
+ *  tiny store √N is 1–2 and no hub can be read at all.  Measured before the
+ *  license: 35 facts scanned at n = 8, 59 at n = 32. */
+async function hub(n) {
+  const mind = new Mind({
+    seed: 7,
+    profile: true,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  const pairs = [["hello", "hi there"]];
+  for (let k = 0; k < 1200; k++) {
+    pairs.push([`filler question ${k}`, `filler answer ${k}`]);
+  }
+  for (let k = 0; k < n; k++) {
+    pairs.push(["hi there", `reply number ${k} talks about topic ${k}.`]);
+  }
+  await mind.ingest(pairs);
+  return mind;
+}
+
+test("150.1 the join prices the derivation's facts, not the hub's", async () => {
+  const priced = [];
+  const answers = [];
+  for (const n of [8, 32]) {
+    const mind = await hub(n);
+    // The tail is bytes nothing learnt, so the cover is expensive and the
+    // search reaches every fixpoint of the hub before it settles.
+    answers.push(await mind.respondText("hello zqxv wbjk"));
+    const c = mind.lastCost.counters;
+    assert.ok(c.joinFacts > 0, "the derivation's facts are priced");
+    priced.push(c.joinFacts);
+    await mind.store.close();
+  }
+  assert.equal(
+    priced[1],
+    priced[0],
+    `facts priced grew with the hub's degree: ${priced.join(" → ")}`,
+  );
+  // 150.2 — the degree changes what the search REACHES, not what it chose.
+  assert.equal(answers[1], answers[0]);
+});

package/test/151-the-cover-pays-for-what-it-reaches.test.mjs

@@ -0,0 +1,142 @@
+// 151-the-cover-pays-for-what-it-reaches.test.mjs — the cover's expensive
+// premises are resolved where the search REACHES them, and a span's cheapest
+// completion dominates the rest.
+//
+// THE TRAP, four times.  Each of these paid for every candidate the search
+// could have used, before (or regardless of whether) it used it:
+//   • connectors — every touching pair of recognised sites was bridged before
+//     the search ran (measured on the 31.7M-node store: a 262-byte query
+//     recognised whole paid 23 bridges, 143,520 junction pops, 7.3 s of 7.9 s);
+//   • concept hops — every edge-less site paid a halo lookup, though the hop is
+//     priced at CONCEPT and the whole's own edge closes the cover at one STEP;
+//   • fusion — the post-grounding fusion climbed for a second point of
+//     attention even when primary's evidence spans the whole query, where no
+//     root can stand a quantum apart from it (3.7 s for an exact dialogue turn);
+//   • alternatives — a greeting's thousands of replies were each a completion of
+//     the same span, each fused and canonically resolved with its neighbours
+//     (122,096 pops, 5.4 s of an 8.6 s cover, to stand in the end on two hops).
+//
+// Pinned:
+//   151.1 a query recognised whole bridges no connector for its parts;
+//   151.2 an edge-less part's concept hop is not looked up when the whole
+//         closes the cover first;
+//   151.3 a grounding standing on the whole query pays no fusion climb;
+//   151.4 the work the cover generates does not grow with a hub's degree — the
+//         replies past the first are dominated, and the answer is unchanged.
+
+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 mind = new Mind({
+    seed: 7,
+    profile: true,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  await mind.ingest(pairs);
+  return mind;
+}
+
+const sitesOf = (mind, text) => {
+  mind.beginResponse();
+  try {
+    return mind.recogniseSpan(new TextEncoder().encode(text)).sites.map((
+      s,
+    ) => [s.start, s.end]);
+  } finally {
+    mind.endResponse();
+  }
+};
+
+test("151.1 a query recognised whole bridges no connector for its parts", async () => {
+  // `ab` and `cd` both continue and TOUCH in the query, so they are an offered
+  // connector pair; `abcd` is learnt whole and closes the cover at one STEP,
+  // before either part's rewrite (a STEP each) leaves the agenda.
+  const mind = await fixture([
+    ["ab", "x"],
+    ["cd", "y"],
+    ["abcd", "the whole"],
+  ]);
+  const sites = sitesOf(mind, "abcd");
+  assert.ok(
+    sites.some(([s, e]) => s === 0 && e === 2) &&
+      sites.some(([s, e]) => s === 2 && e === 4),
+    `the touching parts must be recognised for the pair to be offered: ${
+      JSON.stringify(sites)
+    }`,
+  );
+  assert.equal(await mind.respondText("abcd"), "the whole");
+  assert.equal(mind.lastCost.counters.coverBridges ?? 0, 0);
+  await mind.store.close();
+});
+
+test("151.2 an unreached concept hop is not looked up", async () => {
+  // `ab` and `cd` are learnt only as CONTINUATIONS: they lead somewhere (a halo)
+  // but have no edge of their own, so each is offered a concept hop.
+  const mind = await fixture([
+    ["abcd", "the whole"],
+    ["first", "ab"],
+    ["second", "cd"],
+  ]);
+  const sites = sitesOf(mind, "abcd");
+  assert.ok(
+    sites.length > 1,
+    `the edge-less parts must be recognised: ${JSON.stringify(sites)}`,
+  );
+  assert.equal(await mind.respondText("abcd"), "the whole");
+  assert.equal(mind.lastCost.counters.haloQueries ?? 0, 0);
+  await mind.store.close();
+});
+
+test("151.3 a grounding standing on the whole query pays no fusion climb", async () => {
+  // The answer carries none of the query's bytes, so the derivation stays open
+  // and the fusion layer engages — but primary's evidence is the whole query.
+  const mind = await fixture([
+    ["ab", "x"],
+    ["cd", "y"],
+    ["abcd", "the whole"],
+  ]);
+  assert.equal(await mind.respondText("abcd"), "the whole");
+  assert.equal(mind.lastCost.counters.climbs ?? 0, 0);
+  await mind.store.close();
+});
+
+/** "hello" → "hi there", then "hi there" forks across `n` replies — each a
+ *  fixpoint completing the same span.  The filler raises N so the hop's READ
+ *  cap (√N) admits all `n`. */
+async function hub(n) {
+  const pairs = [["hello", "hi there"]];
+  for (let k = 0; k < 1200; k++) {
+    pairs.push([`filler question ${k}`, `filler answer ${k}`]);
+  }
+  for (let k = 0; k < n; k++) {
+    pairs.push(["hi there", `reply number ${k} talks about topic ${k}.`]);
+  }
+  return await fixture(pairs);
+}
+
+test("151.4 a hub's degree does not grow the work the cover generates", async () => {
+  const generated = [];
+  const answers = [];
+  for (const n of [8, 32]) {
+    const mind = await hub(n);
+    // The tail is bytes nothing learnt, so the goal is PASS-priced and, before
+    // dominance, the search fused every reply with its neighbours.
+    answers.push(await mind.respondText("hello zqxv wbjk"));
+    const c = mind.lastCost.counters;
+    assert.ok(
+      c.searchDominated > 0,
+      "the replies past the first are dominated",
+    );
+    generated.push(c.searchPops - c.searchDominated);
+    await mind.store.close();
+  }
+  assert.equal(
+    generated[1],
+    generated[0],
+    `rule-generating pops grew with the hub's degree: ${generated.join(" → ")}`,
+  );
+  assert.equal(answers[1], answers[0]);
+});