@hviana/sema 0.5.7 → 0.5.9

package/test/85-answered-directly.test.mjs

@@ -0,0 +1,126 @@
+// 85-answered-directly.test.mjs — a question that was answered DIRECTLY must not
+// run on to a further hop.
+//
+// THE DEFECT THIS PINS. `reason()` loops to a fixpoint, extending while the
+// current answer offers anywhere to go. Every stopping condition it had was
+// about the ANSWER — `consumed`, `restatesQuery`, `bytesEqual` — and none asked
+// whether the QUESTION had already been satisfied. So a single-hop question
+// whose answer happens to name another learnt context stepped past a correct
+// answer and replaced it with the next hop's:
+//
+//   asked : "<subject> father"
+//   hop 1 : "The father of <subject> is Ernest I of Anhalt-Dessau."   <- correct
+//   pivot : "Ernest I of Anhalt-Dessau"                <- a learnt context too
+//   got   : "The date of death of Ernest I of Anhalt-Dessau is 12 June 1516."
+//
+// Any store holding a bare-entity context beside a relation fact has that shape.
+//
+// THE FIX is the echo guard's other half, and the same principle: the QUERY's
+// own position in the graph says the read-out is complete. The echo guard
+// handles a query that is itself a learnt CONTINUATION; this handles a query
+// that is a learnt CONTEXT whose grounded answer is one of its own
+// continuations. A genuine multi-hop query is not a deposited context at all —
+// "What is the capital of the country of Eiffel Tower?" resolves to nothing —
+// so the guard can never gate a real chain, which the last test asserts,
+// because a fix that bought single-hop correctness by killing composition would
+// be no fix at all.
+//
+// A REFUTED ALTERNATIVE, recorded so it is not retried: gating the pivot on
+// "the QUERY still contains an unconsumed learnt context" (symmetric to
+// `pivotInto` on the answer) looks natural and BREAKS composition — a two-hop
+// query does not literally contain a learnt context, so the gate fires on every
+// real chain.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+
+const SUBJECT = "John V of Anhalt-Zerbst";
+const HOP1 = `The father of ${SUBJECT} is Ernest I of Anhalt-Dessau.`;
+const HOP2 = "The date of death of Ernest I of Anhalt-Dessau is 12 June 1516.";
+
+// Two chained facts, each deposited as a relation fact AND a bare-entity fact —
+// the shape that makes the entity pivotable, and the run-on possible.
+const DEPOSITS = [
+  [`${SUBJECT} father`, HOP1],
+  [SUBJECT, HOP1],
+  ["Ernest I of Anhalt-Dessau date of death", HOP2],
+  ["Ernest I of Anhalt-Dessau", HOP2],
+];
+
+async function chainStore() {
+  const mind = new Mind({ seed: 7, D: 1024 });
+  await mind.ingest(DEPOSITS);
+  return mind;
+}
+
+test("a single-hop question keeps its own answer", async () => {
+  // The regression itself. Without the guard this returns HOP2.
+  const mind = await chainStore();
+  const answer = await mind.respondText(`${SUBJECT} father`);
+  assert.ok(
+    answer.includes("Ernest I of Anhalt-Dessau"),
+    `lost the answer entirely: ${JSON.stringify(answer)}`,
+  );
+  assert.ok(
+    !answer.includes("12 June 1516"),
+    `ran on to the second hop and replaced a correct answer: ${
+      JSON.stringify(answer)
+    }`,
+  );
+});
+
+test("the bare-entity fact answers its own hop, and stops", async () => {
+  // The bare-entity deposit is a context too, so it must behave the same way:
+  // asking the entity yields ITS continuation, not the one after.
+  const mind = await chainStore();
+  const answer = await mind.respondText(SUBJECT);
+  assert.ok(
+    answer.includes("Ernest I of Anhalt-Dessau"),
+    `lost the answer: ${JSON.stringify(answer)}`,
+  );
+  assert.ok(
+    !answer.includes("12 June 1516"),
+    `bare-entity context ran on a hop: ${JSON.stringify(answer)}`,
+  );
+});
+
+test("the second hop is still reachable when actually asked", async () => {
+  // The guard must not make hop 2 unreachable — it is a deposited fact and a
+  // direct question about it must answer.
+  const mind = await chainStore();
+  const answer = await mind.respondText(
+    "Ernest I of Anhalt-Dessau date of death",
+  );
+  assert.ok(
+    answer.includes("12 June 1516"),
+    `hop 2 became unreachable: ${JSON.stringify(answer)}`,
+  );
+});
+
+test("a genuine two-hop question still composes", async () => {
+  // THE OTHER HALF OF THE CONTRACT. The guard keys on the query being a
+  // deposited context; a real multi-hop question is not one, so composition
+  // must be untouched. If this fails, the guard is over-broad.
+  const mind = new Mind({ seed: 7, D: 1024 });
+  await mind.ingest([
+    ["Eiffel Tower country", "The country of Eiffel Tower is France."],
+    ["France capital", "The capital of France is Paris."],
+    ["France", "The capital of France is Paris."],
+  ]);
+  const steps = [];
+  const answer = await mind.respondText(
+    "What is the capital of the country of Eiffel Tower?",
+    (s) => steps.push(s.mechanism[s.mechanism.length - 1]),
+  );
+  assert.ok(
+    steps.includes("pivotStep"),
+    `the guard suppressed a genuine chain; answer was ${
+      JSON.stringify(answer)
+    }`,
+  );
+  assert.ok(
+    answer.includes("Paris"),
+    `two-hop chain did not compose: ${JSON.stringify(answer)}`,
+  );
+});

