@hviana/sema 0.5.7 → 0.5.9

package/test/77-company-saturation.test.mjs

@@ -0,0 +1,302 @@
+// 77-company-saturation.test.mjs — companyProfile stops because the
+// REPRESENTATION IS FULL, not because a budget ran out.
+//
+// The old rule was `PROFILE_VISITS = 64`: a constant, and one that decided
+// which constituents entered a halo by where they sat in a BFS. It was also
+// wrong in both directions on the trained store — it fired at 64 visits while
+// capacity needed a median of 69 (dropping readable evidence), and an uncapped
+// walk accepted ~50 terms where the representation holds √D = 32.
+//
+// The replacement is derived: a superposition of m unit signatures contributes
+// 1/m per term to any cosine taken against it, so once m > √D one term moves
+// nothing above estimatorNoise(D) = 1/√D. `profileCapacity(D) = √D` is that
+// point (geometry.ts). The constituent set is stored as a bottom-k sketch keyed
+// on each unit's own identity, so membership is a property of the UNIT and not
+// of traversal order.
+//
+// Every check below reads the diagnostics companyProfile reports through
+// ingest's inspectRationale — if the instrumentation were decorative, T8 fails.
+
+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 { estimatorNoise, profileCapacity } from "../dist/src/geometry.js";
+
+/** Ingest, collecting every companyProfile diagnostic payload. */
+async function ingestTraced(mind, items) {
+  const seen = [];
+  await mind.ingest(items, undefined, undefined, (s) => {
+    if (s.mechanism[s.mechanism.length - 1] === "companyProfile") {
+      seen.push(s.data);
+    }
+  });
+  return seen;
+}
+
+/** A store that counts the reads companyProfile's stopping rule performs. */
+function countingStore(opts) {
+  const store = new SQliteStore(opts);
+  const counts = { get: 0, sketchGet: 0, sketchPut: 0, parentsFirst: 0 };
+  for (const m of ["get", "sketchGet", "sketchPut", "parentsFirst"]) {
+    const orig = store[m].bind(store);
+    store[m] = (...a) => {
+      counts[m]++;
+      return orig(...a);
+    };
+  }
+  return { store, counts };
+}
+
+const mk = (D = 1024) => {
+  const store = new SQliteStore({ path: ":memory:", D });
+  return { store, mind: new Mind({ seed: 7, store }) };
+};
+
+// A long partner whose constituents are many and mostly unique.
+const longText = (n, tail = "") =>
+  Array.from({ length: n }, (_, i) => `alpha${i} beta${i} gamma${i}`).join(
+    " ",
+  ) + tail;
+
+// ── 1. deep type-level company still works ───────────────────────────────
+// The motivating case: the shared unit sits BELOW the top of the fold, so a
+// depth-1 profile would miss it entirely (test/76 T1 is the full fixture).
+test("T1: a unit shared below depth 1 still enters both profiles", async () => {
+  const { store, mind } = mk();
+  await mind.ingest([
+    ["The Eiffel Tower is in Paris", "Tour Eiffel dia any Paris"],
+    [
+      "A completely unrelated control sentence",
+      "Another unrelated control string",
+    ],
+  ]);
+  // Both partners must have found constituents at all — an empty sketch on a
+  // full sentence is the depth-1 failure this design exists to prevent.
+  const ids = [];
+  for (let i = 0; i < store.nodeCount(); i++) {
+    const s = store.sketchGet?.(i);
+    if (s && s.length > 0) ids.push(i);
+  }
+  assert.ok(ids.length > 0, "no node acquired a non-empty constituent sketch");
+});
+
+// ── 2. training order ────────────────────────────────────────────────────
+test("T2: forward and reverse training order give identical sketches", async () => {
+  const pairs = [
+    ["The Eiffel Tower is in Paris", "Tour Eiffel dia any Paris"],
+    ["Water freezes at zero degrees", "El agua se congela a cero grados"],
+    ["The capital of France is Paris", "La capitale de la France est Paris"],
+  ];
+  const read = async (items) => {
+    const { store, mind } = mk();
+    await mind.ingest(items);
+    // Key sketches by CONTENT, not id — ids depend on mint order by design.
+    const dec = new TextDecoder();
+    const out = new Map();
+    for (let i = 0; i < store.nodeCount(); i++) {
+      const s = store.sketchGet?.(i);
+      if (!s || s.length === 0) continue;
+      const key = dec.decode(store.bytes(i).filter((x) => x !== 0));
+      out.set(
+        key,
+        s.map((n) => dec.decode(store.bytes(n).filter((x) => x !== 0))).sort(),
+      );
+    }
+    return out;
+  };
+  const fwd = await read(pairs);
+  const rev = await read([...pairs].reverse());
+  // Every partner present in both must have the SAME constituent set.
+  let compared = 0;
+  for (const [k, v] of fwd) {
+    if (!rev.has(k)) continue;
+    compared++;
+    assert.deepEqual(
+      v,
+      rev.get(k),
+      `sketch differs by training order for ${JSON.stringify(k)}`,
+    );
+  }
+  assert.ok(compared > 0, "no partner was comparable across orders");
+});
+
+// ── 3. long partners stop by SATURATION, not by a budget ─────────────────
+test("T3: a long partner reports capacity as the stop reason", async () => {
+  const { mind } = mk();
+  const diag = await ingestTraced(mind, [[
+    longText(40),
+    "a short continuation",
+  ]]);
+  const long = diag.filter((d) => d.wholeLen > 400);
+  assert.ok(long.length > 0, "expected at least one long partner");
+  for (const d of long) {
+    assert.equal(d.capacity, profileCapacity(1024), "capacity must be √D");
+    assert.equal(
+      d.stopReason,
+      "capacity",
+      "long partner must stop at capacity",
+    );
+    assert.ok(d.saturated, "long partner must report saturation");
+    assert.equal(
+      d.sketched,
+      d.capacity,
+      "sketch must be exactly capacity-sized",
+    );
+  }
+});
+
+// ── 4. a unit shared at DIFFERENT depths must not be systematically lost ──
+test("T4: a unit shared at different fold depths enters both sketches", async () => {
+  // The motivating fixture. Content-defined cuts put " Paris" at a different
+  // depth in each sentence — "The Eiffel Tower is in Paris" folds to
+  // "The Eiffel " + "Tower is in Paris", "Tour Eiffel dia any Paris" to
+  // "Tour Eiffel " + "dia any Paris" — so the shared unit is a child of
+  // NEITHER. A selection keyed on traversal position reaches it in one partner
+  // and not the other; one keyed on the unit's own identity keeps it in both.
+  //
+  // NOTE the earlier version of this test compared "zzmarker " at the head
+  // against " zzmarker" at the tail. Those are DIFFERENT BYTES, hence different
+  // node identities, so the comparison could never have been about position.
+  const { store, mind } = mk();
+  const A = "The Eiffel Tower is in Paris";
+  const B = "Tour Eiffel dia any Paris";
+  await mind.ingest([[A, B]]);
+
+  const dec = new TextDecoder();
+  const enc = new TextEncoder();
+  const nodeOf = (text) => {
+    const want = enc.encode(text);
+    for (let i = 0; i < store.nodeCount(); i++) {
+      if (store.contentLen(i, want.length + 1) !== want.length) continue;
+      const b = store.bytes(i);
+      if (b.length === want.length && b.every((x, j) => x === want[j])) {
+        return i;
+      }
+    }
+    return null;
+  };
+  const a = nodeOf(A), b = nodeOf(B);
+  assert.ok(a !== null && b !== null, "both partners must be interned");
+  const sa = store.sketchGet(a) ?? [];
+  const sb = store.sketchGet(b) ?? [];
+  assert.ok(
+    sa.length > 0 && sb.length > 0,
+    "both partners must sketch something",
+  );
+  const shared = sa.filter((n) => sb.includes(n));
+  assert.ok(
+    shared.length > 0,
+    `no shared constituent: A=${
+      JSON.stringify(sa.map((n) => dec.decode(store.bytes(n))))
+    } ` +
+      `B=${JSON.stringify(sb.map((n) => dec.decode(store.bytes(n))))}`,
+  );
+});
+
+// ── 5. an irrelevant tail must not buy unbounded work ────────────────────
+test("T5: work per profile does not grow with an irrelevant structural tail", async () => {
+  const work = [];
+  for (const n of [10, 40, 160]) {
+    const { store, counts } = countingStore({ path: ":memory:", D: 1024 });
+    const mind = new Mind({ seed: 7, store });
+    await mind.ingest([[longText(n), "continuation"]]);
+    work.push({ n, parentsFirst: counts.parentsFirst });
+  }
+  // parentsFirst is the hub probe — exactly one per SKETCHED constituent, so it
+  // measures the stopping rule's own cost. Capacity bounds it at √D per pour.
+  const cap = profileCapacity(1024);
+  for (const w of work) {
+    assert.ok(
+      w.parentsFirst <= cap * 8,
+      `hub probes ${w.parentsFirst} at n=${w.n} exceed a capacity-bounded budget`,
+    );
+  }
+  // 16x the tail must not cost 16x the stopping work.
+  const ratio = work[2].parentsFirst / Math.max(1, work[0].parentsFirst);
+  assert.ok(
+    ratio < 4,
+    `stopping work grew ${ratio.toFixed(1)}x for a 16x tail`,
+  );
+});
+
+// ── 6. corpus growth must not explode the stopping cost ──────────────────
+test("T6: the same partner costs the same to profile as the corpus grows", async () => {
+  const probe = async (extra) => {
+    const { store, counts } = countingStore({ path: ":memory:", D: 1024 });
+    const mind = new Mind({ seed: 7, store });
+    const filler = Array.from(
+      { length: extra },
+      (_, i) => [`ctx ${i} alpha`, `ans ${i} beta`],
+    );
+    await mind.ingest(filler);
+    const before = counts.parentsFirst;
+    await mind.ingest([[longText(30), "continuation"]]);
+    return counts.parentsFirst - before;
+  };
+  const small = await probe(20);
+  const large = await probe(600);
+  assert.ok(
+    large <= small * 2 + 16,
+    `profiling cost grew with corpus size: ${small} -> ${large} hub probes`,
+  );
+});
+
+// ── 7. stopping happened only once evidence was insignificant ────────────
+test("T7: saturated profiles report a marginal at or below the noise floor", async () => {
+  const { mind } = mk();
+  const diag = await ingestTraced(mind, [[
+    longText(40),
+    "a short continuation",
+  ]]);
+  const sat = diag.filter((d) => d.saturated);
+  assert.ok(sat.length > 0, "expected a saturated profile");
+  for (const d of sat) {
+    assert.equal(d.noiseFloor, estimatorNoise(1024));
+    // mass = accepted + 1, and capacity is the point where 1/mass reaches the
+    // floor. Accepting everything sketched puts marginal AT the floor; hub
+    // exclusion can leave it above, and the diagnostics must say which.
+    assert.ok(d.mass > 1, "a saturated profile superposed nothing");
+    assert.equal(d.residual, d.sketched - d.accepted);
+    assert.ok(
+      d.marginal <= d.noiseFloor || d.hubDropped + d.dominating === d.residual,
+      `marginal ${d.marginal} above floor ${d.noiseFloor} with unexplained residual`,
+    );
+  }
+});
+
+// ── 8. the instrumentation is not decorative ─────────────────────────────
+test("T8: perturbing capacity measurably moves the diagnostics", async () => {
+  // profileCapacity is √D, so changing D perturbs the saturation point. If the
+  // reported numbers did not follow, the diagnostics would be describing
+  // something other than the rule that actually stops the walk.
+  const at = async (D) => {
+    const store = new SQliteStore({ path: ":memory:", D });
+    const mind = new Mind({ seed: 7, store });
+    const diag = await ingestTraced(mind, [[
+      longText(40),
+      "a short continuation",
+    ]]);
+    return diag.filter((d) => d.saturated);
+  };
+  const small = await at(256); // capacity 16
+  const large = await at(4096); // capacity 64
+  assert.ok(
+    small.length > 0 && large.length > 0,
+    "both D values must saturate",
+  );
+  assert.equal(small[0].capacity, profileCapacity(256));
+  assert.equal(large[0].capacity, profileCapacity(4096));
+  assert.ok(
+    large[0].sketched > small[0].sketched,
+    `sketch size did not follow capacity: ${small[0].sketched} vs ${
+      large[0].sketched
+    }`,
+  );
+  assert.ok(
+    large[0].marginal < small[0].marginal,
+    `marginal did not follow capacity: ${small[0].marginal} vs ${
+      large[0].marginal
+    }`,
+  );
+});

