@hviana/sema 0.9.0 → 0.9.2

package/test/153-a-cheaper-bound-is-looked-at-first.test.mjs

@@ -0,0 +1,155 @@
+// 153-a-cheaper-bound-is-looked-at-first.test.mjs — the market and the span
+// probe do the same work for less.
+//
+// THE MARKET.  Mechanisms run in declared order and are pruned by the
+// incumbent — but a mechanism floored LOWER than one about to invest, declared
+// after it, could not prune it.  Measured on the 31.7M-node store: a query that
+// opens a trained form (#114 of the battery) was won by prefix-completion at
+// grade 1 after CAST (floor grade 2) had paid the consensus climb and the weave,
+// and confluence, extraction and reference their reads.  The grounding loop now
+// runs such a mechanism AHEAD (pipeline.ts, "a cheaper bound is looked at before
+// a dearer one is paid for") and skips what cannot beat the grade it reaches.
+//
+// THE SPAN PROBE.  Recognition's interior pass probes every span of up to
+// `reach` bytes past each endpoint, and each probe hashed its span from the
+// start — O(n·reach²) bytes (251,660,406 for one response on that store).
+// `Store.flatSpans` extends the hash a start was last probed at instead.
+//
+// Pinned:
+//   153.1 a mechanism floored below CAST's, run ahead, skips CAST and the rest
+//         of the composition market — and the weave is never paid for;
+//   153.2 the decision is the declared order's: the same answer, from the same
+//         mechanism, as a market whose bounds are hidden from the run-ahead;
+//   153.3 a bound that does not undercut the dearer floor runs nothing ahead:
+//         a query the cover grounds whole runs the cover alone;
+//   153.4 the span prober answers exactly `findFlatBranch` over the same span,
+//         in every order a scanner can ask in.
+
+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 FORM =
+  "What time does the movie start? We would need to start between 7-7:30pm";
+const QUERY = "What time does the movie start?";
+
+async function fixture() {
+  const mind = new Mind({
+    seed: 7,
+    profile: true,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  await mind.ingest([
+    [FORM, "Sure, let me check the showtimes."],
+    ["Do you like thrillers?", "Yes, I love them."],
+    ["The movie was great.", "I agree."],
+  ]);
+  return mind;
+}
+
+/** The decision a market reaches when no mechanism can be run ahead: every
+ *  floor answers the run-ahead's refusing probe with 0, which no later floor
+ *  undercuts — so the loop is the plain declared-order loop.  (A real
+ *  `worthRunning` accepts a floor of −∞; only the refusing probe declines it.) */
+function declaredOrder(mind) {
+  for (let i = 0; i < mind.mechanisms.length; i++) {
+    const m = mind.mechanisms[i];
+    mind.mechanisms[i] = {
+      ...m,
+      floor: (ctx, q, pre, worth) =>
+        worth(-Infinity) ? m.floor(ctx, q, pre, worth) : Promise.resolve(0),
+      run: m.run.bind(m),
+    };
+  }
+}
+
+/** The winning candidate's provenance, read off the rationale. */
+async function decide(mind, q) {
+  let winner = null;
+  const answer = await mind.respondText(q, (s) => {
+    if (s.mechanism.at(-1) === "decideGrounding") {
+      winner = s.data.candidates.find((c) => c.decided);
+    }
+  });
+  return { answer, winner };
+}
+
+test("153.1 a cheaper bound run ahead skips the composition market", async () => {
+  const mind = await fixture();
+  const answer = await mind.respondText(QUERY);
+  const c = mind.lastCost.counters;
+  const phases = mind.lastCost.phases;
+  assert.equal(answer, "Sure, let me check the showtimes.");
+  assert.ok(
+    c.mechanismsBounded >= 4,
+    `cast, confluence, extraction and reference are bounded out: ${c.mechanismsBounded}`,
+  );
+  assert.equal(phases["cast.run"], undefined, "CAST never runs");
+  assert.equal(phases["weave"], undefined, "the weave is never paid for");
+  await mind.store.close();
+});
+
+test("153.2 the decision is the declared order's", async () => {
+  const ahead = await fixture();
+  const plain = await fixture();
+  declaredOrder(plain);
+  const a = await decide(ahead, QUERY);
+  const p = await decide(plain, QUERY);
+  assert.equal(a.answer, p.answer);
+  assert.equal(a.winner.provenance, p.winner.provenance);
+  assert.equal(a.winner.weight, p.winner.weight);
+  // …and the oracle really is the dearer market: there, CAST paid for the
+  // weave, and confluence ran.
+  assert.ok(plain.lastCost.phases["weave"] !== undefined);
+  assert.ok(plain.lastCost.phases["confluence.run"] !== undefined);
+  assert.equal(ahead.lastCost.phases["confluence.run"], undefined);
+  await ahead.store.close();
+  await plain.store.close();
+});
+
+test("153.3 a cover that grounds whole runs nothing ahead", async () => {
+  const mind = await fixture();
+  assert.equal(
+    await mind.respondText("Do you like thrillers?"),
+    "Yes, I love them.",
+  );
+  const c = mind.lastCost.counters;
+  assert.equal(c.mechanismRuns, 1, "the cover alone");
+  assert.equal(c.mechanismsBounded ?? 0, 0);
+  await mind.store.close();
+});
+
+test("153.4 the span prober answers exactly findFlatBranch", async () => {
+  const mind = await fixture();
+  const store = mind.store;
+  const bytes = new TextEncoder().encode(
+    `${FORM} Do you like thrillers? The movie was great. ${QUERY}`,
+  );
+  const n = bytes.length;
+  const want = (s, e) => store.findFlatBranch(bytes.subarray(s, e));
+  const probe = store.flatSpans(bytes);
+  let hits = 0, asked = 0;
+  const check = (s, e) => {
+    const got = probe(s, e);
+    assert.equal(got, want(s, e), `span [${s},${e})`);
+    asked++;
+    if (got !== null) hits++;
+  };
+  // Ends ascending per start (the extension path)…
+  for (let e = 1; e <= n; e++) {
+    for (let s = Math.max(0, e - 40); s < e; s++) {
+      check(s, e);
+    }
+  }
+  // …a suffix then its one-byte trim (the short path), and revisits that end
+  // BEFORE the last probe of their start (the rehash path).
+  for (let s = n - 1; s >= 0; s--) {
+    check(s, n);
+    check(s, n - 1 > s ? n - 1 : n);
+    check(s, Math.min(n, s + 3));
+  }
+  assert.ok(asked > 5_000, `probes asked: ${asked}`);
+  assert.ok(hits > 50, `the buffer must hold stored flat spans: ${hits}`);
+  await store.close();
+});

package/test/154-the-question-names-the-step.test.mjs

@@ -0,0 +1,281 @@
+// 154-the-question-names-the-step.test.mjs — a stored structure is identified
+// by the material at hand, wherever the pieces of that material came from.
+//
+// THE OPERATION (src/mind/evidence.ts).  A stored form is WITNESSED by some
+// material when every one of its bytes lies in a W-window the material holds —
+// in any order, at any place.  The corpus writes down, for every continuation,
+// the questions that establish it (its predecessors).  A continuation is NAMED
+// when one of those questions is witnessed by the asker's bytes plus the node
+// being followed.
+//
+// THE DEFECTS IT CLOSES, measured on the 31.7M-node store and on 5,236 held-out
+// 2WikiMultihopQA compositional questions deposited exactly as the trainer
+// deposits their evidence triples (example/train_base/corpora/wiki2.ts):
+//   • the forward choice among a node's continuations read popularity only, so
+//     `Who is the father of Frederick II?` answered the most-poured of his
+//     eight facts (his citizenship) — the father fact's own establishing
+//     question `Frederick II father` lay wholly inside the question;
+//   • the walk consumed EVERY form recognised inside the first hop's answer, the
+//     entity the hop introduced included, so the chain could not step past it
+//     (3 pivot steps over 133 compositional questions);
+//   • the second hop's establishing question is held by neither the question
+//     (1% of the 5,236) nor the first hop's fact, only by both (41%).
+//
+// Pinned:
+//   154.1 witnessing is order-free, complete or nothing, credits a window to the
+//         last source that holds it, and refuses a form below one window;
+//   154.2 the continuation the question names wins over the most-poured one;
+//   154.3 the second hop is named by question material plus the entity the
+//         first hop introduced — neither alone holds it;
+//   154.4 a question that names no further step is not extended: the material
+//         that named the first hop cannot name a second;
+//   154.5 a fragment (`director`, inside every `… director` question) answers
+//         other questions: the cover voices none of its continuations unless the
+//         question names one.
+
+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 { windowIndex, witness } from "../dist/src/mind/evidence.js";
+
+const enc = (s) => new TextEncoder().encode(s);
+
+/** Deposit triples as the trainer does: the relation fact under both the
+ *  subject-relation key and the bare subject (wiki2.ts). */
+function deposits(triples) {
+  const items = [];
+  for (const [s, r, o] of triples) {
+    const fact = `The ${r} of ${s} is ${o}.`;
+    items.push([`${s} ${r}`, fact], [s, fact]);
+  }
+  return items;
+}
+
+const TRIPLES = [
+  // Distractors deposited FIRST: every relation the questions name has older,
+  // unrelated instances, so neither first-insertion nor popularity can land on
+  // the asked fact by accident.
+  ["Marius", "place of death", "Marseille"],
+  ["Jinpa", "director", "Pema Tseden"],
+  ["Kalippava", "place of death", "Kochi"],
+  ["Le Guignolo", "director", "Georges Lautner"],
+  // Frederick II: the citizenship fact first and repeated, so popularity and
+  // first-insertion both pick it.
+  ["Frederick II", "country of citizenship", "Holy Roman Empire"],
+  ["Frederick II", "place of death", "Wartburg"],
+  ["Frederick II", "father", "Peter III of Aragon"],
+  ["Peter III of Aragon", "father", "James I of Aragon"],
+  ["Peter III of Aragon", "place of birth", "Valencia"],
+  // A two-hop chain.
+  ["Beat Girl", "director", "Edmond T. Gréville"],
+  ["Edmond T. Gréville", "place of death", "Nice"],
+  ["Edmond T. Gréville", "place of birth", "Nice"],
+  ["Polish-Russian War", "director", "Xawery Żuławski"],
+  ["Xawery Żuławski", "mother", "Małgorzata Braunek"],
+  ["Juan Carlos Gumucio", "spouse", "Marie Colvin"],
+  ["Marie Colvin", "place of death", "Homs"],
+  ["Ronnie Rocket", "director", "David Lynch"],
+  ["Who...", "performer", "Ayumi Hamasaki"],
+  ["Ayumi Hamasaki", "place of birth", "Fukuoka"],
+  ["David Lynch", "place of birth", "Missoula, Montana"],
+];
+
+/** Filler facts in the same template, lexically varied (the test/99 recipe):
+ *  without them the store is too small for any window to be SCAFFOLDING, and
+ *  ` is `, `The `, ` of ` would read as owed question material — a regime the
+ *  trained store never is in. */
+const WORDS =
+  ("alpha bravo charlie delta echo foxtrot golf hotel india juliet " +
+    "kilo lima mike november oscar papa quebec romeo sierra tango uniform " +
+    "victor whiskey xray yankee zulu amber bronze copper dahlia ember fjord " +
+    "gossamer harbour indigo jasmine kestrel lantern marigold nectar opal")
+    .split(" ");
+const RELATIONS = ["award received", "employer", "director", "performer"];
+function fillers(n) {
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const w = (k) => WORDS[(i * 7 + k * 13) % WORDS.length];
+    out.push([
+      `${w(0)} ${w(1)}`,
+      RELATIONS[i % RELATIONS.length],
+      `${w(2)} ${w(3)}`,
+    ]);
+  }
+  return out;
+}
+
+async function fixture() {
+  const mind = new Mind({
+    seed: 7,
+    profile: true,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  await mind.ingest(deposits(fillers(120)));
+  await mind.ingest(deposits(TRIPLES));
+  // Pour the citizenship fact again, so the distributional ladder prefers it.
+  await mind.ingest([[
+    "Frederick II",
+    "The country of citizenship of Frederick II is Holy Roman Empire.",
+  ]]);
+  return mind;
+}
+
+test("154.1 witnessing is order-free, complete or nothing, and credits the last holder", () => {
+  const W = 4;
+  const question = enc("What is the country of citizenship of Frederick II?");
+  const node = enc("Frederick II");
+  const qi = windowIndex(question, W);
+  const ni = windowIndex(node, W);
+  // Reordered pieces are witnessed; the question is credited only with what
+  // the node does not hold.
+  const w = witness(enc("Frederick II country of citizenship"), [qi, ni], W);
+  assert.equal(w.complete, true);
+  const said = w.spans.map(([s, e]) =>
+    new TextDecoder().decode(question.subarray(s, e))
+  );
+  assert.deepEqual(said, [" country of citizenship"]);
+  // One byte no source holds refuses the whole form.
+  assert.equal(
+    witness(enc("Frederick II country of citizenshop"), [qi, ni], W).complete,
+    false,
+  );
+  // Below one window nothing is witnessed.
+  assert.equal(witness(enc("Fre"), [qi, ni], W).complete, false);
+});
+
+/** The answer plus the rationale steps the assertions read. */
+async function ask(mind, question) {
+  const steps = [];
+  const answer = await mind.respondText(question, (st) => {
+    const name = st.mechanism.at(-1);
+    if (
+      name === "recallByResonance" || name === "askedContinuation" ||
+      name === "pivotStep" || name === "liftAnswer"
+    ) {
+      steps.push({
+        name,
+        note: st.note ?? "",
+        inputs: st.inputs.map((o) => o.text ?? ""),
+        outputs: st.outputs.map((o) => o.text ?? ""),
+      });
+    }
+  });
+  return { answer, steps };
+}
+
+const FATHER = "The father of Frederick II is Peter III of Aragon.";
+const DEATH = "The place of death of Edmond T. Gréville is Nice.";
+
+test("154.2 the continuation the question names wins over the most-poured one", async () => {
+  const mind = await fixture();
+  const { answer, steps } = await ask(
+    mind,
+    "Who is the father of Frederick II?",
+  );
+  // The projection that grounds on the argument `Frederick II` crosses the
+  // father fact — the one whose own question `Frederick II father` the asker's
+  // bytes witness — not the citizenship fact popularity prefers.
+  const bound = steps.find((s) =>
+    s.name === "recallByResonance" && /argument binding/.test(s.note)
+  );
+  assert.ok(bound, "the argument binding must ground");
+  assert.equal(bound.outputs[0], FATHER);
+  const named = steps.find((s) =>
+    s.name === "askedContinuation" && s.inputs[1] === "Frederick II father"
+  );
+  assert.ok(named, "the rationale names the witnessed question");
+  assert.deepEqual(named.outputs, [FATHER]);
+  assert.match(answer, /The father of Frederick II is Peter III of Aragon\./);
+  await mind.store.close();
+});
+
+test("154.3 the second hop is named by the question plus the entity the first hop introduced", async () => {
+  const mind = await fixture();
+  const { answer, steps } = await ask(
+    mind,
+    "Where was the place of death of the director of film Beat Girl?",
+  );
+  const pivot = steps.find((s) => s.name === "pivotStep");
+  assert.ok(pivot, "the chain must step past the first hop");
+  assert.equal(pivot.inputs[1], "Edmond T. Gréville");
+  assert.equal(pivot.outputs[0], DEATH);
+  // …through the question neither source holds alone.
+  assert.ok(
+    steps.some((s) =>
+      s.name === "askedContinuation" &&
+      s.inputs[1] === "Edmond T. Gréville place of death" &&
+      s.outputs.includes(DEATH)
+    ),
+    "the hop is named by `Edmond T. Gréville place of death`",
+  );
+  assert.match(answer, /The place of death of Edmond T\. Gréville is Nice\./);
+  // The same chain whatever grounded the first hop: a CAST substitution, which
+  // declares the anchor it voices — whose continuation IS the answer, voiced and
+  // not withheld — and a cover, which declares nothing, so what it spoke for is
+  // what of the answer the question already holds, never the entity it added.
+  for (
+    const [question, fact] of [
+      [
+        "What is the place of birth of the performer of song Who...?",
+        "The place of birth of Ayumi Hamasaki is Fukuoka.",
+      ],
+      [
+        "Where was the place of death of Juan Carlos Gumucio's wife?",
+        "The place of death of Marie Colvin is Homs.",
+      ],
+    ]
+  ) {
+    const chained = await ask(mind, question);
+    assert.equal(chained.answer, fact, question);
+  }
+  await mind.store.close();
+});
+
+test("154.4 a question that names no further step is not extended", async () => {
+  const mind = await fixture();
+  const { answer, steps } = await ask(
+    mind,
+    "Who is the father of Frederick II?",
+  );
+  // `Peter III of Aragon father` is a stored question too — but `father` was
+  // said by the hop that reached Peter III, so nothing names the grandfather.
+  assert.equal(
+    steps.filter((s) => s.name === "pivotStep").length,
+    0,
+    "no further step is taken",
+  );
+  assert.doesNotMatch(answer, /James I/);
+  assert.doesNotMatch(answer, /Valencia/);
+  // …and a one-hop question whose answer introduces an entity with facts of
+  // its own stops at that answer: nothing the asker still owes is discriminative
+  // (`Who is the` is frame), so no step can claim to pay it by restating ` is `.
+  // The material that named a hop names no second one, however the question
+  // is phrased: `Who was Frederick II's father?` says `father` once.
+  const again = await ask(mind, "Who was Frederick II's father?");
+  assert.equal(again.answer, FATHER);
+  const one = await ask(mind, "Who is the director of Beat Girl?");
+  assert.equal(one.answer, "The director of Beat Girl is Edmond T. Gréville.");
+  assert.equal(one.steps.filter((s) => s.name === "pivotStep").length, 0);
+  await mind.store.close();
+});
+
+test("154.5 a fragment answers other questions unless the question names one", async () => {
+  const mind = await fixture();
+  const { steps } = await ask(
+    mind,
+    "Where did the director of film Beat Girl die?",
+  );
+  // The cover's own composition: `director` sits inside every `… director`
+  // question, so its continuations are the directors of OTHER films — voicing
+  // one of them by popularity glued a stranger's fact onto the answer.
+  const composed = steps.filter((s) => s.name === "liftAnswer").map((s) =>
+    s.outputs[0]
+  );
+  assert.ok(composed.length > 0, "the cover composed");
+  for (const c of composed) {
+    assert.equal(c, "The director of Beat Girl is Edmond T. Gréville.");
+  }
+  assert.ok(mind.lastCost.counters.unaskedFragments > 0);
+  await mind.store.close();
+});

package/test/24-generalization.test.mjs

@@ -264,6 +264,38 @@ test("3.1 — a two-topic query fuses BOTH points of attention", async () => {
   );
 });
 
+test("3.1 — the second topic is fused on its OWN wording, never on a sub-window anchor", async () => {
+  // Observed before the fix (attention.ts canonicalChunkId): the region
+  // `ace and ` — inside the OTHER topic's words, "workplace and about" — had a
+  // saturated window replaced by its unsaturated 2-byte prefix `e `, that
+  // sub-window anchor voted for the Dream Team context, and its position was
+  // the "second cluster" the dispersion gate let the topic through on.  The
+  // fusion passed on scaffolding.  Pinned here: the Dream Team root is a
+  // committed point of attention whose every contributing region lies in the
+  // topic's own words, AND it is fused into the answer.
+  const m = await twoTopicMind();
+  let anchors = null;
+  const got = await m.respondText(TWO_TOPIC_QUERY, (s) => {
+    if (s.mechanism.at(-1) === "climbConsensus" && s.data?.anchors) {
+      anchors = s.data.anchors;
+    }
+  });
+  const topic = (a) =>
+    new TextDecoder().decode(m.store.bytes(a.anchor)).includes("Dream Team");
+  const root = anchors?.find((a) => a.commit.status === "root" && topic(a));
+  await m.store.close();
+  assert.ok(root, "the Dream Team context must be a committed root");
+  const own = TWO_TOPIC_QUERY.indexOf(" the 1992 Dream Team");
+  const foreign = root.contributingSpans.filter(([s]) => s < own);
+  assert.deepEqual(
+    foreign,
+    [],
+    `the Dream Team root is supported from outside its own words: ` +
+      JSON.stringify(foreign.map(([s, e]) => TWO_TOPIC_QUERY.slice(s, e))),
+  );
+  assert.match(got, /Barcelona|gold|Dream Team/i);
+});
+
 test("3.1 — the trace surfaces MORE THAN ONE ordered anchor for a two-topic query", async () => {
   const m = await twoTopicMind();
   const steps = [];

package/test/36-bloom.test.mjs

@@ -14,11 +14,18 @@
 //                       persisted filter (or a stale one); reopen must
 //                       rebuild/top-up from the table and STILL dedup all
 //                       previously-minted content, with zero duplicates.
+//
+// The CANON index's filter (canon_bloom) has the same hazard — a false
+// negative there is a canonical form `canonFind` silently fails to propose —
+// and is pinned the same way: across reopen, across rows added after a
+// persisted filter exists, and against a writer that adds rows without
+// touching the filter (its stamp disagrees with the meta, so it is rebuilt).
 
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
 import { rmSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
 import { SQliteStore } from "../dist/src/store-sqlite.js";
 
 const cleanup = (path) => {
@@ -121,3 +128,49 @@ test("crash: reopen after an unclean exit still dedups everything", (t) => {
   execFileSync(process.execPath, ["-e", phase2], { stdio: "pipe" });
   assert.ok(true);
 });
+
+test("canon filter: persisted with its rows, rebuilt when its stamp is stale", async (t) => {
+  const path = `/tmp/bloom-canon-${process.pid}`;
+  t.after(() => cleanup(path));
+  const H = (i) => (i * 2654435761) >>> 0;
+  const findsAll = (s, from, to) => {
+    for (let i = from; i < to; i++) {
+      assert.deepEqual(s.canonFind(H(i)), [i], `canon row ${i} not proposed`);
+    }
+  };
+
+  // Session 1: rows written by the store itself, then committed and closed.
+  let s = new SQliteStore({ path, D: 64 });
+  await s.size();
+  for (let i = 0; i < 200; i++) s.canonAdd(H(i), i);
+  await s.setMeta("canon.upto", "200");
+  s.commit();
+  findsAll(s, 0, 200);
+  await s.close();
+
+  // Session 2: the persisted filter is loaded, and rows added on top of it
+  // are seen in this session and after the next reopen.
+  s = new SQliteStore({ path, D: 64 });
+  await s.size();
+  findsAll(s, 0, 200);
+  for (let i = 200; i < 300; i++) s.canonAdd(H(i), i);
+  await s.setMeta("canon.upto", "300");
+  s.commit();
+  findsAll(s, 0, 300);
+  await s.close();
+
+  // A writer that knows nothing of the filter (an older build) adds rows and
+  // advances the cursor, as every canon build does.
+  const db = new DatabaseSync(path + ".sqlite");
+  for (let i = 300; i < 350; i++) {
+    db.prepare("INSERT INTO canon (h, id) VALUES (?, ?)").run(H(i), i);
+  }
+  db.prepare("UPDATE meta SET val = '350' WHERE key = 'canon.upto'").run();
+  db.close();
+
+  s = new SQliteStore({ path, D: 64 });
+  await s.size();
+  findsAll(s, 0, 350);
+  assert.deepEqual(s.canonFind(H(9999)), [], "an absent key is not proposed");
+  await s.close();
+});

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

@@ -215,3 +215,78 @@ test("fuseAttention: 1 cluster, low breadth — neither measure saves it (the li
   );
   await m.store.close();
 });
+
+// ═══════════════════════════════════════════════════════════════════════════
+// The dispersion question asked of the CONTEXT (reasoning.ts sharedPlaces).
+// The votes that land on a root are a lossy witness of where the query and the
+// root's context agree: a region votes once, for its top anchor, so a frame
+// every context shares corroborates whichever anchor a tie hands it.  The
+// context's own bytes answer the question exactly — at window scale, in how
+// many separate places of the query does it share content?  These two cases
+// pin both directions with REAL anchors (a stored context and its learnt
+// continuation), each fabricated as a one-cluster, low-breadth root so that
+// only the new reading can decide.
+// ═══════════════════════════════════════════════════════════════════════════
+
+async function sharedPlacesCase(contextText, query) {
+  const m = mk(1);
+  await m.ingest([
+    ...CORPUS,
+    [contextText, "the omega continuation"],
+  ]);
+  const q = enc(query);
+  m.beginResponse();
+  const anchor = m.recogniseSpan(enc(contextText)).sites
+    .find((s) => s.start === 0 && s.end === contextText.length)?.payload;
+  m.endResponse();
+  assert.ok(anchor !== undefined, "the context must be a stored form");
+  const root = {
+    anchor,
+    vote: 1,
+    idfVote: 1,
+    peak: 1,
+    start: 0,
+    end: q.length,
+    clusters: 1,
+    breadth: 0.1,
+  };
+  const placeholder = { ...root, start: q.length, end: q.length };
+  const primary = enc("PRIMARYANCHORTEXT");
+  const out = dec(
+    (await fuseAttention(m, q, {
+      product: primary,
+      accounted: [],
+      remainder: [],
+      cost: 0,
+    }, {
+      attention: async () => ({
+        roots: [placeholder, root],
+        ranked: [placeholder, root],
+      }),
+      guide: gistOf(m, q),
+    })).product,
+  );
+  await m.store.close();
+  return { out, primary: dec(primary) };
+}
+
+test("fuseAttention: a context sharing ONE phrase with the query does not fuse, however long the phrase (the live echo shape)", async () => {
+  // The live defect's shape: the query's closing phrase is byte-identical to
+  // how an unrelated conversation ended.  Many windows, ONE place.
+  const { out, primary } = await sharedPlacesCase(
+    "Thank you very much!",
+    "red circle then 2+2 equals what. Thank you very much!",
+  );
+  assert.equal(out, primary, `a one-place echo fused in: "${out}"`);
+});
+
+test("fuseAttention: a context sharing TWO separate places with the query fuses, even when its votes formed one cluster", async () => {
+  const { out, primary } = await sharedPlacesCase(
+    "red circle at noon, and then: Thank you very much!",
+    "red circle then 2+2 equals what. Thank you very much!",
+  );
+  assert.ok(
+    out.includes("omega") && out.includes(primary),
+    `a two-place context must fuse in, got "${out}"`,
+  );
+});

package/test/48-recognise-turn-connective.test.mjs

@@ -32,7 +32,8 @@ 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 { latin1Key, perceive, resolve } from "../dist/src/mind/primitives.js";
+import { perceive, resolve } from "../dist/src/mind/primitives.js";
+import { latin1 } from "../dist/src/bytes.js";
 
 const enc = (s) => new TextEncoder().encode(s);
 const dec = (b) => new TextDecoder().decode(b).replace(/\0+$/, "");
@@ -71,7 +72,7 @@ test("recognise(): a real leading connective word ('And ') still finds the train
   const boundaries = [30, 61];
   m.perceiveMemo = new Map();
   m.perceiveMemo.set(
-    latin1Key(query),
+    latin1(query),
     perceive(m, query, undefined, undefined, boundaries),
   );
 

package/test/55-cost-meter.test.mjs

@@ -156,10 +156,10 @@ test("7. a bigger query costs more than a smaller one", async () => {
     "the capital of France is and the capital of Japan is and Paris is in",
   );
   const big = mind.lastCost.counters;
-  assert.ok(
-    big.perceivedBytes > small.perceivedBytes,
-    "perception cost tracks query length",
-  );
+  // Fold work in both of its forms: the vector fold (perception) and the
+  // identity fold `exactNode` reads a node id through without vectors.
+  const folded = (c) => (c.perceivedBytes ?? 0) + (c.identityBytes ?? 0);
+  assert.ok(folded(big) > folded(small), "fold cost tracks query length");
   await mind.store.close();
 });