@hviana/sema 0.8.1 → 0.8.3

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`,
+  );
+});

package/test/122-the-climb-search-does-not-grow-with-the-corpus.test.mjs

@@ -0,0 +1,117 @@
+// 122-the-climb-search-does-not-grow-with-the-corpus.test.mjs — the climb's own
+// search must be flat in the corpus too.
+//
+// THE LAW, applied to the last path that was not measured.  test/119 pins the
+// DERIVATION's work, test/121 the post-grounding extension.  The consensus climb
+// runs a search of its own (`lightestDerivation` over a pooling DeductionSystem,
+// attention.ts) and until item 3 of the open list that search was not even
+// timed — its cost was invisible.  It is now a phase (`climb.derivation`), and
+// the phase carries work-counter deltas, which is the honest growth measure: a
+// millisecond reading is noise, a read count is work.
+//
+// MEASURED BEFORE THIS TEST EXISTED, one call per size, byte-identical answer:
+//
+//     N= 250 → climb.derivation: calls=1, counters {edgeProbes: 3, prevReads: 23}
+//     N= 500 → climb.derivation: calls=1, counters {edgeProbes: 3, prevReads:  7}
+//     N=1000 → climb.derivation: calls=1, counters {edgeProbes: 3, prevReads:  7}
+//     N=2000 → climb.derivation: calls=1, counters {edgeProbes: 3, prevReads:  7}
+//     searchPops = 338 at every size
+//
+// THE ASSERTION IS NON-GROWTH, WHICH IS WHAT THE LAW SAYS (`bounded-reads.md`: no
+// per-query read grows with N) — not equality of counters, because `prevReads` is
+// genuinely smaller at the larger sizes (23 → 7).  `searchPops` IS asserted equal,
+// because that is what the measurement shows for this fixture.
+//
+// THE ANTI-VACUITY GUARD: `calls >= 1` at every size.  A flat curve for a phase
+// that never ran would prove nothing, and a walk with no pivot does not enter it.
+
+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").split(" ");
+
+/** test/109's two-fact chain — the pivot is what crosses the hop — plus `n`
+ *  unrelated pairs, exactly the fixture whose numbers are recorded above. */
+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;
+  await store.close();
+  const phase = (c.phases ?? {})["climb.derivation"];
+  return {
+    answer,
+    calls: phase?.calls ?? 0,
+    counters: phase?.counters ?? {},
+    pops: c.counters?.searchPops ?? 0,
+  };
+}
+
+test("a bigger corpus does not buy the climb's search more work", async () => {
+  const base = 250;
+  const runs = [];
+  for (const mult of [1, 2, 4, 8]) {
+    const r = await measure(base * mult);
+    runs.push(r);
+    console.log(
+      `    N=${base * mult} → climb.derivation calls=${r.calls}, ` +
+        `counters ${JSON.stringify(r.counters)}, pops ${r.pops}`,
+    );
+  }
+
+  // ANTI-VACUITY: the phase must actually run at every size.
+  for (const [i, r] of runs.entries()) {
+    assert.ok(
+      r.calls >= 1,
+      `the climb's search must run at N=${base * 2 ** i} (calls=${r.calls})`,
+    );
+  }
+  assert.equal(
+    new Set(runs.map((r) => r.answer)).size,
+    1,
+    `the answer must not move with the corpus (got ${
+      JSON.stringify(runs.map((r) => r.answer))
+    })`,
+  );
+
+  // NON-GROWTH, counter by counter: what the search reads at 8N must not exceed
+  // what it reads at N.  (A counter absent at the small size counts as 0.)
+  const first = runs[0].counters;
+  const last = runs[runs.length - 1].counters;
+  for (const name of new Set([...Object.keys(first), ...Object.keys(last)])) {
+    const a = first[name] ?? 0;
+    const b = last[name] ?? 0;
+    assert.ok(
+      b <= a,
+      `${name} grew with the corpus: ${a} at N=${base} → ${b} at N=${base * 8}`,
+    );
+  }
+
+  // And the agenda pops of the whole response are identical across sizes.
+  assert.equal(
+    new Set(runs.map((r) => r.pops)).size,
+    1,
+    `agenda pops must not move (got ${
+      JSON.stringify(runs.map((r) => r.pops))
+    })`,
+  );
+});

package/test/123-the-paired-formulas-agree.test.mjs

