@hviana/sema 0.2.3 → 0.2.4

package/test/37-cluster-dispersion-fusion.test.mjs

@@ -0,0 +1,190 @@
+// 37-cluster-dispersion-fusion.test.mjs — Category B of the multi-turn
+// garbling investigation: a further point of attention corroborated from
+// only ONE local neighbourhood of the query must not be trusted to fuse in,
+// regardless of how strong its vote is.
+//
+// Two measures were tried and falsified before this one:
+//   - Attention.breadth (dominance-fraction) starves a genuine, evenly-split
+//     multi-topic query — no root in a real N-way split can exceed half the
+//     vote (test/24 gap 3.1).
+//   - raw regionSupport (corroboration COUNT, summed) doesn't separate a
+//     genuine topic from a coincidental echo either — a short, structurally
+//     simple echo racks up as many corroborating regions as a real topic
+//     does (test/35's arithmetic echo: 4 regions, the same range as gap
+//     3.1's real topics: 5-6).
+//
+// Both are MAGNITUDE measures over the SAME span.  The live defect (traced
+// directly against the trained store) was different in kind: an unrelated
+// node.js answer got fused in because the query's own short closing phrase
+// ("Thank you very much!") happened to be byte-identical to how ONE other,
+// wholly unrelated training conversation also ended — a single coincidental
+// match, corroborated from exactly ONE place in the query.  Compared
+// against gap 3.1's two GENUINE topics, each of which is corroborated from
+// TWO distinct, widely separated clusters of the query (verified directly:
+// "Dream Team" from spans [80,96] and [132,148]; "gender equality" from
+// [96,112] and [116,120] — the query's own SYS-scaffolding regions plus the
+// topic's own distinctive wording, never just one).
+//
+// The discriminator is therefore not "how much" evidence but "how many
+// separate PLACES in the query" corroborate it: cluster the contributing
+// regions by merging any two whose gap is strictly less than one river-fold
+// quantum W (ctx.space.maxGroup — the same quantum thinBar, identityBar and
+// reachThreshold already derive from; never a new tuned number) and require
+// at least 2 clusters.  Verified against the boundary case directly: gap
+// 3.1's "gender equality" clusters are exactly W apart, and `gap < W`
+// (strict) is what keeps them separate — `gap <= W` would collapse them
+// into one and break the pinned gap-3.1 requirement.
+
+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 { fuseAttention } from "../dist/src/mind/reasoning.js";
+import { gistOf } from "../dist/src/mind/primitives.js";
+
+const enc = (s) => new TextEncoder().encode(s);
+const dec = (b) =>
+  new TextDecoder().decode(b.filter((x) => x !== 0)).replace(/\s+/g, " ")
+    .trim();
+
+// A genuine cross-region binding (test/34's corpus) mixed with a
+// coincidental arithmetic echo (test/35's corpus) in the SAME climb —
+// reusing the exact same real anchors test/36 verified project to
+// "answer alpha" and "2" respectively.  The echo root's `end` is widened
+// past the full "2+2" expression below (a harmless adjustment to a
+// synthetic Attention object we already fabricate) so Fix A's own
+// already-answered scan does not trip over the SECOND "2" digit sitting
+// immediately after the echo's single-byte match — an unrelated collision
+// specific to this corpus, not the mechanism under test here.
+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"],
+  ["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"],
+  ["3+4", "7"],
+  ["5+2", "7"],
+  ["1+1", "2"],
+  ["5+3", "8"],
+  ["7+1", "8"],
+];
+
+const mk = (seed) =>
+  new Mind({ seed, store: new SQliteStore({ path: ":memory:" }) });
+
+async function setup() {
+  const m = mk(1);
+  await m.ingest(CORPUS);
+  const q = enc("red circle then 2+2 equals what");
+  const roots = await m.climbAttention(q, 24);
+  const binding = roots.find((r) => r.start === 0); // "red circle" [0,10)
+  const echo = roots.find((r) => r.start === 16); // "1+1" [16,17)
+  assert.ok(binding, "expected the 'red circle' binding root");
+  assert.ok(echo, "expected the '1+1' echo root");
+  const guide = gistOf(m, q);
+  return { m, q, binding, echo, guide };
+}
+
+// The gate is an OR of two independent measures (verified against the full
+// suite: a plain AND-only cluster requirement broke test/34's own joint
+// binding, whose crossRegionVotes conclusion is pooled from a single
+// synthetic region — one cluster by construction — despite already, by
+// design, accounting for BOTH original query mentions; `breadth` already
+// recognises that case correctly, since a genuine joint binding dominates
+// the query on its own).  These three tests cover the three quadrants a
+// root can land in; breadth is set explicitly (these are already fabricated
+// synthetic Attention objects) so each quadrant is tested precisely rather
+// than relying on incidental corpus values.
+
+test("fuseAttention: 2 clusters, low breadth — dispersion alone is enough (gap 3.1's shape)", async () => {
+  const { m, q, binding, echo, guide } = await setup();
+  const primary = enc("PRIMARYANCHORTEXT");
+  const dispersedLowBreadth = { ...binding, clusters: 2, breadth: 0.12 };
+  const placeholder = {
+    ...binding,
+    start: q.length,
+    end: q.length,
+    clusters: 1,
+    breadth: 0.12,
+  };
+  const pre = {
+    attention: async () => ({
+      roots: [placeholder, dispersedLowBreadth],
+      ranked: [placeholder, dispersedLowBreadth],
+    }),
+    guide,
+  };
+  const out = dec(await fuseAttention(m, q, primary, pre));
+  assert.equal(
+    out,
+    "answer alpha" + dec(primary),
+    `2 clusters must fuse in even with low breadth, got "${out}"`,
+  );
+  await m.store.close();
+});
+
+test("fuseAttention: 1 cluster, dominant breadth — dominance alone is enough (test/34's joint-binding shape)", async () => {
+  const { m, q, binding, guide } = await setup();
+  const primary = enc("PRIMARYANCHORTEXT");
+  const tightButDominant = { ...binding, clusters: 1, breadth: 0.857 };
+  const placeholder = {
+    ...binding,
+    start: q.length,
+    end: q.length,
+    clusters: 1,
+    breadth: 0.857,
+  };
+  const pre = {
+    attention: async () => ({
+      roots: [placeholder, tightButDominant],
+      ranked: [placeholder, tightButDominant],
+    }),
+    guide,
+  };
+  const out = dec(await fuseAttention(m, q, primary, pre));
+  assert.equal(
+    out,
+    "answer alpha" + dec(primary),
+    `dominant breadth must fuse in even with 1 cluster, got "${out}"`,
+  );
+  await m.store.close();
+});
+
+test("fuseAttention: 1 cluster, low breadth — neither measure saves it (the live coincidental-echo shape)", async () => {
+  const { m, q, echo, guide } = await setup();
+  const primary = enc("PRIMARYANCHORTEXT");
+  const tightAndWeak = {
+    ...echo,
+    end: echo.end + 2,
+    clusters: 1,
+    breadth: 0.211,
+  };
+  const placeholder = { ...tightAndWeak, start: q.length, end: q.length };
+  const pre = {
+    attention: async () => ({
+      roots: [placeholder, tightAndWeak],
+      ranked: [placeholder, tightAndWeak],
+    }),
+    guide,
+  };
+  const out = dec(await fuseAttention(m, q, primary, pre));
+  assert.equal(
+    out,
+    dec(primary),
+    `1 cluster AND low breadth must not fuse in, got "${out}"`,
+  );
+  await m.store.close();
+});