package/test/78-atom-hub-recognition-cliff.test.mjs

@@ -0,0 +1,135 @@
+// 78-atom-hub-recognition-cliff.test.mjs — recognition must not LOSE interior
+// sites when the corpus crosses the atomIsHub threshold.
+//
+// THE BUG THIS PINS.  `atomIsHub` flips at exactly N = 4096 edge sources:
+// atomReach = ⌈N·W/256⌉ = ⌈N/64⌉ exceeds boundFor = √N there (W = 4).
+// recogniseImpl gated FOUR things on that flip, and one of them —
+// tryChain's `!boundary && atomsAreHubs` — blanket-suppressed every
+// off-boundary chain. A store crossing 4096 therefore silently stopped
+// recognising interior forms it had recognised at 4095, with no error and no
+// failing test. Measured on the two-hop fixture below: 4 sites including
+// "France" at N = 3920, 2 sites without it at N = 4227.
+//
+// The fix asks whether the byte-exact branch tryChain ALREADY found is a
+// deposited whole (`bearsEdge`) instead of whether its offset happened to land
+// on a fold cut. So the discriminating assertion is: at N > 4096, an interior
+// form that BEARS A CONTINUATION EDGE is still a recognised site.
+//
+// WHY THIS IS SLOW AND MUST STAY SO.  The threshold is a property of corpus
+// scale, so the only honest fixture is one that actually crosses it — 4300
+// deposits, ~6 s. A cheaper store would sit below the flip and pass under the
+// old code too, which is exactly the hole this file exists to close.
+
+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 { recognise } from "../dist/src/mind/recognition.js";
+import { atomIsHub, corpusN } from "../dist/src/mind/traverse.js";
+
+const CHAIN = [
+  ["Eiffel Tower country", "The country of Eiffel Tower is France."],
+  ["France capital", "The capital of France is Paris."],
+  // The PIVOT: a bare entity that bears a continuation edge, and which occurs
+  // INSIDE hop 1's answer at an offset the fold did not choose as a cut.
+  ["France", "The capital of France is Paris."],
+];
+const ANSWER = "The country of Eiffel Tower is France.";
+
+// Lexically VARIED filler. A single repeated template ("filler 12 alpha") folds
+// to a handful of shared chunks and leaves the query almost uncontested, which
+// was enough to let the two-hop chain compose even with the gate in place —
+// i.e. a templated corpus makes the behavioural test non-discriminating. Real
+// corpora are lexically diverse, so the filler must be too.
+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 " +
+    "pewter quartz ripple saffron thistle umber violet willow xenon yarrow")
+    .split(" ");
+const filler = (i) => {
+  const w = (n) => WORDS[(i * 7 + n * 13) % WORDS.length];
+  return [
+    `${w(1)} ${w(2)} ${w(3)} ${i}`,
+    `${w(4)} ${w(5)} ${w(6)} ${w(7)} ${i}`,
+  ];
+};
+
+/** One store, ingested past the atomIsHub flip. */
+async function pastTheFlip() {
+  const store = new SQliteStore({ path: ":memory:", D: 1024 });
+  const mind = new Mind({ seed: 7, store });
+  await mind.ingest(CHAIN);
+  await mind.ingest(Array.from({ length: 4300 }, (_, i) => filler(i)));
+  return { store, mind };
+}
+
+const dec = new TextDecoder();
+const textOf = (store, id) =>
+  dec.decode(store.bytes(id).filter((x) => x !== 0));
+
+test("the fixture really is past the atomIsHub threshold", async () => {
+  const { store, mind } = await pastTheFlip();
+  const n = corpusN(mind);
+  assert.ok(n > 4096, `fixture must cross N=4096, got ${n}`);
+  assert.equal(
+    atomIsHub(mind, n),
+    true,
+    "atoms must read as hubs, or this file tests nothing",
+  );
+});
+
+test("an edge-bearing interior form is still recognised past the flip", async () => {
+  const { store, mind } = await pastTheFlip();
+  mind.beginResponse?.();
+  const rec = recognise(mind, new TextEncoder().encode(ANSWER));
+  mind.endResponse?.();
+  const texts = rec.sites.map((s) => textOf(store, s.payload));
+  assert.ok(
+    texts.includes("France"),
+    `interior form "France" was not recognised past the flip; sites = ${
+      JSON.stringify(texts)
+    }`,
+  );
+});
+
+test("the interior form is reachable as a pivot, so the chain composes", async () => {
+  // The behavioural consequence: reason() pivots on the longest unconsumed
+  // learnt context the grounded answer CONTAINS. Lose the site and the hop is
+  // structurally unreachable, whatever the rest of the pipeline does.
+  const { mind } = await pastTheFlip();
+  const steps = [];
+  const out = await mind.respondText(
+    "What is the capital of the country of Eiffel Tower?",
+    (s) => steps.push(s.mechanism[s.mechanism.length - 1]),
+  );
+  assert.ok(
+    steps.includes("pivotStep"),
+    `no pivotStep past the flip; answer was ${JSON.stringify(out)}`,
+  );
+  assert.ok(
+    out.includes("Paris"),
+    `two-hop chain did not compose past the flip: ${JSON.stringify(out)}`,
+  );
+});
+
+test("a fragment that leads nowhere is still NOT recognised", async () => {
+  // The other half of the contract: the gate was protecting against
+  // opportunistic byte-atom chains, and the fix must not have opened that door.
+  // "owe" occurs inside "Eiffel Tower country" but was never deposited as a
+  // form of its own, so it bears no edge and no halo.
+  const { store, mind } = await pastTheFlip();
+  mind.beginResponse?.();
+  const rec = recognise(mind, new TextEncoder().encode(ANSWER));
+  mind.endResponse?.();
+  for (const s of rec.sites) {
+    const t = textOf(store, s.payload);
+    assert.ok(
+      t.length >= 4,
+      `sub-window fragment ${JSON.stringify(t)} was admitted as a site`,
+    );
+  }
+  // And pure noise must still ground to nothing.
+  assert.equal(await mind.respondText("qq8f3kz9 zzxq wvbn"), "");
+});

