@hviana/sema 0.6.0 → 0.7.2

package/test/94-cross-region-budget.test.mjs

@@ -0,0 +1,67 @@
+// 94-cross-region-budget.test.mjs — the cross-region junction ladder shares ONE
+// k·W allowance per evidence tier once atoms are hubs, instead of letting each
+// candidate pair spend its own √N·W drift budget (attention.ts crossRegionVotes,
+// §2.17's derived gate = traverse.atomIsHub).
+//
+// This is a PERFORMANCE regression test, not a behaviour test: the shared
+// budget is byte-identical at every scale — a pair whose container is not
+// reached within the allowance falls through to the resonance tier exactly as a
+// per-pair walk that exhausted its own budget would — so the only observable is
+// the meter's junctionPops counter.  A ~4.3k-fact fixture is NOT optional:
+// atomIsHub is false in every small-store suite, so a conventional fixture
+// would pass while the per-pair drift (measured: 160k junction pops, 31% of
+// think) is fully present.  The atomIsHub assertion below fails loudly if the
+// crossover ever moves, so this suite can never silently stop covering the
+// branch it exists for.
+
+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 { atomIsHub, corpusN } from "../dist/src/mind/traverse.js";
+
+test("crossRegion shares one k·W allowance per tier once atoms are hubs", async () => {
+  const m = new Mind({
+    seed: 7,
+    store: new SQliteStore({ path: ":memory:" }),
+    profile: true,
+  });
+
+  // Common windows, each in ≤ √N contexts so the hub guard does NOT abstain —
+  // a non-hub cone is exactly the drift the shared budget must bound.  Three
+  // such windows ("aaaa", "bbbb", "cccc") that never co-occur give the query
+  // below three strong regions and three pairs, every one of whose junction
+  // walks drifts through both windows' cones and finds no container.
+  const per = 60;
+  const corpus = [];
+  for (const w of ["aaaa", "bbbb", "cccc"]) {
+    for (let i = 0; i < per; i++) corpus.push([`${w} ${i}`, `a ${w} ${i}`]);
+  }
+  // Filler edge sources push N past atomIsHub (N > ~4096 at maxGroup=4).
+  for (let i = 0; i < 4300; i++) corpus.push([`filler-${i}`, `f${i}`]);
+  await m.ingest(corpus);
+
+  const N = corpusN(m);
+  assert.ok(
+    atomIsHub(m, N),
+    `fixture must cross atomIsHub (N=${N}); the shared budget is scale-gated ` +
+      `and this suite would otherwise assert nothing`,
+  );
+
+  await m.respondText("aaaa bbbb cccc");
+
+  const c = m.lastCost;
+  const crossPops = c.phases["climb.crossRegion"]?.counters.junctionPops ?? 0;
+  const k = m.cfg.recallQueryK * 2; // pre.k — the ladder's pair budget breadth
+  const W = m.space.maxGroup;
+
+  assert.ok(crossPops > 0, "the query must actually run cross-region walks");
+  assert.ok(
+    crossPops <= 2 * k * W,
+    `crossRegion junction pops ${crossPops} must stay within the shared ` +
+      `2·k·W = ${2 * k * W} allowance (exact + synonym tiers), not the ` +
+      `per-pair √N·W drift`,
+  );
+
+  await m.store.close();
+});

package/test/95-wide-resonance-removed.test.mjs