package/test/38-reason-restate-guard.test.mjs

@@ -0,0 +1,94 @@
+// 38-reason-restate-guard.test.mjs — reason()'s multi-hop chain
+// (absorbForward/pivotStep) must not walk onto a fixpoint whose bytes are
+// ALREADY PRESENT in the query.
+//
+// Traced live (analyze_training.ts, dialogue D): a scaffolding-dominated
+// query ("Can you help me with something?", accumulated on top of "Hello,
+// how are you today?Hello! How can I assist you today?") legitimately
+// grounds (recallByResonance tier 2, consensus-floor-gated) on an unrelated
+// but well-corroborated anchor.  reason() then hops FORWARD from that
+// grounding across two further, ungated steps and lands on the literal
+// bytes "Hello" — content already sitting in the query's own first turn.
+// The final answer is that bare, contextless echo.
+//
+// recallByResonance already refuses exactly this shape at grounding time —
+// three separate guards (`restates`, tier 2's subspan check, tier 0b's
+// argument-binding subspan check) all reject a candidate whose bytes are a
+// proper byte-subspan of the query, because voicing them back only restates
+// part of the question.  reason() is the one place that walks MULTIPLE
+// additional hops past the initial (already-vetted) grounding, and it had
+// no equivalent guard — every hop only checked structural novelty
+// (`consumed`), never whether the result had drifted onto something the
+// query already contains.  Fix: apply the same restates/subspan guard,
+// verbatim, to reason()'s own hop candidates — no new tuned constant, just
+// the existing convention applied where it was missing.
+
+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 { reason } from "../dist/src/mind/reasoning.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("reason(): a forward hop landing on bytes already present in the query is refused", async () => {
+  const m = mk(1);
+  // "bridge context" is a learnt fact SOURCE whose continuation is "Hello" —
+  // the multi-hop chain's next, and only, forward step.
+  await m.ingest([["ask topic", "bridge context"], [
+    "bridge context",
+    "Hello",
+  ]]);
+
+  // The query already contains "Hello" verbatim — e.g. a prior turn's own
+  // greeting, exactly the accumulated-conversation shape from the live
+  // trace.  The grounded starting answer is "bridge context" (as if some
+  // upstream mechanism already grounded it) — reason()'s job is only to
+  // decide whether to hop FURTHER from it.
+  const query = enc("Hello, ask topic what happens next");
+  const answer = enc("bridge context");
+  const pre = {
+    guide: gistOf(m, query),
+    queryResolved: resolve(m, query),
+  };
+
+  const out = await reason(m, query, answer, new Set(), pre);
+  assert.equal(
+    dec(out),
+    "bridge context",
+    `must not hop onto "Hello" — it already restates content the query itself contains, got "${
+      dec(out)
+    }"`,
+  );
+  await m.store.close();
+});
+
+test("reason(): an ordinary forward hop onto genuinely new content is unaffected", async () => {
+  const m = mk(1);
+  await m.ingest([["ask topic", "bridge context"], [
+    "bridge context",
+    "a wholly new fact never mentioned in any query",
+  ]]);
+
+  const query = enc("Hello, ask topic what happens next");
+  const answer = enc("bridge context");
+  const pre = {
+    guide: gistOf(m, query),
+    queryResolved: resolve(m, query),
+  };
+
+  const out = await reason(m, query, answer, new Set(), pre);
+  assert.equal(
+    dec(out),
+    "a wholly new fact never mentioned in any query",
+    `an ordinary hop onto genuinely new content must still fire, got "${
+      dec(out)
+    }"`,
+  );
+  await m.store.close();
+});

