@hviana/sema 0.2.2 → 0.2.4

package/test/41-seatofnode-direction.test.mjs

@@ -0,0 +1,85 @@
+// 41-seatofnode-direction.test.mjs — CAST's seatOfNode (comparison schema)
+// must seat a node by its own FORWARD identity when it has one, not by an
+// incidental predecessor.
+//
+// Traced live (analyze_training.ts, dialogue D geography thread): "And what
+// is the capital of Spain?" answered with "Create an example of a types of
+// questions a GPT model can answer.?And what is the capital of the Moon?"
+// — CAST's comparison schema correctly identified "What is the capital of
+// France?" as the dominant structure and a genuine analog ("capital of
+// Japan"), but seated the dominant by REVERSE context instead of forward:
+// seatOfNode's old test (`prevCount(id) === 0`) skipped the forward branch
+// because that exact question happens to have ONE coincidental predecessor
+// elsewhere in the corpus (a generic "generate example questions"
+// meta-prompt) — even though its own forward edge unambiguously resolves
+// to "The capital of France is Paris."
+//
+// A broad sample of this store's own question-shaped nodes showed this
+// isn't rare: ~71% have at least one predecessor, the large majority from
+// a handful of generic, high-fan-out sentences that recur as incidental
+// neighbours to dozens of unrelated destinations — a SmolSent-style
+// adjacency artifact, not a real identity-establishing lead-in.  There is
+// no reliable way to tell a meaningful predecessor from an incidental one
+// by count alone (the same category error already found and removed from
+// chooseNext), so the fix restores the ONE priority every other consumer
+// of follow()/reverseContext() already uses (project(), pivotInto, cast's
+// own substitution schema): forward first, reverse only as a fallback when
+// forward doesn't resolve.
+
+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 { seatOfNode } 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);
+
+const mk = (seed) =>
+  new Mind({ seed, store: new SQliteStore({ path: ":memory:" }) });
+
+test("seatOfNode: a node with a strong forward identity is seated forward despite a coincidental predecessor", async () => {
+  const m = mk(7);
+  // "the question" has both a genuine forward answer AND one coincidental
+  // predecessor — exactly the live shape (prevCount > 0, hasNext true).
+  await m.ingest([
+    ["the question", "the real answer"],
+    ["a generic template prompt", "the question"],
+  ]);
+
+  const id = resolve(m, enc("the question"));
+  assert.ok(id !== null, "corpus must resolve");
+  assert.ok(m.store.prevCount(id) > 0, "must have a coincidental predecessor");
+  assert.ok(m.store.hasNext(id), "must have a forward continuation");
+
+  const guide = gistOf(m, enc("the question"));
+  const seat = await seatOfNode(m, id, guide, enc("fallback"));
+  assert.equal(
+    dec(seat),
+    "the real answer",
+    `must seat by forward identity, not the coincidental predecessor, got "${
+      dec(seat)
+    }"`,
+  );
+  await m.store.close();
+});
+
+test("seatOfNode: a node with NO forward identity still falls back to its reverse context", async () => {
+  const m = mk(7);
+  await m.ingest([["known as", "the entity"]]);
+
+  const id = resolve(m, enc("the entity"));
+  assert.ok(id !== null, "corpus must resolve");
+  assert.equal(m.store.hasNext(id), false, "must have no forward continuation");
+
+  const guide = gistOf(m, enc("the entity"));
+  const seat = await seatOfNode(m, id, guide, enc("fallback"));
+  assert.equal(
+    dec(seat),
+    "known as",
+    `an entity with no forward edge must still fall back to its reverse ` +
+      `context, got "${dec(seat)}"`,
+  );
+  await m.store.close();
+});

package/test/42-recognise-trace-idempotence.test.mjs