package/test/86-cast-voices-committed.test.mjs

@@ -0,0 +1,164 @@
+// 86-cast-voices-committed.test.mjs — CAST may only SPEAK through a structure
+// the climb committed to, or one the query itself named.
+//
+// THE INVARIANT. cast.ts already states it, in the refusal note its own weave
+// gate emits: "CAST refuses to transfer through content the climb itself never
+// settled on". That gate asks only that the weave TOUCH a committed point
+// (`points.some(isRoot)`) — the right question for MEMBERSHIP, since a weave
+// needs uncommitted structure to compare against; that is what an analogy IS.
+// It is the wrong question for VOICING: satisfied by any committed bystander,
+// it licensed every OTHER aligned point to put its own learnt content into the
+// answer while a committed root that contributed nothing held the door open.
+//
+// WHAT THAT COST, measured on the fixture below (N ~ 103, consensusFloor 5.13):
+//
+//   climbConsensus committed ONE root:  "Eiffel Tower country"  #5   vote 8.13
+//   projectCounterfactual voiced:
+//     filler              "What is th"      #535  vote 0.15   <- a FILLER deposit
+//     displaced-structure "France capital"  #90   vote 0.57
+//   answer "What is the capitalThe capital of France is Paris."   [cast]
+//
+// Neither voiced structure was committed and both scored 9-34x BELOW the floor,
+// while the root that licensed the weave supplied no bytes at all.
+//
+// WHY THE TEST READS THE TRACE AND NOT THE ANSWER. The answer text is the wrong
+// probe: both the pre-fix and post-fix answers on this fixture are malformed
+// concatenations, and which one happens to contain the right substring is
+// cosmetic. That remaining garbling is a SEPARATE defect — CAST bidding at all
+// on a plain factual question — and this file deliberately asserts nothing
+// about it. The invariant is structural, so it is asserted structurally: the
+// node CAST voices must be a node the climb committed.
+//
+// THE OTHER HALF OF THE CONTRACT is tests 2 and 3. Commitment is not the only
+// warrant — a structure the asker QUOTED is content the query did ask about —
+// and an analogy must still transfer from a structure the query never names,
+// provided the climb settled on it. A gate that bought the invariant by killing
+// either would be no fix 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";
+
+const CHAIN = [
+  ["Eiffel Tower country", "The country of Eiffel Tower is France."],
+  ["France capital", "The capital of France is Paris."],
+  ["France", "The capital of France is Paris."],
+];
+const TWO_HOP = "What is the capital of the country of Eiffel Tower?";
+// The SHAPE matters: this filler family reproduces the defect at every N from
+// 50 up, across seeds 7/42/99 and D 512/1024, and survives a full entity
+// rename — so it is a structural fixture, not a byte-pattern one.
+const filler = (i) => [
+  `What is the status of my request ${i}?`,
+  `I have token number ${i} waiting.`,
+];
+
+/** Run one query; collect the committed anchors and the structures CAST voiced. */
+async function voicedVsCommitted(query, train) {
+  const store = new SQliteStore({ path: ":memory:", D: 1024 });
+  const mind = new Mind({ seed: 7, store });
+  await mind.ingest(train);
+  const committed = new Set();
+  const voiced = [];
+  await mind.respondText(query, (s) => {
+    const name = s.mechanism[s.mechanism.length - 1];
+    if (name === "climbConsensus") {
+      for (const o of s.outputs ?? []) {
+        if (o.role === "anchor" && o.node !== undefined) committed.add(o.node);
+      }
+    }
+    // What each schema transfers THROUGH: substitution voices the displaced
+    // structure's tail plus its own continuation; redirection voices the named
+    // substitute's own fact.
+    if (name === "projectCounterfactual") {
+      for (const i of s.inputs ?? []) {
+        if (
+          (i.role === "displaced-structure" || i.role === "substitute") &&
+          i.node !== undefined
+        ) voiced.push({ node: i.node, text: String(i.text ?? "") });
+      }
+    }
+  });
+  await store.close();
+  return { committed, voiced };
+}
+
+test("CAST voices only a structure the climb committed to", async () => {
+  // THE REGRESSION. Without the gate the displaced structure is #90
+  // ("France capital", uncommitted, vote 0.57) while the climb's only
+  // committed root is #5 — so `voiced` is not a subset of `committed`.
+  const { committed, voiced } = await voicedVsCommitted(TWO_HOP, [
+    ...CHAIN,
+    ...Array.from({ length: 50 }, (_, i) => filler(i)),
+  ]);
+  assert.ok(
+    committed.size > 0,
+    "fixture no longer reaches the consensus climb",
+  );
+  assert.ok(
+    voiced.length > 0,
+    "fixture no longer fires a CAST projection — it no longer covers the defect",
+  );
+  for (const v of voiced) {
+    assert.ok(
+      committed.has(v.node),
+      `CAST voiced #${v.node} ${
+        JSON.stringify(v.text.slice(0, 48))
+      }, which the climb never committed (committed: ${
+        [...committed].join(", ")
+      })`,
+    );
+  }
+});
+
+test("a substitute the query NAMES may still be voiced", async () => {
+  // OVER-CORRECTION GUARD, and the reason `voiceable` is a disjunction.
+  // "what if the capital of France were Lyon?" names Lyon outright; the climb
+  // need not have committed it for the asker to have asked about it. Gating on
+  // commitment alone refuses this — it is test/29 B3, reproduced here so the
+  // dependency is visible from the file that introduces the gate.
+  const store = new SQliteStore({ path: ":memory:", D: 1024 });
+  const mind = new Mind({ seed: 7, store });
+  await mind.ingest([
+    ["what is the capital of France?", "Paris is the capital of France"],
+    ["what is the capital of Italy?", "Rome is the capital of Italy"],
+    ["Lyon is a city in France", "Lyon is known for its cuisine"],
+  ]);
+  const got = await mind.respondText(
+    "what if the capital of France were Lyon?",
+  );
+  await store.close();
+  assert.ok(
+    /Lyon/i.test(got) && !/Paris/i.test(got),
+    `the named substitute was refused — expected Lyon, not Paris: ${
+      JSON.stringify(got)
+    }`,
+  );
+});
+
+test("an analogy still transfers from a structure the query never names", async () => {
+  // THE CAPABILITY THE GATE MUST NOT COST. "steel is frigid" names neither the
+  // water context nor its property; transferring from it is exactly what CAST
+  // exists to do, and it is licensed here because the climb COMMITTED that
+  // structure (test/29 D1 is the same assertion from the other direction).
+  const store = new SQliteStore({ path: ":memory:", D: 1024 });
+  const mind = new Mind({ seed: 7, store });
+  await mind.ingest([
+    ["ice is cold so ice is brittle", "brittle"],
+    ["steel is hard so steel is strong", "strong"],
+    ["water is frigid so water is freezing", "freezing"],
+  ]);
+  const r = await mind.respond("steel is frigid");
+  const got = new TextDecoder().decode(r.bytes ?? new Uint8Array());
+  await store.close();
+  assert.equal(
+    r.provenance,
+    "cast",
+    `CAST must still fire — got ${r.provenance}`,
+  );
+  assert.ok(
+    /freezing/i.test(got),
+    `property transfer lost — expected "freezing", got ${JSON.stringify(got)}`,
+  );
+});

