@hviana/sema 0.8.1 → 0.8.3

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/14-scaling.test.mjs

@@ -158,14 +158,17 @@ test("training: recall work does NOT grow with the store (storage reads, not tim
     for (let i = from; i < to; i++) await mind.ingest(novelExperience(i, "g"));
   };
 
-  await grow(0, 300);
+  // 6x in RATIO is the signal; the absolute size is the cost.  100 -> 600
+  // keeps the same 6x step (and a SMALLER N makes the log-N growth relatively
+  // LARGER, so the 3x band below is not loosened by shrinking it).
+  await grow(0, 100);
   const small = await readsNow();
-  await grow(300, 1800); // 6x the corpus
+  await grow(100, 600); // 6x the corpus
   const large = await readsNow();
   await store.close();
 
   console.log(
-    `    content-index reads for one recall: N=300 → ${small}, N=1800 → ${large}`,
+    `    content-index reads for one recall: N=100 → ${small}, N=600 → ${large}`,
   );
 
   // 6x the corpus must not cost anywhere near 6x the reads. A genuinely
@@ -194,7 +197,7 @@ test("training: absolute deposition throughput clears a sane floor", async () =>
   // not one-time setup.
   for (let i = 0; i < 200; i++) await mind.ingest(novelExperience(i, "warm"));
 
-  const N = 1000;
+  const N = 400;
   let bytes = 0;
   const t0 = performance.now();
   for (let i = 0; i < N; i++) {
@@ -322,7 +325,7 @@ test("training: exact recall is preserved at scale", async () => {
 // growth exponent in corpus size is the proof — it must be well below linear.
 test("inference: cost is sublinear in corpus size (independent corpora)", async () => {
   const query = unknownInput(1024);
-  const sizes = [50, 200, 800, 3200];
+  const sizes = [50, 200, 800];
   const times = [];
 
   for (const n of sizes) {
@@ -370,7 +373,7 @@ test("inference: input is processed at a roughly constant KB/s (linear, not quad
   const mind = new Mind({ seed: 7, store });
   await mind.ingest(corpus(200, "inflen"));
 
-  const kbs = [0.5, 1, 2, 4, 8];
+  const kbs = [0.5, 1, 2, 4];
   const queries = kbs.map((kb) => unknownInput(kb * 1024));
   const bytes = queries.map((q) => new TextEncoder().encode(q).length);
 
@@ -452,7 +455,7 @@ test("inference: completion still fires inside long inputs", async () => {
   });
   await mind.ingest([["ice", "cold"], ["fire", "hot"], ["2+2", "4"]]);
 
-  for (const pad of [16, 64, 256, 1024]) {
+  for (const pad of [16, 64, 256]) {
     const filler = unknownInput(pad);
     const mid = filler.slice(0, filler.length >> 1);
     const end = filler.slice(filler.length >> 1);

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",

package/test/43-cast-analog-seat.test.mjs

@@ -65,6 +65,7 @@ test("CAST comparison: a nextOf-descendant analog is seated by its own bytes, no
   const dominant = {
     anchor: franceId,
     vote: 100,
+    idfVote: 100, // the fixture builds an Attention: the field has to exist
     ctx: enc("What is the capital of France?"),
     runs: [{ qs: 0, qe: 30, cs: 0, weight: 1 }],
   };
@@ -75,6 +76,7 @@ test("CAST comparison: a nextOf-descendant analog is seated by its own bytes, no
   const spainPoint = {
     anchor: spainAnalogSrcId,
     vote: 50,
+    idfVote: 50, // the fixture builds an Attention: the field has to exist
     ctx: enc("some other prompt"),
     runs: [{ qs: 32, qe: 62, cs: 0, weight: 1 }],
   };
@@ -85,6 +87,7 @@ test("CAST comparison: a nextOf-descendant analog is seated by its own bytes, no
         {
           anchor: franceId,
           vote: 100,
+          idfVote: 100, // the fixture builds an Attention: the field has to exist
           start: 0,
           end: 30,
           breadth: 1,
@@ -95,6 +98,7 @@ test("CAST comparison: a nextOf-descendant analog is seated by its own bytes, no
         {
           anchor: franceId,
           vote: 100,
+          idfVote: 100, // the fixture builds an Attention: the field has to exist
           start: 0,
           end: 30,
           breadth: 1,
@@ -103,6 +107,7 @@ test("CAST comparison: a nextOf-descendant analog is seated by its own bytes, no
         {
           anchor: spainAnalogSrcId,
           vote: 50,
+          idfVote: 50, // the fixture builds an Attention: the field has to exist
           start: 32,
           end: 62,
           breadth: 0.5,
@@ -174,6 +179,7 @@ test("CAST comparison: a DIRECTLY aligned analog is never re-projected past its
   const dominant = {
     anchor: franceId,
     vote: 100,
+    idfVote: 100, // the fixture builds an Attention: the field has to exist
     ctx: enc("What is the capital of France?"),
     runs: [{ qs: 0, qe: 30, cs: 0, weight: 1 }],
   };
@@ -182,6 +188,7 @@ test("CAST comparison: a DIRECTLY aligned analog is never re-projected past its
   const japanPoint = {
     anchor: japanId,
     vote: 50,
+    idfVote: 50, // the fixture builds an Attention: the field has to exist
     ctx: enc("What is the capital of Japan? Tokyo is the capital of Japan."),
     runs: [{ qs: 32, qe: 62, cs: 0, weight: 1 }],
   };
@@ -192,6 +199,7 @@ test("CAST comparison: a DIRECTLY aligned analog is never re-projected past its
         {
           anchor: franceId,
           vote: 100,
+          idfVote: 100, // the fixture builds an Attention: the field has to exist
           start: 0,
           end: 30,
           breadth: 1,
@@ -202,6 +210,7 @@ test("CAST comparison: a DIRECTLY aligned analog is never re-projected past its
         {
           anchor: franceId,
           vote: 100,
+          idfVote: 100, // the fixture builds an Attention: the field has to exist
           start: 0,
           end: 30,
           breadth: 1,
@@ -210,6 +219,7 @@ test("CAST comparison: a DIRECTLY aligned analog is never re-projected past its
         {
           anchor: japanId,
           vote: 50,
+          idfVote: 50, // the fixture builds an Attention: the field has to exist
           start: 32,
           end: 62,
           breadth: 0.5,