@hviana/sema 0.9.2 → 0.9.4

package/src/mind/traverse.ts

@@ -8,7 +8,7 @@
 
 import { cosine, Vec } from "../vec.js";
 import type { AncestorReach, MindContext, SaturationStop } from "./types.js";
-import { gistOf, read } from "./primitives.js";
+import { gistOf, read, resolve } from "./primitives.js";
 import {
   canonicalWindows,
   chainReach,
@@ -21,7 +21,7 @@ import {
 // file's line order never decides load order.  The note described an intention
 // the runtime does not honour; the imports move and the claim goes.
 import { decodeText } from "./rationale.js";
-import { latin1 } from "../bytes.js";
+import { concatBytes, indexOf, latin1 } from "../bytes.js";
 import { type WindowIndex, windowIndex, witness } from "./evidence.js";
 import type { RationaleItem } from "./rationale.js";
 
@@ -693,7 +693,9 @@ export function guidedNext(
   // policy climbMemo and recogniseMemo follow (every mechanism must emit its
   // own steps; a memo hit would swallow the repeat's `disambiguate` step).
   // Consistency does not need the memo: chooseNext is a pure function of the
-  // (read-only) store and the guide, so recomputation yields the same pick.
+  // (read-only) store, the guide and the consensus climb's points once they
+  // exist (the memo is cleared when they arrive), so recomputation yields the
+  // same pick.
   if (!ctx.trace) {
     const memo = ctx._edgeChoice.get(node);
     if (memo !== undefined) return memo === -1 ? undefined : memo;
@@ -839,6 +841,31 @@ export function offsetCanon(ctx: MindContext, bytes: Uint8Array): Uint8Array {
   return c.length === bytes.length ? c : bytes;
 }
 
+/** A FRAGMENT ANSWERS OTHER QUESTIONS.  A recognised form that sits inside
+ *  other forms (it has structural parents or containers) holds continuations
+ *  because the forms it is a piece of were asked — suffix inheritance gives
+ *  `f death` the answer of every `… place of death` question, and `director`
+ *  the answer of every `… director` one.  Choosing one of several such
+ *  continuations by popularity voices some other question's answer.  A
+ *  fragment with several continuations leads somewhere FOR THIS QUESTION only
+ *  when the question names one (the exact tier below).  A form that is
+ *  (nearly) the whole question is not a piece of it: the question says
+ *  nothing beyond it, so its continuations answer THIS question.  Read by
+ *  every mechanism that projects through a recognised site (cover's sites,
+ *  recall's argument binding). */
+export function answersOtherQuestions(
+  ctx: MindContext,
+  id: number,
+  queryLen: number,
+  siteLen: number,
+): boolean {
+  const asked = ctx._edgeAsked;
+  if (asked === null || queryLen - siteLen < ctx.space.maxGroup) return false;
+  if (!(ctx.store.hasParents(id) || ctx.store.hasContainers(id))) return false;
+  if (ctx.store.nextFirst(id, 2).length < 2) return false;
+  return namedContinuations(ctx, id, asked) === null;
+}
+
 /** The continuations of `id` that `asked` NAMES (see {@link
  *  askedContinuations}) — for a caller holding material other than the whole
  *  question: the multi-hop walk asks with what of the question no product has
@@ -914,7 +941,11 @@ function askedEntry(
   const hit = memo.get(id);
   if (hit !== undefined && !ctx.trace) return hit;
   const entry = askedContinuationsImpl(ctx, id, nx, asked);
-  memo.set(id, entry);
+  // Nothing named before the climb has run is provisional: a co-instance
+  // read from its points may still name one.
+  if (entry.named !== null || ctx._edgeAsked?.points !== undefined) {
+    memo.set(id, entry);
+  }
   return entry;
 }
 
@@ -963,7 +994,8 @@ function askedContinuationsImpl(
   // reply established by hundreds of contexts would otherwise spend the whole
   // allowance alone.  The order changes what is READ, never what wins: scores
   // are compared afterwards in the continuations' own order.
-  let budget = Math.max(hubBound(ctx), chainReach(W));
+  const allowance = Math.max(hubBound(ctx), chainReach(W));
+  let budget = allowance;
   const order = nx
     .map((n, at) => ({ n, at, support: cachedPrevCount(ctx, n, cache) }))
     .filter((c) => c.support >= 2) // only `id` establishes the rest
@@ -995,6 +1027,16 @@ function askedContinuationsImpl(
       const head = offsetCanon(ctx, read(ctx, c, W));
       if (head.length < W) continue;
       if (!indexes.some((ix) => ix.has(latin1(head)))) continue;
+      // AN ESTABLISHING CONTEXT IS A DEPOSITED ONE.  A span interned inside
+      // bigger forms inherits their edges (the fragment ` born?` leads to the
+      // fact of every `Where was … born?` question), so witnessing it names
+      // every one of them — measured on the 2Wiki fixture with one-hop
+      // questions deposited, ` born?` named nine strangers' birthplaces.  The
+      // structural predicate pivotInto already reads: a form with parents or
+      // containers was never a context on its own.
+      if (
+        cachedHasParents(ctx, c, cache) || ctx.store.hasContainers(c)
+      ) continue;
       const form = read(ctx, c, formCap + 1);
       if (form.length < W || form.length > formCap) continue;
       const w = witness(offsetCanon(ctx, form), indexes, W);
@@ -1018,7 +1060,9 @@ function askedContinuationsImpl(
       witnessed = by;
     } else if (score === bestBytes) best.push(n);
   }
-  if (best.length === 0) return none;
+  if (best.length === 0) {
+    return byCoInstance(ctx, id, nx, asked, formCap, allowance);
+  }
   if (ctx.meter) ctx.meter.askedContinuations++;
   if (ctx.trace && witnessed !== null) {
     ctx.trace.step(
@@ -1035,6 +1079,294 @@ function askedContinuationsImpl(
   return { named: best, spans: evidence };
 }
 
+/** The climb's points the question HOLDS under the response's equivalence —
+ *  stored forms whose canonical bytes occur in the question's, as sites.  The
+ *  recognition walk matches bytes and the fold's own boundaries, so a stored
+ *  `Man at Bath` inside `… of film Man At Bath work at?` is no site; the
+ *  consensus climb reaches it through the windows the two spellings share, and
+ *  containment under the canon (offset-preserving, so the span is the
+ *  question's own) decides.  Approximate proposes, exact decides.  Read off
+ *  the `chainReach(W)` most corroborated points; empty before the climb. */
+export function canonHeldPoints(
+  ctx: MindContext,
+  minLen: number,
+): Array<{ start: number; end: number; payload: number }> {
+  const asked = ctx._edgeAsked;
+  if (asked === null || asked.points === undefined || ctx.canon === null) {
+    return [];
+  }
+  const W = ctx.space.maxGroup;
+  const out: Array<{ start: number; end: number; payload: number }> = [];
+  for (const id of asked.points.slice(0, chainReach(W))) {
+    const raw = read(ctx, id, asked.bytes.length);
+    if (raw.length < minLen || raw.length >= asked.bytes.length) continue;
+    const form = ctx.canon(raw);
+    if (form.length !== raw.length) continue;
+    const at = indexOf(asked.bytes, form, 0);
+    if (at >= 0) out.push({ start: at, end: at + raw.length, payload: id });
+  }
+  return out;
+}
+
+/** A CO-INSTANCE of the question: a stored form that shares the question's
+ *  FRAME — the same opening and the same close, byte for byte under the
+ *  response's equivalence — around ONE different filler.  `Where was Peter
+ *  Jackson born?` against `Where was the director of film Beat Girl born?`
+ *  shares `Where was ` and ` born?`, and leaves `Peter Jackson` against `the
+ *  director of film Beat Girl`: another instance of the same question, never
+ *  this one.  It is the ordered limit of witnessing: a frame is not a bag of
+ *  windows (an order-free reading lets `Lyon is a city in France` pass for an
+ *  instance of `what if the capital of France were Lyon?`, which NAMES Lyon;
+ *  and a coincidental window inside a filler splits it).
+ *
+ *  The frame must reach one window, every window inside it must be held by
+ *  the material (so on the walk, a frame a product already said cannot name a
+ *  second step), and the form's filler must be a thing the corpus knows
+ *  (below) — a record that differs from the question only inside the frame
+ *  by a description (`converts sunlight into chemical energy` against
+ *  `works`) is the same question about the frame's own subject.  (Requiring
+ *  the two fillers to share no window as well was measured redundant with
+ *  this and cost two answers on the 2Wiki fixture.)  Returns the form's filler span in `raw` and the
+ *  question spans of the frame, or null.  One reading for every consumer: the
+ *  exact tier transfers the relation through it, and the readers that would
+ *  VOICE such a form's own continuation refuse it. */
+export function coInstanceFiller(
+  ctx: MindContext,
+  raw: Uint8Array,
+  indexes: ReadonlyArray<WindowIndex>,
+  question: Uint8Array,
+): { span: [number, number]; spans: Array<[number, number]> } | null {
+  const W = ctx.space.maxGroup;
+  const form = offsetCanon(ctx, raw);
+  const max = Math.min(form.length, question.length);
+  let a = 0;
+  while (a < max && form[a] === question[a]) a++;
+  let b = 0;
+  while (
+    b < max - a &&
+    form[form.length - 1 - b] === question[question.length - 1 - b]
+  ) b++;
+  const fe = form.length - b;
+  if (a + b < W || fe <= a || question.length - b <= a) return null;
+  // Scaffolding is nobody's evidence, so a frame window that is a hub need not
+  // be unsaid (` is ` in `Which country Leo Mittler is from?`, which the first
+  // hop's `… is Arshad Khan.` already said).
+  const hub = hubWindows(ctx, raw);
+  const held = (o: number): boolean => {
+    if (hub[o]) return true;
+    const key = latin1(form.subarray(o, o + W));
+    return indexes.some((ix) => ix.has(key));
+  };
+  for (let o = 0; o + W <= a; o++) if (!held(o)) return null;
+  for (let o = fe; o + W <= form.length; o++) if (!held(o)) return null;
+  // THE FILLER IS A THING THE CORPUS KNOWS: a stored context with
+  // continuations of its own, opening where the slot opens (up to one window
+  // earlier — a filler byte can sit in a window the question holds by chance:
+  // the `T` of `Taika` inside `as t` of `was the`).  `Peter Jackson` is one;
+  // `converts sunlight into chemical energy`, the slot of `Explain how
+  // photosynthesis …`, is a description of the frame's own subject, and the
+  // record answers the question.  The longest such context is the filler.
+  // One content-addressed probe per byte (the `keyEnds` reading); only a run
+  // some deposit spelled whole is looked up.
+  const ids = leafIdPrefix(ctx, raw);
+  let best: [number, number] | null = null;
+  const cache = getStructCache(ctx);
+  const reach = Math.min(ids.length, fe + W - 1);
+  for (let st = Math.max(0, a - W + 1); st <= a; st++) {
+    const run: number[] = [];
+    for (let en = st + 1; en <= reach; en++) {
+      run.push(ids[en - 1]);
+      if (en - st < W) continue;
+      // The flat branch over the whole run exists only where some deposit
+      // spelled exactly these bytes — the cheap filter; the context it names
+      // is then looked up by content.
+      if (ctx.store.findBranch(run) === null) continue;
+      if (best !== null && en - st <= best[1] - best[0]) continue;
+      const id = resolve(ctx, raw.subarray(st, en));
+      if (id !== null && cachedHasNext(ctx, id, cache)) best = [st, en];
+    }
+  }
+  if (best === null) return null;
+  const spans: Array<[number, number]> = [];
+  if (a > 0) spans.push([0, a]);
+  if (b > 0) spans.push([question.length - b, question.length]);
+  return { span: best, spans };
+}
+
+/** THE RELATION, READ OFF ANOTHER INSTANCE — the exact tier's second reading,
+ *  asked only when no establishing context of `id`'s continuations is
+ *  witnessed outright.
+ *
+ *  `When was the director of film Jinpa born?` reaches `Pema Tseden`, whose
+ *  date-of-birth fact is established by `Pema Tseden date of birth`: the
+ *  question says `born`, the corpus says `date of birth`, and no window joins
+ *  them.  What can join them is ANOTHER INSTANCE of the same question.  A
+ *  stored context the question witnesses in every byte but ONE contiguous span
+ *  (`When was Peter Jackson born?`, residue `Peter Jackson`) is the question's
+ *  own frame around a different filler — a CO-INSTANCE.  Its continuation is
+ *  established by other contexts too (`Peter Jackson date of birth`), and one
+ *  that holds the filler is the relation spelled the way the corpus spells it.
+ *  Put this node where the filler was and look the result up by content:
+ *  `Pema Tseden date of birth` exists, and its continuation is named.
+ *
+ *  Nothing here is stored as a unit — not `born` ≈ `date of birth`, not the
+ *  frame — and nothing is approximate: the co-instance is witnessed, the
+ *  substitution is bytes, the target is an exact lookup that either exists
+ *  with this node's continuation or does not.  A frame the question shares only
+ *  partly (`Where was … born?` against `When was …`) leaves two residues and
+ *  is no co-instance.
+ *
+ *  BOUNDED: the frames are a property of the question and are read once per
+ *  question (`relationFrames`); co-instances are proposed by the edge-bearing
+ *  ancestors of its windows (`edgeAncestors`, the climb's own memoised reach;
+ *  a saturated window proposes nothing), rarest first, at most `allowance` of
+ *  them, each read once.  A node pays one exact lookup per frame. */
+function byCoInstance(
+  ctx: MindContext,
+  id: number,
+  nx: readonly number[],
+  asked: { bytes: Uint8Array; index: WindowIndex },
+  formCap: number,
+  allowance: number,
+): AskedEntry {
+  const none: AskedEntry = { named: null, spans: new Map() };
+  const frames = relationFrames(ctx, asked, allowance);
+  if (frames.length === 0) return none;
+  const node = read(ctx, id, formCap);
+  const support = new Map<number, Set<number>>();
+  const spans = new Map<number, Array<[number, number]>>();
+  const via = new Map<number, { q: number; t: number }>();
+  for (const fr of frames) {
+    const t = resolve(ctx, concatBytes([fr.prefix, node, fr.suffix]));
+    if (t === null || t === id) continue;
+    for (const n of ctx.store.nextFirst(t, allowance)) {
+      if (!nx.includes(n)) continue;
+      let by = support.get(n);
+      if (by === undefined) support.set(n, by = new Set());
+      for (const q of fr.by) by.add(q);
+      if (!spans.has(n)) {
+        spans.set(n, fr.spans);
+        via.set(n, { q: fr.by[0], t });
+      }
+    }
+  }
+  let best: number[] = [];
+  let most = 0;
+  for (const n of nx) {
+    const k = support.get(n)?.size ?? 0;
+    if (k === 0) continue;
+    if (k > most) {
+      best = [n];
+      most = k;
+    } else if (k === most) best.push(n);
+  }
+  if (best.length === 0) return none;
+  if (ctx.meter) ctx.meter.coInstanceNamings++;
+  const first = via.get(best[0]);
+  if (ctx.trace && first !== undefined) {
+    ctx.trace.step(
+      "askedByCoInstance",
+      [
+        rItemShort(ctx, id, "node"),
+        rItemShort(ctx, first.q, "co-instance"),
+        rItemShort(ctx, first.t, "asked"),
+      ],
+      best.map((n) => rItemShort(ctx, n, "named")),
+      `${nx.length} continuations — no establishing context is witnessed; ` +
+        `${most} co-instance(s) of the question carry the relation to ` +
+        `${best.length === 1 ? "one" : best.length} of them`,
+    );
+  }
+  const evidence = new Map<number, Array<[number, number]>>();
+  for (const n of best) evidence.set(n, spans.get(n) ?? []);
+  return { named: best, spans: evidence };
+}
+
+/** One RELATION FRAME read off a co-instance: an establishing context of the
+ *  co-instance's continuation with the filler cut out (`Peter Jackson place
+ *  of birth` → `` + · + ` place of birth`).  Any node put in the gap spells
+ *  that node's context for the same relation. */
+interface RelationFrame {
+  /** The co-instances that spell the relation this way (first one traced). */
+  by: number[];
+  prefix: Uint8Array;
+  suffix: Uint8Array;
+  spans: Array<[number, number]>;
+}
+
+/** The relation frames the question's co-instances carry — a property of the
+ *  QUESTION, not of the node asked about, so it is read once per question
+ *  (and once per walk material) and every node only pays the exact lookups.
+ *  A question the corpus holds verbatim is its own instance and reads none. */
+function relationFrames(
+  ctx: MindContext,
+  asked: { bytes: Uint8Array; index: WindowIndex },
+  allowance: number,
+): RelationFrame[] {
+  // A co-instance is the question's frame around ONE other filler, so it is
+  // read at most to twice the question's length.
+  const formCap = 2 * asked.bytes.length;
+  const hit = frameMemo.get(asked);
+  if (hit !== undefined && !ctx.trace) return hit;
+  const whole = ctx._edgeAsked;
+  // THE PROPOSALS ARE THE CLIMB'S.  The consensus climb already scored the
+  // stored forms the question's regions reach — measured on the 2Wiki
+  // fixture with one-hop questions, the co-instances were among its points —
+  // so the tier reads co-instances from those and climbs nothing of its own.
+  // Before the climb has run there is nothing to read, and nothing is
+  // remembered: a later ask, after the climb, reads its points.
+  const points = whole?.points;
+  if (points === undefined) return [];
+  const frames: RelationFrame[] = [];
+  frameMemo.set(asked, frames);
+  if (whole !== null && resolve(ctx, whole.bytes) !== null) return frames;
+  const W = ctx.space.maxGroup;
+  const cache = getStructCache(ctx);
+  const deposited = (c: number): boolean =>
+    !cachedHasParents(ctx, c, cache) && !ctx.store.hasContainers(c);
+  const spelled = new Map<string, RelationFrame>();
+  // Most corroborated first (the climb's own ranking), at most
+  // `chainReach(W)` read — the exact tier's own floor.
+  const proposals = points.filter((c) => cachedHasNext(ctx, c, cache))
+    .slice(0, Math.min(allowance, chainReach(W)));
+  for (const q of proposals) {
+    if (!deposited(q)) continue;
+    const raw = read(ctx, q, formCap + 1);
+    if (raw.length > formCap) continue;
+    if (ctx.meter) ctx.meter.coInstanceReads++;
+    const co = coInstanceFiller(ctx, raw, [asked.index], asked.bytes);
+    if (co === null) continue;
+    const [fs, fe] = co.span;
+    const filler = raw.subarray(fs, fe);
+    for (const f of ctx.store.nextFirst(q, W)) {
+      for (const c of ctx.store.prevFirst(f, allowance)) {
+        if (c === q || !deposited(c)) continue;
+        const cb = read(ctx, c, formCap + 1);
+        const at = indexOf(cb, filler, 0);
+        if (at < 0) continue;
+        const prefix = cb.subarray(0, at);
+        const suffix = cb.subarray(at + filler.length);
+        if (prefix.length + suffix.length === 0) continue;
+        const key = latin1(prefix) + "\u0000" + latin1(suffix);
+        const known = spelled.get(key);
+        if (known === undefined) {
+          spelled.set(key, { by: [q], prefix, suffix, spans: co.spans });
+        } else if (!known.by.includes(q)) known.by.push(q);
+      }
+    }
+  }
+  // ONE INSTANCE AGREES WITH NOTHING.  A relation is read off the corpus only
+  // where two co-instances spell it the same way — the agreement `reference`
+  // demands of a frame (MIN_INSTANCES), for the same reason: a single
+  // coincidental alignment is not evidence of what the frame means.  Measured
+  // on the trained store, long dialogue turns proposed hundreds of one-off
+  // "frames", each an exact lookup for every node asked about.
+  for (const fr of spelled.values()) if (fr.by.length >= 2) frames.push(fr);
+  frames.sort((a, b) => b.by.length - a.by.length);
+  return frames;
+}
+const frameMemo = new WeakMap<object, RelationFrame[]>();
+
 /** The perceived gist of a candidate node, through the session gist cache.
  *  Re-gisting a candidate is a full river fold of its bytes — the measured
  *  recall bottleneck (a hub context offers up to √N continuations, EACH

package/src/mind/types.ts

@@ -415,8 +415,12 @@ export interface MindContext extends GraphSearchHost {
   /** The question currently being answered, as the material `chooseNext`'s
    *  exact tier witnesses a continuation's establishing contexts against —
    *  its bytes (canonical when the response's canon preserves offsets) and
-   *  their window index.  Set and cleared with `_edgeGuide`. */
-  _edgeAsked: { bytes: Uint8Array; index: WindowIndex } | null;
+   *  their window index.  Set and cleared with `_edgeGuide`.  `points` are the
+   *  anchors the response's consensus climb scored, once it has climbed —
+   *  the proposals the exact tier reads co-instances from. */
+  _edgeAsked:
+    | { bytes: Uint8Array; index: WindowIndex; points?: readonly number[] }
+    | null;
   _edgeChoice: Map<number, number>;
   _prevSeen: Set<number> | null;
   /** Session cache of node-id → perceived gist, for candidate scoring

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

@@ -31,7 +31,16 @@
 //         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.
+//         question names one;
+//   154.6 …and neither does recall's argument binding, when the fragment is the
+//         query's sole argument;
+//   154.7 a comparison needs the question to name two things: an analog
+//         evidenced only by windows the dominant holds, or by scaffolding, is
+//         not compared (it used to glue its bare question onto the answer);
+//   154.8 an argument the question holds only under the response's
+//         equivalence (`Man At Bath` for the stored `Man at Bath`, inside the
+//         question) still binds: the climb proposes it, canonical containment
+//         decides.
 
 import { test } from "node:test";
 import assert from "node:assert/strict";
@@ -279,3 +288,81 @@ test("154.5 a fragment answers other questions unless the question names one", a
   assert.ok(mind.lastCost.counters.unaskedFragments > 0);
   await mind.store.close();
 });
+
+test("154.6 recall's argument binding does not bind a fragment the question names nothing of", async () => {
+  const mind = await fixture();
+  // Subjects ending in a parenthesis (2Wiki's own titles) let the fold intern
+  // `director` as a node of its own, which inherits every director fact.
+  await mind.ingest(deposits([
+    ["Vasantha Sena (1967 film)", "director", "B. S. Ranga"],
+    ["Guilty of Treason (film)", "director", "Felix E. Feist"],
+  ]));
+  const steps = [];
+  const answer = await mind.respondText(
+    "When was the director of film Jinpa born?",
+    (st) => {
+      if (st.mechanism.includes("recallByResonance")) {
+        steps.push({
+          name: st.mechanism.at(-1),
+          outputs: st.outputs.map((o) => o.text ?? ""),
+        });
+      }
+    },
+  );
+  // `director` — the only constituent long enough to bind — leads to every
+  // director fact, and the binding voiced the most-poured stranger's.
+  assert.ok(
+    steps.some((s) => s.name === "unaskedFragments"),
+    "the binding is refused",
+  );
+  for (const s of steps.filter((s) => s.name === "recallByResonance")) {
+    for (const o of s.outputs) assert.doesNotMatch(o, /Vasantha|Guilty/);
+  }
+  assert.equal(answer, "The director of Jinpa is Pema Tseden.");
+  await mind.store.close();
+});
+
+test("154.7 a comparison needs the question to name two things", async () => {
+  const mind = await fixture();
+  const notes = [];
+  const answer = await mind.respondText(
+    "Tell me the father of Frederick II.",
+    (st) => {
+      if (st.mechanism.at(-1) === "validateAnalogy") notes.push(st.note ?? "");
+    },
+  );
+  // `Peter III of Aragon father` is reached through ` father` (the dominant
+  // `Frederick II father` holds it) and ` of ` (scaffolding): one structure
+  // named, so nothing is compared.
+  assert.ok(
+    notes.some((n) => /names one structure, not two/.test(n)),
+    "the comparison is refused",
+  );
+  assert.equal(answer, FATHER);
+  await mind.store.close();
+});
+
+test("154.8 an argument held only under the response's equivalence still binds", async () => {
+  const mind = await fixture();
+  await mind.ingest(deposits([
+    ["Man at Bath", "director", "Christophe Honoré"],
+    ["At the End of the Tunnel", "director", "Rodrigo Grande"],
+  ]));
+  // The trainer builds the canonical-form index after training (progress.ts).
+  await mind.buildCanonIndex();
+  // 2Wiki title-cases its questions; the title sits inside the question,
+  // where no fold boundary of the query lines up with the stored form.
+  assert.equal(
+    await mind.respondText(
+      "Where does the director of film Man At Bath work at?",
+    ),
+    "The director of Man at Bath is Christophe Honoré.",
+  );
+  assert.equal(
+    await mind.respondText(
+      "Where did the director of film At The End Of The Tunnel work?",
+    ),
+    "The director of At the End of the Tunnel is Rodrigo Grande.",
+  );
+  await mind.store.close();
+});