package/test/87-codominant-commitment.test.mjs

@@ -0,0 +1,250 @@
+// 87-codominant-commitment.test.mjs — when the estimator cannot separate two
+// anchors, the climb must not pick one of them by coin flip.
+//
+// THE DEFECT THIS PINS. `commitVotes` exempts the DOMINANT anchor from both
+// vote gates ("the first non-overlapping root is dominant and bypasses the two
+// vote thresholds — it always grounds"), and holds every later anchor to
+// `naturalBreak` AND an absolute `consensusFloor(N) = ln N + 1/2`. Which anchor
+// gets the exemption is decided by a sort over ESTIMATED quantities. When the
+// two are within the estimator's own resolution that sort is a coin flip — and
+// the loser is then refused by a floor the winner never had to clear.
+//
+// MEASURED on the corpus below, 60 seeds per D. True separation of the two
+// anchors is 0.54s / 0.75s / 1.04s (s = estimatorNoise(D) = 1/sqrt(D)):
+//
+//     D      s=1/sqrt(D)   vote SD (estimated anchor)   SD/s   top flips
+//     256    0.0625        0.0561                       0.90   19/60
+//    1024    0.0313        0.0268                       0.86   12/60
+//    4096    0.0156        0.0074                       0.48    2/60
+//
+// The SD tracks 1/sqrt(D) and the flip rate collapses with it, so the
+// reordering is the ESTIMATOR's, not the corpus's. One anchor's vote is
+// constant across all 60 seeds (exact, content-addressed evidence); the other's
+// varies. Meanwhile `consensusFloor(3) = 1.599` and neither anchor exceeds
+// ~1.01, so the runner-up could NEVER commit: the query was allowed exactly one
+// point of attention, chosen by noise.
+//
+// THE FIX is the co-dominant band: an anchor whose margin from the dominant is
+// inside sqrt(k)*s inherits the dominant's exemption. sqrt(k) because a vote is
+// a SUM over the anchor's k contributing regions, so its noise grows as
+// sqrt(k) — a bare s would be the same category error as pricing an
+// N-invariant count against an N-growing threshold. Both quantities are already
+// in hand (`regionAxioms`, `estimatorNoise(D)`), so no constant is introduced.
+//
+// WHAT THIS FILE ASSERTS, AND WHY NOT THE OUTCOME. test/29 D2 asserts
+// `provenance === "cast"` — a PROXY. It passed while the property its own title
+// names ("site-aware climb is seed-independent") was false, because CAST voiced
+// the runner-up regardless of what the climb committed. So this file asserts
+// the commitment itself, read from the trace.
+//
+// NOT "the same anchors commit at every seed" — that was tried and it is FALSE,
+// which is worth recording. At seed 7 the noise puts the two anchors 0.049
+// apart while the runner-up's band is sqrt(2)*s = 0.044, so it is genuinely
+// separated and correctly rejected. The band is a statement about resolution,
+// not a promise of a fixed root set. The exact invariant is the one below: an
+// anchor inside its own band of the dominant is never rejected by a gate the
+// dominant was exempt from.
+
+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 D = 1024;
+const SIGMA = 1 / Math.sqrt(D); // estimatorNoise(D), by its own definition
+
+// test/29 D1's corpus: "steel is frigid" aligns "steel is " with one context
+// and "frigid" with another, and the two score within noise of each other.
+const ANALOGY = [
+  ["ice is cold so ice is brittle", "brittle"],
+  ["steel is hard so steel is strong", "strong"],
+  ["water is frigid so water is freezing", "freezing"],
+];
+
+/** The climb's per-anchor commit record for one query. */
+async function commitRecord(seed, train, query) {
+  const store = new SQliteStore({ path: ":memory:", D });
+  const mind = new Mind({ seed, store });
+  await mind.ingest(train);
+  let anchors = [];
+  await mind.respondText(query, (s) => {
+    if (s.mechanism[s.mechanism.length - 1] !== "climbConsensus") return;
+    anchors = s.data?.anchors ?? anchors;
+  });
+  await store.close();
+  return anchors;
+}
+
+/** The anchor's own band: sqrt(k) * sigma, k = its contributing-vote count. */
+const bandOf = (a) => Math.sqrt(Math.max(1, a.contributingVotes ?? 1)) * SIGMA;
+
+test("an anchor inside its band of the dominant is never refused by the floor", async () => {
+  // THE REGRESSION, stated exactly. Without the band, seed 1 rejects the
+  // runner-up with ["below-natural-break","below-consensus-floor"] at a margin
+  // of 0.013 — a third of its own resolution — while the dominant that beat it
+  // by that margin was exempt from both gates. Measured at 6 of 24 seeds.
+  let rescued = 0;
+  for (const seed of [1, 7, 8, 18, 20, 22, 23, 42]) {
+    const anchors = await commitRecord(seed, ANALOGY, "steel is frigid");
+    const dom = anchors.find((a) => a.commit?.dominant);
+    assert.ok(dom !== undefined, `seed ${seed}: no dominant anchor recorded`);
+    for (const a of anchors) {
+      if (a === dom || a.commit?.status === "overlap") continue;
+      const margin = (dom.idfVote ?? 0) - (a.idfVote ?? 0);
+      if (margin >= bandOf(a)) continue; // genuinely separated — may be rejected
+      rescued++;
+      assert.equal(
+        a.commit?.status,
+        "root",
+        `seed ${seed}: anchor #${a.anchor} sits ${
+          margin.toFixed(5)
+        } from the ` +
+          `dominant — inside its own band of ${
+            bandOf(a).toFixed(5)
+          } — yet was ` +
+          `${a.commit?.status} for ${
+            JSON.stringify(a.commit?.rejectionReasons)
+          }, gates the dominant never had to clear`,
+      );
+    }
+  }
+  assert.ok(
+    rescued > 0,
+    "no anchor in the sweep landed inside its band — fixture no longer covers the defect",
+  );
+});
+
+test("a band-admitted root is genuinely inside its own sqrt(k)*sigma", async () => {
+  // WIDTH GUARD. The band must be exactly what it claims. Recomputed here from
+  // the trace's OWN recorded numbers, so a widened band cannot pass silently.
+  let checked = 0;
+  for (const seed of [1, 7, 20, 22]) {
+    const anchors = await commitRecord(seed, ANALOGY, "steel is frigid");
+    const dom = anchors.find((a) => a.commit?.dominant);
+    if (dom === undefined) continue;
+    for (const a of anchors) {
+      if (!a.commit?.tiedWithDominant) continue;
+      checked++;
+      const margin = (dom.idfVote ?? 0) - (a.idfVote ?? 0);
+      assert.ok(
+        margin < bandOf(a),
+        `seed ${seed}: anchor #${a.anchor} admitted as tied with margin ${
+          margin.toFixed(5)
+        } but its band is only ${bandOf(a).toFixed(5)}`,
+      );
+    }
+  }
+  assert.ok(
+    checked > 0,
+    "no root was admitted by the band — fixture no longer covers it",
+  );
+});
+
+test("band admissions are bounded by the QUERY, not by the corpus", async () => {
+  // THE COST CONTRACT. The band's direct cost is O(1) per anchor, but admitting
+  // a root is not free downstream: the weave, the schemas and fusion all read
+  // `roots`. So the question that matters is whether the number of admissions
+  // can grow with the corpus. It cannot, and the bound is structural rather
+  // than a cap: an anchor overlapping one already placed is ABSORBED before any
+  // vote gate is consulted, so rivals elected from the same query span can
+  // never all commit — the ceiling is the query's own count of pairwise
+  // non-overlapping spans.
+  //
+  // Adversarial fixture: K structures made near-identical with respect to the
+  // query, so their votes cluster inside each other's bands. Measured at
+  // K = 1, 2, 4, 8, 16 over seeds 1/7/42 — committed roots never exceeded 2 and
+  // did not rise with K; the extra candidates came back `overlap`, or never
+  // entered the ranked list at all.
+  const SUBJ = [
+    "water",
+    "juice",
+    "milk",
+    "cider",
+    "broth",
+    "syrup",
+    "cream",
+    "nectar",
+    "brine",
+    "tonic",
+    "lager",
+    "cocoa",
+    "gravy",
+    "toddy",
+    "mead",
+    "punch",
+  ];
+  const PROP = [
+    "freezing",
+    "icy",
+    "cold",
+    "chilled",
+    "frosty",
+    "numbing",
+    "glacial",
+    "bitter",
+    "raw",
+    "biting",
+    "harsh",
+    "sharp",
+    "stinging",
+    "crisp",
+    "keen",
+    "brisk",
+  ];
+  const rootsAt = async (K) => {
+    const train = [["steel is hard so steel is strong", "strong"]];
+    for (let i = 0; i < K; i++) {
+      train.push([
+        `${SUBJ[i]} is frigid so ${SUBJ[i]} is ${PROP[i]}`,
+        PROP[i],
+      ]);
+    }
+    const anchors = await commitRecord(7, train, "steel is frigid");
+    return anchors.filter((a) => a.commit?.status === "root").length;
+  };
+  const small = await rootsAt(1);
+  for (const K of [2, 4, 8, 16]) {
+    const n = await rootsAt(K);
+    assert.ok(
+      n <= Math.max(small, 2),
+      `${K} near-tied rivals produced ${n} committed roots — admissions are ` +
+        `growing with the corpus, not with the query`,
+    );
+  }
+});
+
+test("the band does not admit a clearly separated anchor", async () => {
+  // OVER-CORRECTION GUARD. The band is about indistinguishability, not
+  // generosity. Measured on this fixture the climb commits ONE root at vote
+  // 8.13 while its rivals sit at 0.57 and 0.15 — separations of 240s and 255s.
+  // If this ever commits more than one root, the band has become a blanket
+  // admission.
+  const chain = [
+    ["Eiffel Tower country", "The country of Eiffel Tower is France."],
+    ["France capital", "The capital of France is Paris."],
+    ["France", "The capital of France is Paris."],
+  ];
+  const filler = Array.from({ length: 50 }, (_, i) => [
+    `What is the status of my request ${i}?`,
+    `I have token number ${i} waiting.`,
+  ]);
+  const anchors = await commitRecord(
+    7,
+    [...chain, ...filler],
+    "What is the capital of the country of Eiffel Tower?",
+  );
+  const roots = anchors.filter((a) => a.commit?.status === "root");
+  assert.equal(
+    roots.length,
+    1,
+    `expected the clearly dominant anchor alone; got ${
+      roots.map((r) => `#${r.anchor}@${Number(r.idfVote).toFixed(3)}`).join(
+        ", ",
+      )
+    }`,
+  );
+  assert.ok(
+    !roots[0].commit?.tiedWithDominant,
+    "the dominant root must not be marked as tied with itself",
+  );
+});