@@ -0,0 +1,90 @@
+// 123 — the derived formulas the house writes PER SIDE have to agree.
+//
+// The structural review (finding 9) found four derived quantities duplicated
+// by design: `hubBound`, `atomIsHub`/`atomReach`, `leadsSomewhere` and the
+// interior's phrase scale.  `graph-search.ts` is *host-based* on purpose (it
+// does not know `MindContext`), so the formula repeats — and the house
+// recorded that it HAS DRIFTED once ("they had already drifted on the
+// `Math.max(2, …)` floor", attention.ts).
+//
+// A pair test cannot call both homes (one is private), but it CAN read the
+// code — as `test/88-dependency-footprint` reads imports.  Each pair is
+// extracted by its own pattern, and if the extraction finds no formula the
+// test FAILS: finding nothing would leave the pair comparing against nothing,
+// the vacuous-pass class `prefix-completion.ts` names.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+
+const SRC = (p) =>
+  readFileSync(new URL(`../dist/src/${p}`, import.meta.url), "utf8");
+
+/** Extract `pattern` and return normalised group 1 — or fail, naming the file. */
+function extract(file, pattern, what) {
+  const text = SRC(file);
+  const m = text.match(pattern);
+  assert.ok(
+    m !== null,
+    `could not find ${what} in ${file} — the pair test would compare nothing ` +
+      `(pattern: ${pattern}). Update the pattern WITH the formula.`,
+  );
+  return m[1].replace(/\s+/g, "").replace(/ctx\.store|this\.store/g, "S");
+}
+
+test("123. the duplicated derived formulas agree, home by home", () => {
+  // ── (1) hubBound = ⌈√max(2, N)⌉, in traverse.ts and in graph-search.ts ──
+  // The PAIR is the floor and the root — NOT how each home obtains N: one takes
+  // it as a parameter (`boundFor(contextCount)`), the other reads it from the
+  // store.  Comparing the argument would compare the two call shapes instead of
+  // the formula, which is what the drift the house recorded was about.
+  const SHAPE = /Math\.ceil\(Math\.sqrt\(Math\.max\(2,\s*[^)]*\)\)\)/;
+  const shapeOf = (file, what) => {
+    const m = SRC(file).match(SHAPE);
+    assert.ok(
+      m !== null,
+      `could not find ${what} in ${file} (pattern: ${SHAPE})`,
+    );
+    return m[0].replace(/\s+/g, "").replace(
+      /Math\.max\(2,\s*[^)]*\)/,
+      "max(2,N)",
+    );
+  };
+  assert.equal(
+    shapeOf("mind/traverse.js", "boundFor's hub-bound shape"),
+    shapeOf("mind/graph-search.js", "GraphSearch.hubBound's shape"),
+    "the hub-bound formula has drifted between traverse.ts and graph-search.ts",
+  );
+
+  // ── (2) atomReach = max(1, ⌈N·W/256⌉), in traverse.ts and in graph-search.ts ──
+  // Each home names N and W differently (a parameter and `ctx.space.maxGroup`
+  // against the store's edge-source count and the local `W`), so the PAIR is the
+  // arithmetic shape — the `256` and the floor.
+  const reachShape = (file, what) =>
+    extract(
+      file,
+      /Math\.max\(1,\s*Math\.ceil\(\((?:[^()]|\([^()]*\))*\*\s*[A-Za-z_.]+\)\s*\/\s*(256)\)\)/,
+      what,
+    );
+  assert.equal(
+    reachShape("mind/traverse.js", "atomReach's shape"),
+    reachShape("mind/graph-search.js", "the atomsAreHubs shape"),
+    "the atom-reach formula has drifted between traverse.ts and graph-search.ts",
+  );
+
+  // ── (4) the interior phrase-scale allowance, in resonance.ts and attention.ts ──
+  const resonance = extract(
+    "mind/resonance.js",
+    /maxInterior\s*=\s*[^;]*?\(\s*([A-Za-z_.]+\.length\s*\+\s*[A-Za-z_.]+\.length)\s*\)\s*\*\s*([A-Za-z_.]+\.maxGroup)/,
+    "bridgeUncached's maxInterior",
+  );
+  const attention = extract(
+    "mind/attention.js",
+    /maxSiblingBytes\s*=\s*\(([A-Za-z_.]+Len\s*\+\s*[A-Za-z_.]+Len)\)\s*\*\s*([A-Za-z_.]+\.maxGroup)/,
+    "maxSiblingBytes",
+  );
+  assert.equal(
+    resonance.replace(/[A-Za-z_.]*\.length/g, "LEN"),
+    attention.replace(/[A-Za-z_.]*Len/g, "LEN"),
+    "the interior phrase-scale allowance has drifted between resonance.ts and attention.ts",
+  );
+});

package/test/125-the-post-grounding-branch-publishes-its-operand.test.mjs

@@ -0,0 +1,51 @@
+// 125 — the post-grounding branch publishes WHAT IT READ.
+//
+// Post-grounding decides on `decided.used` and on the provenance NAME.  Those
+// operands were not in the trace, so a change to the branch could not be shown
+// equivalent (or not) from outside: three separate investigations failed in
+// exactly that interval.  A gap in instrumentation is a defect IN the
+// instrumentation (AGENTS.md §6) — closed on the spot, once, as COUNTS, never
+// content.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+test("125. the post-grounding branch publishes its operand", async () => {
+  const { Mind, SQliteStore } = await import("../dist/src/index.js");
+  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"],
+    ["2+2", "2+2 equals 4"],
+    ["Gustaf Molander", "Gustaf Molander was a Swedish film director"],
+  ]);
+  const steps = [];
+  await mind.respondText("who was Gustaf Molander", (s) => steps.push(s));
+  await store.close();
+  const pg = steps.filter((p) => p.data && p.data.usedDeclared !== undefined);
+  assert.ok(
+    pg.length >= 1,
+    `the response must emit a postGrounding step carrying the operand ` +
+      `(steps with data: ${
+        steps.filter((p) => p.data).map((p) => String(p.note).slice(0, 24))
+          .join(" | ")
+      })`,
+  );
+  const d = pg[pg.length - 1].data;
+  assert.equal(
+    typeof d.usedDeclared,
+    "boolean",
+    "usedDeclared states whether `used` arrived",
+  );
+  assert.equal(
+    typeof d.preConsumed,
+    "number",
+    "preConsumed is a COUNT, never content",
+  );
+  assert.equal(typeof d.voiced, "number", "voiced is a COUNT, never content");
+  assert.equal(
+    typeof d.provenance,
+    "string",
+    "the name the OLD branch read is published too",
+  );
+});