package/test/39-cast-restate-guard.test.mjs

@@ -0,0 +1,102 @@
+// 39-cast-restate-guard.test.mjs — CAST's substitution schema
+// (projectCounterfactual, cast.ts) must not append a forward-followed edge
+// whose bytes are ALREADY PRESENT in the query — the same defect test/38
+// fixed in reason(), found again in a sibling mechanism.
+//
+// Traced live (analyze_training.ts, dialogue D, turn 4): CAST's substitution
+// schema transfers a displaced structure onto a filler ("Bitte spiele...");
+// after building the substitution, it separately follows the displaced
+// structure's OWN learnt forward-continuation edge and appends whatever
+// that turns up — in the live trace, the literal bytes "Hello", because in
+// the training corpus that structure happens to be followed, in some
+// wholly unrelated conversation, by another dialogue opening with "Hello".
+// The accumulated query's own first turn is "Hello, how are you today?", so
+// the appended "Hello" restates content the query already contains — the
+// SAME defect class as test/38, just reached through cast.ts's own
+// `follow()` call (line ~299) instead of reason()'s hop loop.  The old
+// guard there only checked the candidate wasn't already inside the
+// PARTIALLY-BUILT ANSWER (`indexOf(answer, fwd, 0) < 0`) — never that it
+// wasn't already in the QUERY.  Fix: reuse `restatesQuery` (exported from
+// reasoning.ts, the exact function test/38 introduced) at the same call
+// site — no new tuned constant, the existing convention extended to a
+// second place it was missing.
+
+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 mk = (seed) =>
+  new Mind({ seed, store: new SQliteStore({ path: ":memory:" }) });
+
+test("CAST substitution: a followed edge landing on bytes already present in the query is refused", async () => {
+  const m = mk(7);
+  // "Ice is cold" is CAST's displaced structure for "What if steel were
+  // cold?" (mirrors test/33's own substitution corpus).  A second edge from
+  // the SAME source, corroborated by a second, unrelated predecessor, makes
+  // "Water is wet" — and, one further hop, "wet" — its resonance-preferred
+  // forward continuation, exactly the "some other conversation continues
+  // from the same node" shape the live trace showed.
+  await m.ingest([
+    ["Ice is cold", "cold"],
+    ["Fire is hot", "hot"],
+    ["Steel is hard", "hard"],
+    ["Water is wet", "wet"],
+    ["Ice is cold", "Water is wet"],
+    ["Something else entirely", "Water is wet"],
+  ]);
+
+  const steps = [];
+  // The query already contains "wet" verbatim (as if some earlier turn had
+  // already mentioned it) — reason() and CAST both must recognise the
+  // followed edge restates it, not append it a second time.
+  const r = await m.respond(
+    "What if steel were cold? Not wet.",
+    (s) => steps.push(s),
+  );
+  const got = new TextDecoder().decode(r.bytes).replace(/\0/g, "");
+  assert.ok(
+    !got.includes("wet") || got.includes("Not wet"),
+    `substitution must not append "wet" a second time — it already restates ` +
+      `the query, got "${got}"`,
+  );
+
+  const proj = steps.find((s) =>
+    s.mechanism.at(-1) === "projectCounterfactual" &&
+    s.inputs.some((i) => i.role === "filler")
+  );
+  assert.ok(
+    proj,
+    "expected the substitution schema's projectCounterfactual step",
+  );
+  const projected = new TextDecoder().decode(
+    new TextEncoder().encode(proj.outputs[0].text),
+  );
+  assert.ok(
+    !projected.includes("wet"),
+    `the substitution's own projection must stop before the restating hop, got "${projected}"`,
+  );
+  await m.store.close();
+});
+
+test("CAST substitution: an ordinary followed edge onto genuinely new content is unaffected", async () => {
+  const m = mk(7);
+  await m.ingest([
+    ["Ice is cold", "cold"],
+    ["Fire is hot", "hot"],
+    ["Steel is hard", "hard"],
+    ["Water is wet", "wet"],
+    ["Ice is cold", "Water is wet"],
+    ["Something else entirely", "Water is wet"],
+  ]);
+
+  const steps = [];
+  const r = await m.respond("What if steel were cold?", (s) => steps.push(s));
+  const got = new TextDecoder().decode(r.bytes).replace(/\0/g, "");
+  assert.ok(
+    got.includes("wet"),
+    `an ordinary followed edge onto content the query never mentioned must ` +
+      `still fire, got "${got}"`,
+  );
+  await m.store.close();
+});

