@hviana/sema 0.2.3 → 0.2.5

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

@@ -0,0 +1,244 @@
+// 43-cast-analog-seat.test.mjs — CAST's analogical-comparison schema must
+// never chase an analog's own FORWARD continuation, whether the analog is
+// a nextOf descendant or a directly aligned point.
+//
+// Traced live (analyze_training.ts, dialogue D geography thread): "And what
+// is the capital of Spain?" answered "The capital of France is Paris.And
+// what is the capital of the Moon?" — the comparison schema correctly
+// identified "What is the capital of France?" as dominant and correctly
+// found a genuine analog, "What is the capital of Japan?\nTokyo is the
+// capital of Japan." (validated via analogyStrength, 0.7667) — a DIRECTLY
+// aligned point (found in alignStructures' own output), not a nextOf
+// descendant.  seatOfNode's forward branch fired on it: the analog node is
+// already a complete, self-answering unit with prevCount 0 (no
+// establishing predecessor either), and its SOLE forward edge is a wholly
+// unrelated quiz question that happens to follow it in one training
+// document ("And what is the capital of the Moon?") — landing one hop past
+// the informative content that made it a genuine analog in the first
+// place.
+//
+// Two related shapes, two fixes:
+//   1. A nextOf DESCENDANT (AnalogCandidate.point === null, reached by
+//      following another aligned point's own continuation edge — never
+//      matched in the query) — its own bytes ARE its seat directly, no
+//      projection at all (the module's own doc comment on the alignment
+//      loop: "the hub's own [...] context will be the seat").
+//   2. A DIRECTLY aligned point (point !== null, the live shape above) —
+//      still goes through seatOfNode for its reverse-establishing check
+//      (a bare entity NAME like "Leonardo da Vinci" needs it — test/29's
+//      C2/C3), but with `allowForward: false`: the analog is only being
+//      CITED for comparison, the query never asked about it, so chasing
+//      its own further continuation is never appropriate — only reverse
+//      context or its own bytes.
+
+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 { counterfactualTransfer } from "../dist/src/mind/mechanisms/cast.js";
+import { gistOf, resolve } from "../dist/src/mind/primitives.js";
+
+const enc = (s) => new TextEncoder().encode(s);
+const dec = (b) => new TextDecoder().decode(b);
+
+test("CAST comparison: a nextOf-descendant analog is seated by its own bytes, not re-projected", async () => {
+  const m = new Mind({ seed: 7, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest([
+    ["What is the capital of France?", "The capital of France is Paris."],
+    // "some other prompt" stands in for whatever real aligned point's own
+    // continuation edge reaches the self-contained analog below — in the
+    // live trace this was reached through the query's own weave, not a
+    // direct textual match, hence AnalogCandidate.point === null.
+    ["some other prompt", "Japan capital is Tokyo."],
+    // The coincidental further edge: the analog's OWN forward continuation,
+    // unrelated to the comparison, mirroring "...capital of Japan?" being
+    // followed by "...capital of the Moon?" in one training document.
+    ["Japan capital is Tokyo.", "Unrelated next quiz question."],
+  ]);
+
+  const query = enc(
+    "What is the capital of France? What is the capital of Spain?",
+  );
+  const franceId = resolve(m, enc("What is the capital of France?"));
+  const spainAnalogSrcId = resolve(m, enc("some other prompt"));
+
+  const dominant = {
+    anchor: franceId,
+    vote: 100,
+    ctx: enc("What is the capital of France?"),
+    runs: [{ qs: 0, qe: 30, cs: 0, weight: 1 }],
+  };
+  // The "Spain" point aligned in the query, whose OWN nextOf reaches the
+  // self-contained Japan analog (via a real learnt edge) — this is what
+  // makes the Japan node a nextOf descendant (point === null) rather than
+  // a directly aligned point.
+  const spainPoint = {
+    anchor: spainAnalogSrcId,
+    vote: 50,
+    ctx: enc("some other prompt"),
+    runs: [{ qs: 32, qe: 62, cs: 0, weight: 1 }],
+  };
+
+  const pre = {
+    attention: async () => ({
+      roots: [
+        {
+          anchor: franceId,
+          vote: 100,
+          start: 0,
+          end: 30,
+          breadth: 1,
+          clusters: 1,
+        },
+      ],
+      ranked: [
+        {
+          anchor: franceId,
+          vote: 100,
+          start: 0,
+          end: 30,
+          breadth: 1,
+          clusters: 1,
+        },
+        {
+          anchor: spainAnalogSrcId,
+          vote: 50,
+          start: 32,
+          end: 62,
+          breadth: 0.5,
+          clusters: 1,
+        },
+      ],
+    }),
+    weave: async () => ({
+      points: [dominant, spainPoint],
+      depth: new Float64Array(query.length),
+    }),
+    rec: { sites: [] },
+    guide: gistOf(m, query),
+    k: 24,
+  };
+
+  const results = await counterfactualTransfer(m, query, pre);
+  const comparison = results.find((r) =>
+    dec(r.bytes).includes("Japan capital is Tokyo.")
+  );
+  assert.ok(
+    comparison,
+    `expected the comparison schema's own candidate among the results, got ` +
+      results.map((r) => dec(r.bytes)),
+  );
+  assert.ok(
+    !dec(comparison.bytes).includes("Unrelated next quiz question"),
+    `the nextOf-descendant analog must not be re-projected past its own ` +
+      `bytes, got "${dec(comparison.bytes)}"`,
+  );
+  await m.store.close();
+});
+
+test("CAST comparison: a DIRECTLY aligned analog is never re-projected past its own bytes", async () => {
+  const m = new Mind({ seed: 7, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest([
+    ["What is the capital of France?", "The capital of France is Paris."],
+    // The analog itself: an already-complete Q+A unit, mirroring the live
+    // "What is the capital of Japan?\nTokyo is the capital of Japan." node
+    // — matched DIRECTLY in the query this time (point !== null), not via
+    // nextOf.
+    [
+      "some other prompt",
+      "What is the capital of Japan? Tokyo is the capital of Japan.",
+    ],
+    // The analog's own coincidental further edge — an unrelated quiz
+    // question, exactly the "capital of the Moon" shape.
+    [
+      "What is the capital of Japan? Tokyo is the capital of Japan.",
+      "Unrelated next quiz question.",
+    ],
+  ]);
+
+  // The query itself never mentions Japan at all — exactly the live shape:
+  // "And what is the capital of Spain?" never contains Japan's text either;
+  // the analog is found by STRUCTURAL (halo) similarity to the dominant,
+  // not by a literal substring match — hence bestAnalog.point !== null
+  // (a genuinely ALIGNED point, just not aligned by literal quotation).
+  const query = enc(
+    "What is the capital of France? What is the capital of Spain?",
+  );
+  const franceId = resolve(m, enc("What is the capital of France?"));
+  const japanId = resolve(
+    m,
+    enc("What is the capital of Japan? Tokyo is the capital of Japan."),
+  );
+  assert.ok(franceId !== null && japanId !== null, "corpus must resolve");
+
+  const dominant = {
+    anchor: franceId,
+    vote: 100,
+    ctx: enc("What is the capital of France?"),
+    runs: [{ qs: 0, qe: 30, cs: 0, weight: 1 }],
+  };
+  // Aligned to the "Spain" span of the query by halo similarity (not literal
+  // quotation) — a directly aligned point, so bestAnalog.point !== null.
+  const japanPoint = {
+    anchor: japanId,
+    vote: 50,
+    ctx: enc("What is the capital of Japan? Tokyo is the capital of Japan."),
+    runs: [{ qs: 32, qe: 62, cs: 0, weight: 1 }],
+  };
+
+  const pre = {
+    attention: async () => ({
+      roots: [
+        {
+          anchor: franceId,
+          vote: 100,
+          start: 0,
+          end: 30,
+          breadth: 1,
+          clusters: 1,
+        },
+      ],
+      ranked: [
+        {
+          anchor: franceId,
+          vote: 100,
+          start: 0,
+          end: 30,
+          breadth: 1,
+          clusters: 1,
+        },
+        {
+          anchor: japanId,
+          vote: 50,
+          start: 32,
+          end: 62,
+          breadth: 0.5,
+          clusters: 1,
+        },
+      ],
+    }),
+    weave: async () => ({
+      points: [dominant, japanPoint],
+      depth: new Float64Array(query.length),
+    }),
+    rec: { sites: [] },
+    guide: gistOf(m, query),
+    k: 24,
+  };
+
+  const results = await counterfactualTransfer(m, query, pre);
+  const comparison = results.find((r) =>
+    dec(r.bytes).includes("Tokyo is the capital of Japan")
+  );
+  assert.ok(
+    comparison,
+    `expected the comparison schema's own candidate among the results, got ` +
+      results.map((r) => dec(r.bytes)),
+  );
+  assert.ok(
+    !dec(comparison.bytes).includes("Unrelated next quiz question"),
+    `a directly aligned analog must not be re-projected past its own ` +
+      `bytes, got "${dec(comparison.bytes)}"`,
+  );
+  await m.store.close();
+});

package/test/44-recognise-edge-whitespace.test.mjs

@@ -0,0 +1,63 @@
+// 44-recognise-edge-whitespace.test.mjs — recognise() must still find a
+// stored form when the query's own fold chunk swallows a leading/trailing
+// separator byte the trained form never had.
+//
+// Traced live (analyze_training.ts, dialogue D geography thread): the
+// accumulated query "...And what is the capital of Spain?" recognises
+// nothing near "what is the capital of Spain?" even though the exact fact
+// is trained and well-formed ("What is the capital of Spain?", resolves
+// cleanly in isolation).  Root-caused directly: the query's OWN fold draws
+// a chunk boundary at " what is the capital of Spain?" (WITH the leading
+// space folded in from the preceding "And "), and canon.ts's own
+// documented contract says edge whitespace belongs between forms, never to
+// one — so canonResolve correctly refuses that padded span.  The one-byte
+// trimmed span DOES canon-resolve to the trained fact (verified directly:
+// canonResolve on bytes[65,94) returns the same id as resolving "What is
+// the capital of Spain?" standalone) — but nothing tried the trimmed span.
+// Fix: when a chunk's canon fallback misses, retry the two one-byte-
+// shorter edge variants via resolve() (self-verifying, like every
+// content-addressed lookup here) before giving up — mind/recognition.ts
+// has no notion of "whitespace" at all, it just trusts the store's own
+// hash-then-verify discipline.  Two extra probes, only on the
+// already-failed miss path.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind, SQliteStore } from "../dist/src/index.js";
+import { textCanon } from "../dist/src/canon.js";
+import { recognise } from "../dist/src/mind/recognition.js";
+import { resolve } from "../dist/src/mind/primitives.js";
+
+const enc = (s) => new TextEncoder().encode(s);
+
+test("recognise(): a chunk that swallows a leading separator still finds the trained form after trimming", async () => {
+  const m = new Mind({ seed: 7, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest([
+    ["What is the capital of France?", "The capital of France is Paris."],
+    ["What is the capital of Spain?", "Madrid is the capital of Spain."],
+  ]);
+  await m.buildCanonIndex(textCanon);
+  m.canon = m._canonFor(textCanon);
+  m.canonMemo = new Map();
+
+  const query = enc(
+    "What is the capital of France?The capital of France is Paris." +
+      "And what is the capital of Spain?",
+  );
+  const expected = resolve(m, enc("What is the capital of Spain?"));
+  assert.ok(
+    expected !== null,
+    "sanity: the trained fact must resolve standalone",
+  );
+
+  const rec = recognise(m, query);
+  const hit = rec.sites.find((s) => s.payload === expected);
+  assert.ok(
+    hit,
+    `expected a recognised site for the trained Spain fact, got sites: ` +
+      JSON.stringify(
+        rec.sites.map((s) => [s.start, s.end, s.payload]),
+      ),
+  );
+  await m.store.close();
+});

package/test/45-liftanswer-restated-trim.test.mjs

@@ -0,0 +1,60 @@
+// 45-liftanswer-restated-trim.test.mjs — cover's derivation must not be
+// discarded WHOLESALE just because one of its segments restates content the
+// query already contains; liftAnswer should TRIM the restating segment and
+// keep the rest.
+//
+// Traced live (analyze_training.ts, dialogue D geography thread) and
+// reproduced minimally here: in a multi-turn conversation, turn 1's own
+// reply ("The capital of France is Paris.") becomes part of turn 2's
+// accumulated query verbatim.  cover's search correctly answers turn 1's
+// embedded question by FOLLOWING its edge to that same reply text — which
+// now duplicates content already sitting later in the query (the prior
+// turn's own answer, echoed back).  The OLD behaviour (cover.ts's
+// `restatedSpan` check) detected this correctly but responded by discarding
+// the ENTIRE candidate — throwing away the genuinely NEW answer (turn 2's
+// own question) along with the stale restated one.  Root cause: node
+// "The capital of France is Paris." has no forward edge and no concept
+// sibling (a plain declarative answer, not itself a question), so cover's
+// search also has to fall back to a very expensive byte-by-byte cover for
+// its own re-occurrence — but that is a SEPARATE, already-documented
+// concern; this test's fix is specifically about not discarding good
+// content alongside restated content once a derivation IS found.
+//
+// Fix: liftAnswer (types.ts) now takes the query bytes and the geometry's
+// quantum W, and excludes any recognised segment whose SUBSTITUTED bytes
+// (not the segment's own literal text) already occur elsewhere in the
+// query — from both the framing (lo/hi) decision AND the final
+// concatenation — instead of cover.ts rejecting the whole derivation.
+
+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+$/, "");
+
+test("cover: a restated segment is trimmed from the answer, not discarded wholesale", async () => {
+  const m = new Mind({ seed: 7, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest([
+    ["What is the capital of France?", "The capital of France is Paris."],
+    ["What is the capital of Spain?", "Madrid is the capital of Spain."],
+  ]);
+
+  const conv = m.beginConversation();
+  await m.respondTurn(conv, "What is the capital of France?");
+  const r2 = await m.respondTurn(conv, "What is the capital of Spain?");
+  const got = dec(r2.response.bytes);
+
+  assert.ok(
+    got.length > 0,
+    "expected a non-empty answer — the genuinely new Spain answer must not " +
+      "be discarded just because the France answer restates itself",
+  );
+  assert.ok(
+    got.includes("Madrid") || got.includes("Spain"),
+    `expected the NEW answer (Spain) to survive, got ${JSON.stringify(got)}`,
+  );
+
+  m.endConversation(conv);
+  await m.store.close();
+});

package/test/46-recognise-multibyte-edge.test.mjs

@@ -0,0 +1,85 @@
+// 46-recognise-multibyte-edge.test.mjs — recognise()'s canon-miss fallback
+// must recover a trained form whose edge misalignment is MORE than one byte
+// (the shipped ±1 fix only covers a single stray edge byte).
+//
+// bytesToTree's plain fold is RADIX-ALIGNED: a chunk's own boundary is a
+// multiple of the geometry's group width W from the LOCAL start of whatever
+// it was folded from (see geometry.ts's FoldPyramid comment).  A query whose
+// recognised span sits at a different local offset than the trained deposit
+// did — e.g. extra leading whitespace, which canon deliberately preserves
+// verbatim at the edges, only collapsing INTERIOR whitespace — shifts every
+// chunk boundary inside it by that many bytes, which can exceed 1.
+//
+// Fix: widen the miss-fallback with bounded W-quantum edge trims, each
+// gated by the SAME cheap store.findBranch(leafIds) pre-filter the
+// canonical pass (tryChain) already uses — so the (rare) miss path pays for
+// a real resolve() fold only when a branch could plausibly exist there —
+// and capped to nodes no larger than chainReach(W) = W² (a chunk-scale
+// bound, not a whole-query one): widening at ROOT scale can rediscover
+// content the structural walk's own finer recursion already owns as a
+// SEPARATE, duplicate site, and downstream derivation can then stitch a
+// wrong answer out of the two overlapping sites (see the second test here).
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind, SQliteStore } from "../dist/src/index.js";
+import { recognise } from "../dist/src/mind/recognition.js";
+import { resolve } from "../dist/src/mind/primitives.js";
+
+const enc = (s) => new TextEncoder().encode(s);
+const dec = (b) => new TextDecoder().decode(b).replace(/\0+$/, "");
+
+test("recognise(): a >1-byte edge misalignment still finds the trained form", async () => {
+  // A whole-query-scale offset (the entire query is nothing but the trained
+  // fact plus a swallowed prefix) is a DIFFERENT, still-open problem — see
+  // the "does not corrupt" test below for why widening this fix to root
+  // scale is exactly what must NOT happen.  What this fix targets is a
+  // canon-miss node bounded to chunk scale (<= W², chainReach's own bound)
+  // whose trim offset is more than the shipped ±1 fallback reaches.
+  const m = new Mind({ seed: 7, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest([["cats meow", "yes they do"]]);
+
+  const expected = resolve(m, enc("cats meow"));
+  assert.ok(
+    expected !== null,
+    "sanity: the trained fact must resolve standalone",
+  );
+
+  // Two EXTRA leading spaces relative to the trained form — canon only
+  // collapses interior whitespace, so this is a 2-byte edge offset, wider
+  // than the shipped ±1 fallback covers.
+  const query = enc("  cats meow");
+  const rec = recognise(m, query);
+  const hit = rec.sites.find((s) => s.payload === expected);
+  assert.ok(
+    hit,
+    `expected a recognised site for the trained fact despite the 2-byte ` +
+      `edge offset, got sites: ` +
+      JSON.stringify(rec.sites.map((s) => [s.start, s.end, s.payload])),
+  );
+  await m.store.close();
+});
+
+test("recognise(): a wide edge trim does not corrupt an unrelated short-form answer", async () => {
+  // Regression guard for the root-scale false positive: widening the
+  // fallback's reach must not let it re-derive a smaller subtree's own
+  // content as a SEPARATE site at the whole-query node, which previously
+  // let cover's derivation stitch two overlapping sites into a wrong
+  // answer ("4+15" instead of "4").
+  const TABLE = [
+    ["1+2", "3"],
+    ["2+2", "4"],
+    ["2+3", "5"],
+    ["3+3", "6"],
+    ["3+5", "8"],
+    ["4+3", "7"],
+    ["2+5", "7"],
+    ["1+5", "6"],
+    ["6+1", "7"],
+    ["4+1", "5"],
+  ];
+  const m = new Mind({ seed: 42 });
+  await m.ingest(TABLE);
+  const r = await m.respond("2+2 は何ですか");
+  assert.equal(dec(r.bytes), "4");
+});

package/test/47-cast-comparison-coverage.test.mjs

@@ -0,0 +1,134 @@
+// 47-cast-comparison-coverage.test.mjs — CAST's analogical-comparison schema
+// must not fire when its own accounted evidence leaves a substantial,
+// contiguous stretch of the query untouched — the same half-dominance bar
+// CAST's own frame gate and liftAnswer already apply, PLUS a topic-scale
+// bar (see cast.ts's comparison-gate comment for why one alone isn't enough).
+//
+// Traced live (analyze_training.ts, dialogue D geography thread): "And what
+// is the capital of Spain?" answered "The capital of France is Paris.What is
+// the capital of Japan?\nTokyo is the capital of Japan." — a wrong analog.
+// Root-caused directly against the live store: recognise() never finds a
+// site for "capital of Spain" at all (a genuine extra word, "And ", not
+// boundary noise — see the session's own investigation), so the consensus
+// climb commits only ONE root (France) and CAST's comparison schema treats
+// the query as "about one thing."
+//
+// The live numbers are the important part of this test: comparison's own
+// accounted spans (dominant [0,30) + analog [77,88)) leave a 47-byte gap in
+// the 94-byte query — exactly HALF, so the query-relative bar alone
+// (dominates: strictly more than half) does NOT decisively refuse it; only
+// the topic-relative bar (47 ≥ dominant's own 30-byte context) does.  This
+// test pins the EXACT borderline shape, not an easier, more comfortably
+// over-half one — a fix that only handled a clear majority-gap would still
+// leave the live bug live.
+
+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 { counterfactualTransfer } from "../dist/src/mind/mechanisms/cast.js";
+import { gistOf, resolve } from "../dist/src/mind/primitives.js";
+
+const enc = (s) => new TextEncoder().encode(s);
+const dec = (b) => new TextDecoder().decode(b);
+
+test("CAST comparison: refuses to fire when its own accounted evidence leaves an exactly-half, topic-scale gap", async () => {
+  const m = new Mind({ seed: 7, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest([
+    ["What is the capital of France?", "The capital of France is Paris."],
+    [
+      "some other prompt",
+      "What is the capital of Japan? Tokyo is the capital of Japan.",
+    ],
+    [
+      "What is the capital of Japan? Tokyo is the capital of Japan.",
+      "Unrelated next quiz question.",
+    ],
+  ]);
+
+  // The real accumulated multi-turn shape: dominant covers only the FIRST
+  // 30 bytes (the France sentence); the rest of the query — including the
+  // whole "And what is the capital of Spain?" tail — is never aligned to
+  // anything beyond a bare 5-byte "Spain" token, mirroring the live case
+  // where recognise() found nothing bigger for that span.
+  const query = enc(
+    "What is the capital of France?The capital of France is Paris." +
+      "And what is the capital of Spain?",
+  );
+  const franceId = resolve(m, enc("What is the capital of France?"));
+  const japanId = resolve(
+    m,
+    enc("What is the capital of Japan? Tokyo is the capital of Japan."),
+  );
+  assert.ok(franceId !== null && japanId !== null, "corpus must resolve");
+
+  const dominant = {
+    anchor: franceId,
+    vote: 100,
+    ctx: enc("What is the capital of France?"),
+    runs: [{ qs: 0, qe: 30, cs: 0, weight: 1 }],
+  };
+  // Directly aligned, but its OWN evidence is just "capital of" (bytes
+  // 77..88 of the 94-byte query) — the exact live span — not the whole
+  // clause and not even the word "Spain" itself.
+  const japanPoint = {
+    anchor: japanId,
+    vote: 50,
+    ctx: enc("What is the capital of Japan? Tokyo is the capital of Japan."),
+    runs: [{ qs: 77, qe: 88, cs: 0, weight: 1 }],
+  };
+
+  const pre = {
+    attention: async () => ({
+      roots: [
+        {
+          anchor: franceId,
+          vote: 100,
+          start: 0,
+          end: 30,
+          breadth: 1,
+          clusters: 1,
+        },
+      ],
+      ranked: [
+        {
+          anchor: franceId,
+          vote: 100,
+          start: 0,
+          end: 30,
+          breadth: 1,
+          clusters: 1,
+        },
+        {
+          anchor: japanId,
+          vote: 50,
+          start: 77,
+          end: 88,
+          breadth: 0.5,
+          clusters: 1,
+        },
+      ],
+    }),
+    weave: async () => ({
+      points: [dominant, japanPoint],
+      depth: new Float64Array(query.length),
+    }),
+    rec: { sites: [] },
+    guide: gistOf(m, query),
+    k: 24,
+  };
+
+  const results = await counterfactualTransfer(m, query, pre);
+  const comparison = results.find((r) =>
+    dec(r.bytes).includes("Tokyo is the capital of Japan")
+  );
+  assert.ok(
+    !comparison,
+    `comparison should refuse when the largest gap (47 bytes) is exactly ` +
+      `half the 94-byte query and at least as large as the 30-byte ` +
+      `dominant, but fired: ${
+        comparison ? JSON.stringify(dec(comparison.bytes)) : ""
+      }`,
+  );
+  await m.store.close();
+});