package/test/84-composed-answer-honesty.test.mjs

@@ -0,0 +1,136 @@
+// 84-composed-answer-honesty.test.mjs — a two-hop query must COMPOSE or stay
+// SILENT. It must never fabricate: never return an answer built from content
+// belonging to an unrelated deposit.
+//
+// WHAT THIS PINS, AND WHAT IT DOES NOT.
+//
+// Measured against a store fed REAL corpus text (Taskmaster dialogue + SmolSent)
+// as distractors, with the chain below held constant:
+//
+//   deposits  N      pivot  result
+//   ---------------------------------------------------------------------
+//     1,000   1,091   yes   "The capital of France is Paris."      composed
+//     3,000   3,065   yes   "The capital of France is Paris."      composed
+//     6,000   6,013   no    "Does your order look correct?The country of Eiffel Tower …"
+//     9,000   8,922   no    (the same fabrication)
+//
+// Controls held at EVERY scale — "Eiffel Tower country" and "France capital"
+// each answered correctly throughout. So the substrate stays intact and only
+// composition degrades, and when it degrades the store does not fall silent: it
+// GLUES an unrelated dialogue turn onto hop 1 and returns that.
+//
+// This file CANNOT reproduce that. The failure needs real corpus text: a
+// generated dialogue-shaped corpus of the same size composes cleanly at
+// N = 6,003, and lexically-varied word-salad filler composes at N = 9,394. That
+// matches the older observation that synthetic filler is far more forgiving than
+// real text. Shipping the real corpus as a fixture is not an option — size, and
+// the licence rules in DATASETS.md.
+//
+// So what runs here is the CONTRACT, at a scale where the engine currently
+// honours it. It is a regression guard: if a future change makes the store
+// fabricate at low N, this goes red. It does NOT cover the real-text ceiling.
+//
+// TO REPRODUCE THE REAL FAILURE: build the same chain, then ingest ~6,000
+// deposits produced by the Taskmaster adapter (example/train_base.ts §6e′) from
+// TM-2/TM-3/TM-4, and ask the two-hop question. See FINDINGS.md §A1/§A4.
+
+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 CHAIN = [
+  ["Eiffel Tower country", "The country of Eiffel Tower is France."],
+  ["France capital", "The capital of France is Paris."],
+  // The pivot fact: a bare entity that also opens hop 2.
+  ["France", "The capital of France is Paris."],
+];
+const TWO_HOP = "What is the capital of the country of Eiffel Tower?";
+
+// Dialogue-shaped distractors — natural sentences rather than word salad, so
+// the corpus looks like the one the trainer actually deposits.
+const NOUN =
+  "coffee latte pizza cinema hotel taxi museum concert train dentist library market garden harbour"
+    .split(" ");
+const ADJ =
+  "small large iced hot early late extra plain double single quick quiet"
+    .split(" ");
+const SUBJ = "order booking ticket table room flight delivery payment account"
+  .split(" ");
+const pick = (a, i, n) => a[(i * n) % a.length];
+const filler = (i) => [
+  `Can I book ${pick(ADJ, i, 7)} ${pick(NOUN, i, 13)} for ${i}?`,
+  `Does your ${pick(SUBJ, i, 11)} look correct? I have ${pick(ADJ, i, 3)} ${
+    pick(NOUN, i, 17)
+  } number ${i}.`,
+];
+const DEPOSITS = 1500;
+
+async function storeWithDistractors() {
+  const store = new SQliteStore({ path: ":memory:", D: 1024 });
+  const mind = new Mind({ seed: 7, store });
+  await mind.ingest(CHAIN);
+  await mind.ingest(Array.from({ length: DEPOSITS }, (_, i) => filler(i)));
+  return mind;
+}
+
+test("each hop still answers on its own — the substrate is intact", async () => {
+  // The control that made the real-text measurement conclusive: when
+  // composition fails it is NOT because a hop was lost.
+  const mind = await storeWithDistractors();
+  const hop1 = await mind.respondText("Eiffel Tower country");
+  const hop2 = await mind.respondText("France capital");
+  assert.ok(
+    hop1.includes("France"),
+    `hop 1 lost: ${JSON.stringify(hop1)}`,
+  );
+  assert.ok(
+    hop2.includes("Paris"),
+    `hop 2 lost: ${JSON.stringify(hop2)}`,
+  );
+});
+
+test("a two-hop query composes or stays silent — it never fabricates", async () => {
+  // THE CONTRACT. Three outcomes are conceivable and only two are acceptable:
+  //   compose  -> the answer contains Paris
+  //   silence  -> the empty answer, which is honest (AGENTS §2.13)
+  //   fabricate-> an assembly carrying content from an unrelated deposit
+  // The third is what a store past the real-text ceiling actually does.
+  const mind = await storeWithDistractors();
+  const answer = await mind.respondText(TWO_HOP);
+
+  if (answer === "") return; // honest silence is acceptable
+
+  assert.ok(
+    answer.includes("Paris"),
+    `neither composed nor silent — fabricated: ${JSON.stringify(answer)}`,
+  );
+
+  // Composing is not enough: the answer must not have dragged an unrelated
+  // deposit along with it. Every distractor continuation contains "look
+  // correct" or "Can I book", and no legitimate answer to this question does.
+  for (const foreign of ["look correct", "Can I book", "number "]) {
+    assert.ok(
+      !answer.includes(foreign),
+      `answer glued unrelated deposit content (${JSON.stringify(foreign)}): ${
+        JSON.stringify(answer)
+      }`,
+    );
+  }
+});
+
+test("an unanswerable two-hop query stays silent, not inventive", async () => {
+  // The same contract where NO chain exists: there is no second hop to find,
+  // so the only honest outcomes are silence or an answer about the first hop —
+  // never a distractor's sentence.
+  const mind = await storeWithDistractors();
+  const answer = await mind.respondText(
+    "What is the capital of the country of the Statue of Zamunda?",
+  );
+  for (const foreign of ["look correct", "Can I book"]) {
+    assert.ok(
+      !answer.includes(foreign),
+      `invented an answer from an unrelated deposit: ${JSON.stringify(answer)}`,
+    );
+  }
+});