package/test/40-choosenext-scale-guard.test.mjs

@@ -0,0 +1,75 @@
+// 40-choosenext-scale-guard.test.mjs — chooseNext's disambiguation must not
+// be gated by consensusFloor(N) at corpus scale.
+//
+// Traced live (analyze_training.ts, robustness probe "typo in query"):
+// "What is the capitol of France?" (typo: capitol→capital) correctly
+// resonates onto the learnt node "What is the capital of France?", whose
+// forward edges are UNAMBIGUOUSLY dominated by "The capital of France is
+// Paris." (prevCount 2, vs 1/1/1 for three other edges) — a genuine,
+// structural winner by chooseNext's own loop (traverse.ts:517-529), which
+// already requires strict dominance; a tie leaves first-inserted as the
+// pick, exactly the "no real winner" case a floor would matter for.
+//
+// But chooseNext ALSO gated this pick on `bestSupport < consensusFloor(N)`
+// once the corpus scale crosses atomIsHub's threshold (traverse.ts:541-546)
+// — reusing the SAME ln(N)+0.5 floor recallByResonance and commitVotes use
+// for POOLED, IDF-weighted CLIMB VOTES (each region worth up to ln N, so a
+// sum exceeding ln N + 0.5 is more than any one region could say alone —
+// HOW_IT_WORKS.md §8.6).  `prevCount(candidate)` is a different kind of
+// quantity: a raw count of how many training contexts independently
+// predicted ONE destination, bounded by how many times that specific fact
+// was retold — NOT by corpus size N.  Gating an N-invariant count against
+// an N-growing threshold guarantees failure once N is large enough
+// (verified live: N≈325K gives a floor of ≈13.19, so a genuinely dominant
+// but only-doubly-attested fact like "capital of France → Paris" was
+// refused, falling back to a noisy concept-hop that produced the wrong
+// answer).  HOW_IT_WORKS.md's own canonical chooseNext pseudocode (§25)
+// has NO such floor — it's undocumented implementation drift, not a
+// deliberate design surface.  Fix: remove the gate; chooseNext's existing
+// strict-dominance loop already IS the "genuinely competing" test.
+
+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 { chooseNext } from "../dist/src/mind/traverse.js";
+import { gistOf, resolve } from "../dist/src/mind/primitives.js";
+
+const enc = (s) => new TextEncoder().encode(s);
+
+test("chooseNext: a genuinely-dominant edge is trusted at large corpus scale", async () => {
+  const m = new Mind({ seed: 7, store: new SQliteStore({ path: ":memory:" }) });
+
+  // Push edgeSourceCount() well past atomIsHub's crossover (N > ~4096 at
+  // the default maxGroup=4) with cheap, unrelated filler facts — this is
+  // the ONLY way to exercise the scale-gated branch at all; every existing
+  // chooseNext test (test/30) stays at small N, where the gate was already
+  // inert (consensusFloor(N) < 2 for N < 4.5), so none of them cover this.
+  const filler = [];
+  for (let i = 0; i < 4300; i++) filler.push([`filler-${i}`, `f${i}`]);
+  await m.ingest(filler);
+
+  // "trigger" has three continuations: "winner" is corroborated by TWO
+  // distinct contexts ("trigger" itself and "also trigger"); the other two
+  // by one each — an unambiguous, strictly-dominant winner.
+  await m.ingest([
+    ["trigger", "winner"],
+    ["trigger", "loserA"],
+    ["trigger", "loserB"],
+    ["also trigger", "winner"],
+  ]);
+
+  const triggerId = resolve(m, enc("trigger"));
+  const winnerId = resolve(m, enc("winner"));
+  assert.ok(triggerId !== null && winnerId !== null, "corpus must resolve");
+
+  const guide = gistOf(m, enc("trigger"));
+  const picked = chooseNext(m, triggerId, guide);
+  assert.equal(
+    picked,
+    winnerId,
+    `expected chooseNext to trust the strictly-dominant edge (prevCount 2 ` +
+      `vs 1/1/1) even at large corpus scale, got ${picked}`,
+  );
+  await m.store.close();
+});

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