@@ -0,0 +1,109 @@
+// 95-wide-resonance-removed.test.mjs — the substitution bridge and prefix
+// completion must propose from BOUNDED sources, never from the exhaustive-√N
+// ANN scan that `Precomputed.wideResonance()` used to run (removed; see
+// pipeline-mechanism.ts's REMOVED note).
+//
+// This is a PERFORMANCE regression test, not a behaviour test: the wide list
+// was a PROPOSAL source whose consumers byte-verify every candidate (§2.3), so
+// removing it is byte-identical wherever the bounded sources supply the same
+// candidate set — and the meter's phase map is the only observable that says
+// whether the exhaustive machinery still exists.  Red-on-revert: re-adding
+// wideResonance re-creates the `wideResonance` phase (and, when the query's
+// top hit clears conceptThreshold, a full-index ANN scan inside it), so the
+// phase-absence assertion below fails.
+
+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 dec = (b) => new TextDecoder().decode(b).replace(/\0+$/, "");
+
+// The test/49 resonance-proposed corpus: the query "what is the capital of
+// france" resonates STRAIGHT to the trained "What is the capital of France?"
+// (nearest whole-query hit, so its top hit clears conceptThreshold — the exact
+// condition that made the old wideResonance go exhaustive) yet falls below the
+// reach bar, so recall refuses and the bridge runs to recover the fact.
+const CORPUS = [
+  ["What is the capital of France?", "The capital of France is Paris."],
+  ["What is the capital of Spain?", "The capital of Spain is Madrid."],
+  ["What is the capital of Italy?", "The capital of Italy is Rome."],
+  // Lowercase mid-sentence occurrences attest the case-folded windows the
+  // substitution's corroboration gate requires.
+  ["He wrote of france and of spain.", "Then he flew home to italy."],
+  ["She spoke of france in her diary.", "Her diary told of france."],
+];
+
+test("the bridge's refusal path never descends the exhaustive-√N ANN scan", async () => {
+  const m = new Mind({
+    seed: 7,
+    store: new SQliteStore({ path: ":memory:" }),
+    profile: true,
+  });
+  await m.ingest(CORPUS);
+
+  const r = await m.respond("what is the capital of france");
+  assert.ok(
+    dec(r.bytes).includes("Paris"),
+    `the bridge must still ground the fact through its bounded proposals, got ${
+      JSON.stringify(dec(r.bytes))
+    }`,
+  );
+
+  const c = m.lastCost;
+  // The fixture actually ran the bridge — without this, a silently-skipped
+  // fixture would pass the phase-absence assertion while asserting nothing.
+  assert.ok(
+    c.phases["substitutionBridge"],
+    "the fixture must run the substitution bridge",
+  );
+  // The exhaustive-√N phase is gone.  Its removal is the whole point: the
+  // bridge's proposal source is the response's ONE top-k read (memoized), and
+  // every proposal is byte-verified downstream, so the full-index scan bought
+  // recall at O(index) cost for an O(k) need.
+  assert.equal(
+    c.phases["wideResonance"],
+    undefined,
+    "wideResonance (the exhaustive √N scan) must be removed from the response",
+  );
+  // The bridge phase itself accrues no content-index ANN reads: proposals come
+  // from the memoized `resonance()`, never a fresh exhaustive descend.
+  const bridgeAnn = c.phases["substitutionBridge"].counters.annVectorReads ?? 0;
+  assert.equal(
+    bridgeAnn,
+    0,
+    "the substitution bridge must not descend the content ANN on its own",
+  );
+
+  await m.store.close();
+});
+
+test("prefix completion proposes from the write-side window index, not the ANN", async () => {
+  const m = new Mind({
+    seed: 7,
+    store: new SQliteStore({ path: ":memory:" }),
+    profile: true,
+  });
+  await m.ingest(CORPUS);
+
+  // A strict byte-prefix of the trained answer form.  Its gist cannot rank its
+  // own continuation (cos falls below reachThreshold), so the content-addressed
+  // window walk is the correct proposal source — and the one prefix-completion
+  // now tries FIRST.
+  const r = await m.respond("The capital of France is");
+  assert.ok(
+    dec(r.bytes).includes("Paris"),
+    `expected the trained form through the content-addressed prefix supply, got ${
+      JSON.stringify(dec(r.bytes))
+    }`,
+  );
+
+  const c = m.lastCost;
+  assert.equal(
+    c.phases["wideResonance"],
+    undefined,
+    "wideResonance (the exhaustive √N scan) must be removed from the response",
+  );
+
+  await m.store.close();
+});