package/test/126-the-pipeline-does-not-name-mechanisms.test.mjs

@@ -0,0 +1,42 @@
+// 126 — the pipeline does NOT know mechanisms by name.
+//
+// `pipeline-mechanism.ts` promises, in its header: "it never imports a
+// mechanism-specific type and never has a special-case branch for any
+// mechanism".  Post-grounding broke that: it decided on a provenance NAME
+// (cast/join/recall/recall-echo) rather than on what the mechanism
+// DECLARES in its result.  The contract already has the right mould:
+// `MechanismResult.complete`, whose doc says "the decider honours the
+// property and never asks which mechanism set it".  This test pins the
+// property, not the implementation — no mechanism name in pipeline.js.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+
+const NOMES =
+  /[=!]==?\s*"(cast|join|recall|recall-echo|cover|extract|prefix|reference|alu)"/;
+
+test("126. the pipeline branches on what a mechanism DECLARES, not on its name", () => {
+  const src = readFileSync(
+    new URL("../dist/src/mind/pipeline.js", import.meta.url),
+    "utf8",
+  );
+  // ANTI-VACUITY: the file has to be the right one and has to talk about
+  // provenance — otherwise the test would pass on an empty file.
+  assert.ok(src.length > 2000, `pipeline.js looks wrong (${src.length} bytes)`);
+  assert.ok(
+    src.includes("provenance"),
+    "pipeline.js must mention provenance at all",
+  );
+  const nomes = src.split("\n")
+    .map((l, i) => [i + 1, l])
+    .filter(([, l]) => NOMES.test(l))
+    .map(([i, l]) => `${i}: ${l.trim().slice(0, 90)}`);
+  assert.deepEqual(
+    nomes,
+    [],
+    `the pipeline compares provenance against a mechanism NAME, which the market ` +
+      `contract forbids (it must read a declaration instead):\n  ${
+        nomes.join("\n  ")
+      }`,
+  );
+});

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

@@ -0,0 +1,83 @@
+// 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)`.
+//
+// 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.
+//
+// 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
+// on a 6-fact and on a 10-fact corpus).  The halo clause of the pair therefore
+// cannot be exercised here at all — the pin's last guard asserts that measured
+// zero, so that a future corpus which DOES carry halos turns this into a
+// signal to extend the pin.  What IS exercised: the agreement itself, node by
+// node, over every node the corpus mints, with guards so an all-false walk
+// cannot pass.
+
+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 CORPUS = [
+  "birds fly in the sky",
+  "planes fly in the sky",
+  "kites fly in the sky",
+  "arrows fly in the sky",
+  "the sky is blue",
+  "the sea is blue",
+  "ice is cold",
+  "steel is cold",
+  "water boils at one hundred degrees",
+  "iron melts at one thousand degrees",
+];
+
+test("the two homes of 'leads somewhere' agree, node by node", async () => {
+  const m = new Mind({ seed: 1, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest(CORPUS);
+
+  const total = m.store.nodeCount();
+  let withEdge = 0;
+  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 hasEdge = m.store.hasNext(id);
+    const hasHalo = m.store.hasHalo(id);
+    if (hasEdge) withEdge++;
+    if (hasHalo) withHalo++;
+    assert.equal(
+      named,
+      spelled,
+      `node ${id}: traverse.leadsSomewhere says ${named}, ` +
+        `primitives' spelling says ${spelled} (hasNext=${hasEdge}, hasHalo=${hasHalo})`,
+    );
+  }
+
+  assert.ok(total > 10, `corpus should mint more than 10 nodes, got ${total}`);
+  assert.ok(
+    withEdge > 0,
+    "no node in this corpus has a continuation: the edge side of the pair is untested",
+  );
+  // The halo side, measured: `withHalo` is 0 on these corpora (a 6-fact and a
+  // 10-fact one), so the halo clause of the pair cannot be exercised by a
+  // synthetic corpus of this shape — halos are poured on the WRITE side.  This
+  // is the pin's declared edge, not a hidden one: the agreement is pinned over
+  // every node the corpus mints, and the halo clause needs a store that
+  // carries halos to be pinned at all.
+  assert.equal(
+    withHalo,
+    0,
+    "these corpora now carry halos: extend this pin to exercise the halo clause",
+  );
+
+  await m.store.close();
+});