@@ -0,0 +1,106 @@
+// 42-recognise-trace-idempotence.test.mjs — recognise() (and, by the same
+// defect, climbAttentionAll()) must return the SAME result whether or not
+// inspectRationale is attached — tracing must never change what the
+// system decides, only whether it explains itself.
+//
+// Traced live (analyze_training.ts): the same 4-turn dialogue produced a
+// DIFFERENT final answer depending only on whether inspectRationale was
+// attached to the last turn — a deterministic, reproducible divergence,
+// not cross-process randomness (verified: 5 untraced runs, byte-identical;
+// traced vs untraced, consistently different).
+//
+// Root cause, isolated directly: recogniseImpl walks the query's perceived
+// tree via foldTree(ctx, tree, 0, visit) — and foldTree's subtree-resolution
+// fast path (primitives.ts) returns immediately for any subtree already
+// cached in ctx._resolvedSubtrees, WITHOUT recursing into its children, so
+// `visit` never fires for anything below that point.  A multi-turn
+// conversation's stable-prefix fold deliberately shares node OBJECTS
+// across turns and within a turn's own walk, so by a SECOND call on the
+// exact same bytes, large parts of the tree are already cached and
+// recogniseImpl silently finds FEWER sites than the first call — it is not
+// safe to call twice on the same input once `_resolvedSubtrees` is warm.
+//
+// Under ordinary (untraced) operation this never surfaces: recogniseMemo
+// (keyed by exact byte content) ensures recogniseImpl only ever runs ONCE
+// per distinct query string per conversation.  But the memo was previously
+// SKIPPED whenever `ctx.trace` was truthy ("so every call still emits its
+// rationale step") — meaning a traced turn re-ran recogniseImpl from
+// scratch at every one of the many call sites that recognise the same
+// query within one response (cover, reason, articulate...), each
+// subsequent call more incomplete than the last, silently changing which
+// mechanism grounds the answer.  Fix: consult (and populate) the memo
+// unconditionally — matching perceive()'s own memo, which never had a
+// trace gate — and emit the trace step from the cache-hit path directly,
+// so tracing stays fully observable without ever bypassing correctness.
+// climbAttentionAll() had the identical `!ctx.trace` gate over the same
+// class of foldTree-based computation (collectRegions) and got the same
+// fix, on the same reasoning, in the same change.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { recognise } from "../dist/src/mind/recognition.js";
+
+const enc = (s) => new TextEncoder().encode(s);
+
+test("recognise(): a traced call returns the identical cached result, not a degraded recompute", async () => {
+  const m = new Mind({ seed: 7 });
+  // A long, deeply-chunked query (enough leaf-parents for foldTree's
+  // subtree cache to matter) that also recurs as a learnt SOURCE, so its
+  // own subtree — and many of its word-level sub-leaves — resolve and get
+  // cached into ctx._resolvedSubtrees on the first walk.
+  const words = [
+    "hello",
+    "world",
+    "foo",
+    "bar",
+    "baz",
+    "qux",
+    "quux",
+    "corge",
+    "grault",
+    "garply",
+    "waldo",
+    "fred",
+    "plugh",
+    "xyzzy",
+    "thud",
+  ];
+  const long = words.join(" ") + " " + words.slice().reverse().join(" ");
+  await m.ingest([
+    [long, "some reply text here"],
+    ...words.map((w, i) => [w, `word ${i}`]),
+  ]);
+
+  // _resolvedSubtrees is only ever populated during respondTurn's
+  // conversation machinery (a plain respond() leaves it null, immune to
+  // this defect) — reproduce that shape directly for a controlled,
+  // deterministic unit test.
+  m.perceiveMemo = new Map();
+  m.recogniseMemo = new Map();
+  m._resolvedSubtrees = new WeakMap();
+  m.trace = null;
+
+  const bytes = enc(long);
+  const untraced = recognise(m, bytes);
+  assert.ok(
+    untraced.sites.length > 0,
+    "sanity: the untraced call must find sites",
+  );
+
+  m.trace = { enter: () => undefined, step: () => undefined };
+  const traced = recognise(m, bytes);
+
+  assert.equal(
+    traced,
+    untraced,
+    "a traced call must return the SAME cached Recognition object, not " +
+      "recompute (and potentially degrade) it",
+  );
+  assert.equal(
+    traced.sites.length,
+    untraced.sites.length,
+    `traced and untraced site counts must match, got ${traced.sites.length} ` +
+      `vs ${untraced.sites.length}`,
+  );
+});

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