@hviana/sema 0.8.2 → 0.8.3

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

package/test/129-the-trace-payload-shape.test.mjs

@@ -0,0 +1,164 @@
+// 129-the-trace-payload-shape.test.mjs — THE PAYLOAD'S SHAPE, PINNED
+//
+// The climb's trace payload (`ClimbConsensusData`, `version: 1`) is built by
+// hand next to the internal `TraceDraft` that feeds it, and the pair has
+// already drifted once (`visited?` — "Absent on payloads recorded before this
+// field existed").  The draft is NOT exported, so a test cannot compare the two
+// side by side (and exporting it just for a test would be new plumbing the
+// architecture forbids).  What CAN be pinned from outside is the payload's
+// SHAPE: a closed key set per section, so that a field added, removed or
+// renamed on one side of the pair cannot pass unnoticed.
+//
+// The sets below are MEASURED from a real payload (printed before being
+// written), not chosen.  If this test fails, the payload changed: update the
+// section it names AND the draft that feeds it AND the note in attention.ts
+// that says which fields older payloads lack.
+//
+// The sections are optional by design (that is what keeps recorded payloads
+// valid); this query produces ALL of them, and the test asserts that too, so a
+// section silently disappearing is caught rather than tolerated.
+
+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 = [
+  ["red", "is a color"],
+  ["blue", "is a color"],
+  ["circle", "is a shape"],
+  ["square", "is a shape"],
+  ["red circle", "answer alpha"],
+  ["red square", "answer beta"],
+  ["blue circle", "answer gamma"],
+  ["blue square", "answer delta"],
+];
+
+const TOP = [
+  "anchors",
+  "cache",
+  "candidates",
+  "config",
+  "crossRegion",
+  "pooling",
+  "reaches",
+  "regions",
+  "result",
+  "saturation",
+  "version",
+];
+const REQUIRED = ["cache", "candidates", "config", "result", "version"];
+const SECTIONS = {
+  cache: ["detailAvailable", "hit"],
+  config: [
+    "annK",
+    "consensusFloor",
+    "corpusN",
+    "crossRegionProbeLimit",
+    "dimension",
+    "estimatorNoise",
+    "hubBound",
+    "mode",
+    "naturalBreak",
+  ],
+  candidates: ["perceived", "recognised", "total"],
+  crossRegion: [
+    "eligibleRegions",
+    "junctionVotes",
+    "maximalRegions",
+    "probeLimit",
+    "probes",
+    "probesAttempted",
+    "stopReason",
+    "supersededOrdinaryVotes",
+  ],
+  saturation: ["hasLeading", "leadingEnd", "regionIntervals"],
+  pooling: ["eligibleVotes", "inputVotes", "saturationMaskedVotes"],
+};
+const ANCHOR = [
+  "anchor",
+  "breadth",
+  "candidateBreadth",
+  "clusters",
+  "commit",
+  "contributingEvidence",
+  "contributingSpans",
+  "contributingVotes",
+  "idfVote",
+  "peak",
+  "pooledVote",
+  "rank",
+];
+const REGION = [
+  "annHitsExamined",
+  "annHitsReturned",
+  "annQueried",
+  "canonicalFailed",
+  "canonicalId",
+  "canonicalUsable",
+  "chunk",
+  "dfWeight",
+  "focusWeightPerRoot",
+  "idf",
+  "index",
+  "known",
+  "mutualWeight",
+  "ordinaryVoteProduced",
+  "outcome",
+  "reachNode",
+  "selected",
+  "source",
+  "span",
+  "superseded",
+  "voteWeightPerRoot",
+];
+
+/** The payload, found the way a reader finds it: deep in the recorded steps. */
+function findPayload(steps) {
+  const walk = (o, depth) => {
+    if (o === null || typeof o !== "object" || depth > 6) return null;
+    if (o.version === 1 && o.config && o.result) return o;
+    for (const v of Object.values(o)) {
+      const hit = walk(v, depth + 1);
+      if (hit) return hit;
+    }
+    return null;
+  };
+  for (const step of steps) {
+    const hit = walk(step.data, 0);
+    if (hit) return hit;
+  }
+  return null;
+}
+
+test("the climb trace payload keeps its published shape", async () => {
+  const m = new Mind({ seed: 1, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest(CORPUS);
+  const steps = [];
+  await m.respondText("red then circle", (step) => steps.push(step));
+  const payload = findPayload(steps);
+  assert.ok(payload, "no version:1 payload with config+result was recorded");
+
+  assert.deepEqual(Object.keys(payload).sort(), TOP);
+  for (const key of REQUIRED) {
+    assert.ok(key in payload, `required section ${key} is missing`);
+  }
+  for (const [name, keys] of Object.entries(SECTIONS)) {
+    assert.ok(payload[name] !== undefined, `section ${name} is absent`);
+    assert.deepEqual(
+      Object.keys(payload[name]).sort(),
+      keys,
+      `section ${name} changed shape`,
+    );
+  }
+  assert.ok(payload.anchors.length > 0, "no anchors recorded");
+  assert.deepEqual(Object.keys(payload.anchors[0]).sort(), ANCHOR);
+  assert.ok(payload.regions.length > 0, "no regions recorded");
+  assert.deepEqual(Object.keys(payload.regions[0]).sort(), REGION);
+  assert.ok(
+    Array.isArray(payload.anchors[0].commit.rejectionReasons),
+    "an anchor's commit no longer carries its rejection reasons",
+  );
+
+  await m.store.close();
+});

package/test/32-confluence.test.mjs

@@ -171,3 +171,71 @@ test("E1 — the intersection is seed-independent (it is exact, not resonant)",
     await m.store.close();
   }
 });
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Section F — the early-exit budget: live, but never pruning
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("F1 — the two streams are found well inside the early-exit's budget", async () => {
+  // The mechanism scans the climb's ranked anchors with two cuts: `ranked.slice(0,
+  // pre.k)` and an early exit after `2W` anchors that returns null when fewer than
+  // two constraint streams exist.  Both are spec-legal (a capacity, and a formula
+  // over W — config.ts's default `maxGroup` is 4) but neither was DERIVED; what
+  // makes them legitimate is that they do not prune the case they exist to protect.
+  //
+  // MEASURED on this corpus: the two streams appear at ranks 1 and 4 against the
+  // budget of 8, while `ranked` is 9 — the cut IS live (it would have returned
+  // null at the 8th anchor) and it does NOT prune.  The last assertion is the
+  // anti-vacuity guard: if `ranked` ever fell to 8 or below, this test would be
+  // pinning nothing at all.
+  const W = 4; // the engine's default quantum: config.ts, geometry.maxGroup
+  const m = new Mind({
+    seed: 7,
+    store: new SQliteStore({ path: ":memory:" }),
+    profile: true,
+  });
+  await m.ingest(materials);
+  const steps = [];
+  await m.respondText(
+    "Which material is translucent and featherlight?",
+    (s) => steps.push(s),
+  );
+  await m.store.close();
+
+  const findAnchors = (o, depth = 0) => {
+    if (o === null || typeof o !== "object" || depth > 5) return null;
+    if (Array.isArray(o.anchors) && o.anchors.length) return o;
+    for (const v of Object.values(o)) {
+      const r = findAnchors(v, depth + 1);
+      if (r) return r;
+    }
+    return null;
+  };
+  const step = steps.find((s) => findAnchors(s.data ?? s) !== null);
+  const td = step ? findAnchors(step.data ?? step) : null;
+  assert.ok(td, "the climb must report its anchors");
+
+  const meet = steps.find((s) =>
+    (s.mechanism ?? []).join("/").includes("intersectEvidence")
+  );
+  assert.ok(meet, "confluence must ENTER on a conjunctive query");
+
+  const ranks = (meet.inputs ?? [])
+    .filter((i) => typeof i.node === "number")
+    .map((i) => (td.anchors.find((a) => a.anchor === i.node) ?? {}).rank);
+  assert.ok(
+    ranks.length >= 2,
+    `the meet needs two streams (got ${ranks.length})`,
+  );
+  assert.ok(
+    Math.max(...ranks) < 2 * W,
+    `the streams must appear inside the budget (ranks ${
+      ranks.join(",")
+    } vs 2W=${2 * W})`,
+  );
+  assert.ok(
+    td.anchors.length > 2 * W,
+    `and the cut must be live on this fixture, else this test pins nothing ` +
+      `(ranked=${td.anchors.length}, 2W=${2 * W})`,
+  );
+});

package/test/38-reason-restate-guard.test.mjs

@@ -57,7 +57,10 @@ test("reason(): a forward hop landing on bytes already present in the query is r
     queryResolved: resolve(m, query),
   };
 
-  const out = await reason(m, query, answer, new Set(), pre);
+  // `reason()` reports the WHOLE extension (bytes + what it carried + how many
+  // steps) so a caller can price it; these assertions measure the bytes, and
+  // that is all this change touches — the law they pin is untouched.
+  const out = (await reason(m, query, answer, new Set(), pre)).bytes;
   assert.equal(
     dec(out),
     "bridge context",
@@ -82,7 +85,10 @@ test("reason(): an ordinary forward hop onto genuinely new content is unaffected
     queryResolved: resolve(m, query),
   };
 
-  const out = await reason(m, query, answer, new Set(), pre);
+  // `reason()` reports the WHOLE extension (bytes + what it carried + how many
+  // steps) so a caller can price it; these assertions measure the bytes, and
+  // that is all this change touches — the law they pin is untouched.
+  const out = (await reason(m, query, answer, new Set(), pre)).bytes;
   assert.equal(
     dec(out),
     "a wholly new fact never mentioned in any query",