@hviana/sema 0.2.2 → 0.2.4

package/test/36-already-answered-fusion.test.mjs

@@ -0,0 +1,128 @@
+// 36-already-answered-fusion.test.mjs — a point of attention whose own
+// learnt continuation is ALREADY present later in the query must not be
+// fused in again.
+//
+// This is Category A of a two-part defect found while investigating a
+// multi-turn dialogue's garbled fusion ("Thank you very much!" fused with
+// unrelated points of attention).  One of those points (root "Hello",
+// anchor of the greeting) traced back to substantial, genuine regions —
+// not noise — and its learnt continuation ("Hello! How can I assist you
+// today?") was found to be VERBATIM present earlier in the query, because
+// it was Sema's own prior reply, appended by addTurn the same way any turn
+// is appended.  Re-surfacing it is redundant: the query has already spoken
+// its own answer.
+//
+// Deliberately turn-agnostic and Mind-bookkeeping-free: Mind's multi-turn
+// API is strictly a computational optimization (incremental fold reuse) —
+// it must never be the thing inference depends on for correctness.  This
+// check uses only what already exists for ANY accumulated byte stream,
+// single-shot or multi-turn: `follow()` (the same content-addressed
+// continuation walk `reason()`'s own echo guard already uses,
+// `ctx.store.prevCount(qId) > 0`, just applied per-candidate-root instead
+// of to the whole query) and plain byte containment.  A query that embeds
+// its own prior exchange — via real respondTurn(), or a caller manually
+// pasting a transcript into one respond() call — is caught identically.
+//
+// (Category B — coincidental echo of a short, generic CURRENT-turn phrase
+// against unrelated corpus content, unrelated to staleness — is a SEPARATE
+// defect, not addressed here; see the investigation notes for why breadth
+// and regionSupport both fail to discriminate it from genuine fusion.)
+
+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();
+
+// "greet" leads to "reply-greet" — a learnt exchange the query embeds BOTH
+// halves of, exactly the shape addTurn produces (ask, then the system's own
+// reply, concatenated raw).  "red circle" is a genuine, unrelated second
+// topic (test/34's own binding corpus) whose own continuation is nowhere
+// in the query — the ordinary multi-topic case, which must still fuse.
+const CORPUS = [
+  ["greet", "reply-greet"],
+  ["red", "is a color"],
+  ["blue", "is a color"],
+  ["circle", "is a shape"],
+  ["square", "is a shape"],
+  ["red circle", "answer alpha"],
+  ["red square", "answer beta"],
+  ["blue circle", "answer gamma"],
+  ["blue square", "answer delta"],
+];
+
+const mk = (seed) =>
+  new Mind({ seed, store: new SQliteStore({ path: ":memory:" }) });
+
+test("fuseAttention: a root whose continuation is already answered in the query is excluded", async () => {
+  const m = mk(1);
+  await m.ingest(CORPUS);
+  // "greet"'s own continuation, "reply-greet", is embedded right in the
+  // query — the ask and its answer both present, exactly like a
+  // conversation's own turn + reply.  "red circle" is a genuine further
+  // topic with no such embedded answer.
+  const q = enc("greet reply-greet then red then circle");
+  const roots = await m.climbAttention(q, 24);
+  const greet = roots.find((r) => r.start === 0);
+  const redCircle = roots.find((r) => r.start !== 0);
+  assert.ok(greet, "expected the 'greet' root at query offset 0");
+  assert.ok(redCircle, "expected the 'red circle' binding root");
+
+  const guide = gistOf(m, q);
+  const primary = enc("PRIMARYANCHORTEXT");
+  // forest[0] is never independently projected (see reasoning.ts: it is
+  // treated as already primary's own source) — a placeholder keeps BOTH
+  // real roots in `rest`, where this filter actually applies.
+  const placeholder = { ...greet, start: q.length, end: q.length };
+  const pre = {
+    attention: async () => ({
+      roots: [placeholder, greet, redCircle],
+      ranked: [placeholder, greet, redCircle],
+    }),
+    guide,
+  };
+  const out = dec(await fuseAttention(m, q, primary, pre));
+  assert.ok(
+    !out.includes("reply-greet"),
+    `a root whose continuation is already answered in the query must not fuse in, got "${out}"`,
+  );
+  assert.ok(
+    out.includes("answer alpha"),
+    `a genuine further topic with no embedded answer must still fuse in, got "${out}"`,
+  );
+  await m.store.close();
+});
+
+test("fuseAttention: ordinary multi-topic fusion (no embedded answers) is completely unaffected", async () => {
+  const m = mk(1);
+  await m.ingest(CORPUS);
+  const q = enc("red then circle");
+  const roots = await m.climbAttention(q, 24);
+  assert.equal(roots.length, 1, "expected the single joint binding root");
+  // Force a second, independent (unclimbed-style) inclusion path by
+  // reusing the SAME root twice at different synthetic positions, neither
+  // of which has an embedded answer — a pure regression check that the
+  // new filter doesn't fire when there is nothing to catch.
+  const guide = gistOf(m, q);
+  const primary = enc("PRIMARYANCHORTEXT");
+  const placeholder = { ...roots[0], start: q.length, end: q.length };
+  const pre = {
+    attention: async () => ({
+      roots: [placeholder, roots[0]],
+      ranked: [placeholder, roots[0]],
+    }),
+    guide,
+  };
+  const out = dec(await fuseAttention(m, q, primary, pre));
+  assert.ok(
+    out.includes("answer alpha"),
+    `an ordinary further topic must still fuse in, got "${out}"`,
+  );
+  await m.store.close();
+});

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