@hviana/sema 0.9.1 → 0.9.2

package/src/mind/traverse.ts

@@ -9,13 +9,20 @@
 import { cosine, Vec } from "../vec.js";
 import type { AncestorReach, MindContext, SaturationStop } from "./types.js";
 import { gistOf, read } from "./primitives.js";
-import { canonicalWindows, leafIdPrefix, leafIdRun } from "./canonical.js";
+import {
+  canonicalWindows,
+  chainReach,
+  leafIdPrefix,
+  leafIdRun,
+} from "./canonical.js";
 // Imported at the TOP, where every other import is.  They used to sit 800 lines
 // down under a note claiming the position mattered ("before trace module is
 // loaded") — it does not: an ES module's static imports are HOISTED, so the
 // 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 { type WindowIndex, windowIndex, witness } from "./evidence.js";
 import type { RationaleItem } from "./rationale.js";
 
 // ── Session structural memo ─────────────────────────────────────────────
@@ -696,8 +703,10 @@ export function guidedNext(
   return pick;
 }
 
-/** Disambiguate among a node's learnt continuations by distributional
- *  support.  NOTE the `guide` contract: its VALUE is deliberately unused —
+/** Disambiguate among a node's learnt continuations: first by the question's
+ *  own witness of an establishing context (the exact tier, see
+ *  {@link askedContinuations}), then by distributional support.  NOTE the
+ *  `guide` contract: its VALUE is deliberately unused —
  *  only its PRESENCE gates disambiguation (a null guide means no query is in
  *  flight, so structural walkers keep plain first-edge behaviour).  The
  *  gist-cosine of short answer candidates against a query guide is dominated
@@ -721,13 +730,30 @@ export function chooseNext(
   if (nx.length === 0) return undefined;
   if (nx.length === 1 || !guide) return nx[0];
 
+  // THE EXACT TIER — the continuation the QUESTION names.  Every other
+  // disambiguation below reads popularity, and is right to refuse the gist (see
+  // the doc above); but the corpus also wrote down, for each continuation,
+  // WHICH QUESTIONS IT ANSWERS — its establishing contexts — and a question is
+  // not a gist.  When one of them is witnessed by the asker's bytes plus the
+  // node's own, that continuation is the one being asked for.  Measured on the
+  // 31.7M-node store: `Who is the father of Frederick II?` answered the
+  // citizenship fact (the most-poured of eight) while `Frederick II father` —
+  // one of the father fact's own establishing contexts — lay wholly inside the
+  // question.  Exact, so it ranks first (exact-vs-approximate.md); when nothing
+  // is witnessed the ladder below decides exactly as before.
+  const asked = ctx._edgeAsked;
+  const named = asked === null ? null : askedContinuations(ctx, id, nx, asked);
+  if (named !== null && named.length === 1) return named[0];
+
   // Cap candidates at √N — the same bound the original chooseAmong used.
   // A hub context can accumulate thousands of continuations; the best-fit
   // one is among the first √N by insertion order (edges are never deleted,
   // so the oldest are the most established).  A strongly-supported edge
   // inserted beyond the cap is invisible here — the deliberate trade
-  // against paying O(fan-out) count reads on every disambiguation.
-  const capped = nx; // already the hub-capped prefix, by the read above
+  // against paying O(fan-out) count reads on every disambiguation.  Several
+  // continuations named EQUALLY by the question are told apart by the same
+  // ladder, over them alone.
+  const capped = named ?? nx; // already the hub-capped prefix, by the read above
 
   // Distributional-evidence disambiguation, consulting BOTH read-outs of the
   // evidence the training poured:
@@ -802,6 +828,213 @@ export function chooseNext(
   return best;
 }
 
+/** The response canonicalizer's reading of `bytes` when it keeps every offset
+ *  — so a window found in the canonical bytes sits at the same place in the
+ *  asker's — else the bytes themselves.  Text canon is offset-preserving on
+ *  ASCII without interior whitespace runs; where it is not, the raw bytes are
+ *  read and a case-variant window simply does not match. */
+export function offsetCanon(ctx: MindContext, bytes: Uint8Array): Uint8Array {
+  if (ctx.canon === null) return bytes;
+  const c = ctx.canon(bytes);
+  return c.length === bytes.length ? c : bytes;
+}
+
+/** 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
+ *  restated yet.  null when none is named. */
+export function namedContinuations(
+  ctx: MindContext,
+  id: number,
+  asked: { bytes: Uint8Array; index: WindowIndex },
+): number[] | null {
+  const nx = ctx.store.nextFirst(id, hubBound(ctx));
+  return nx.length === 0 ? null : askedContinuations(ctx, id, nx, asked);
+}
+
+/** The continuations of `id` (among `nx`) that the question NAMES: one of
+ *  their establishing contexts — a predecessor other than `id` itself — is
+ *  wholly witnessed by the question plus `id`'s own bytes (evidence.ts), with
+ *  the question supplying at least one window the node does not.  Ranked by
+ *  how much of the question witnesses it; null when none is named.
+ *
+ *  THE NODE'S OWN BYTES ARE MATERIAL because a derivation stands on them.  On
+ *  the second hop of `Where was the place of death of the director of film
+ *  Beat Girl?` the node is `Edmond T. Gréville` — reached, never written — and
+ *  its fact's establishing context `Edmond T. Gréville place of death` is held
+ *  by neither the question nor the node, only by both.  Measured over 5,236
+ *  held-out 2Wiki questions: such a context is wholly witnessed by the
+ *  question alone 69 times, by the question and the first hop 2,153 times.
+ *
+ *  BOUNDED: predecessor reads share one √N budget across the candidates (see
+ *  the loop below), asked cheapest first; past it the tier abstains for the
+ *  rest, metered, and the ladder decides as before.
+ *  Each form is read at most to the material's length — a form longer than
+ *  everything at hand cannot be wholly witnessed without repeating it. */
+function askedContinuations(
+  ctx: MindContext,
+  id: number,
+  nx: readonly number[],
+  asked: { bytes: Uint8Array; index: WindowIndex },
+): number[] | null {
+  return askedEntry(ctx, id, nx, asked).named;
+}
+
+/** The question spans that NAMED `pick` among `id`'s continuations — the
+ *  evidence a projection through that pick stands on, so a mechanism can
+ *  account for what the question said about it (mechanism-market.md:
+ *  evidence travels).  Empty when the question names no continuation of `id`
+ *  or names others. */
+export function askedEvidence(
+  ctx: MindContext,
+  id: number,
+  pick: number,
+): Array<[number, number]> {
+  const asked = ctx._edgeAsked;
+  if (asked === null) return [];
+  const nx = ctx.store.nextFirst(id, hubBound(ctx));
+  const entry = askedEntry(ctx, id, nx, asked);
+  return entry.named?.includes(pick) ? entry.spans.get(pick) ?? [] : [];
+}
+
+interface AskedEntry {
+  named: number[] | null;
+  /** Per named continuation, the question spans that witnessed it. */
+  spans: Map<number, Array<[number, number]>>;
+}
+
+function askedEntry(
+  ctx: MindContext,
+  id: number,
+  nx: readonly number[],
+  asked: { bytes: Uint8Array; index: WindowIndex },
+): AskedEntry {
+  let memo = askedMemo.get(asked);
+  if (memo === undefined) askedMemo.set(asked, memo = new Map());
+  const hit = memo.get(id);
+  if (hit !== undefined && !ctx.trace) return hit;
+  const entry = askedContinuationsImpl(ctx, id, nx, asked);
+  memo.set(id, entry);
+  return entry;
+}
+
+/** One pick per node per question — every mechanism of a response asks the
+ *  same node about the same question (the guided-pick memo's own reason). */
+const askedMemo = new WeakMap<object, Map<number, AskedEntry>>();
+
+function askedContinuationsImpl(
+  ctx: MindContext,
+  id: number,
+  nx: readonly number[],
+  asked: { bytes: Uint8Array; index: WindowIndex },
+): AskedEntry {
+  const none: AskedEntry = { named: null, spans: new Map() };
+  const W = ctx.space.maxGroup;
+  // A SATURATED READ IS NOT A CANDIDATE SET.  When the continuations came back
+  // at the √N cap the read may have cut the named one off, so "none of these is
+  // named" and "this is the named one" are both unfounded — and this is exactly
+  // where witnessing would read most.  The tier abstains, metered, and the
+  // distributional ladder decides as it always has.
+  if (nx.length >= hubBound(ctx)) {
+    if (ctx.meter) ctx.meter.askedReadsSaturated++;
+    return none;
+  }
+  const cache = getStructCache(ctx);
+  const ownCap = asked.bytes.length * W;
+  const own = offsetCanon(ctx, read(ctx, id, ownCap));
+  const ownIndex = windowIndex(own, W);
+  // Naming needs the question to say at least one window the node does not:
+  // when the node already holds every window of the question (the question IS
+  // this context, or a piece of it), nothing can be named, and nothing is read.
+  let beyond = false;
+  for (const key of asked.index.keys()) {
+    if (!ownIndex.has(key)) {
+      beyond = true;
+      break;
+    }
+  }
+  if (!beyond) return none;
+  const indexes = [asked.index, ownIndex];
+  const formCap = asked.bytes.length + own.length;
+  // BOUNDED READS (bounded-reads.md): the decision reads at most √N
+  // establishing contexts — floored at the write side's own arity `chainReach(W)`
+  // so a store too small for √N to cover one fact's questions still decides.
+  // Candidates are asked CHEAPEST FIRST (fewest establishing contexts): a common
+  // 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 order = nx
+    .map((n, at) => ({ n, at, support: cachedPrevCount(ctx, n, cache) }))
+    .filter((c) => c.support >= 2) // only `id` establishes the rest
+    .sort((a, b) => a.support - b.support || a.at - b.at);
+  const scored: Array<
+    {
+      n: number;
+      at: number;
+      score: number;
+      by: number;
+      spans: Array<[number, number]>;
+    }
+  > = [];
+  for (const { n, at, support } of order) {
+    if (support > budget) {
+      if (ctx.meter) ctx.meter.askedReadsSaturated++;
+      break;
+    }
+    budget -= support;
+    if (ctx.meter) ctx.meter.askedPredecessorReads += support;
+    let score = 0;
+    let by = -1;
+    let spans: Array<[number, number]> = [];
+    for (const c of ctx.store.prevFirst(n, support)) {
+      if (c === id) continue;
+      // The form's FIRST window decides most refusals: one short prefix read
+      // before the whole form is reconstructed (a conversation-length
+      // predecessor would otherwise be read in full to fail on its opening).
+      const head = offsetCanon(ctx, read(ctx, c, W));
+      if (head.length < W) continue;
+      if (!indexes.some((ix) => ix.has(latin1(head)))) continue;
+      const form = read(ctx, c, formCap + 1);
+      if (form.length < W || form.length > formCap) continue;
+      const w = witness(offsetCanon(ctx, form), indexes, W);
+      if (!w.complete || w.bytes < W) continue;
+      if (w.bytes > score) {
+        score = w.bytes;
+        by = c;
+        spans = w.spans;
+      }
+    }
+    if (score > 0) scored.push({ n, at, score, by, spans });
+  }
+  scored.sort((a, b) => a.at - b.at);
+  let best: number[] = [];
+  let bestBytes = 0;
+  let witnessed: number | null = null;
+  for (const { n, score, by } of scored) {
+    if (score > bestBytes) {
+      best = [n];
+      bestBytes = score;
+      witnessed = by;
+    } else if (score === bestBytes) best.push(n);
+  }
+  if (best.length === 0) return none;
+  if (ctx.meter) ctx.meter.askedContinuations++;
+  if (ctx.trace && witnessed !== null) {
+    ctx.trace.step(
+      "askedContinuation",
+      [rItemShort(ctx, id, "node"), rItemShort(ctx, witnessed, "asked")],
+      best.map((n) => rItemShort(ctx, n, "named")),
+      `${nx.length} continuations — the question witnesses ` +
+        `${best.length === 1 ? "one's" : `${best.length}'`} own establishing ` +
+        `context (${bestBytes} question byte(s) beyond the node)`,
+    );
+  }
+  const evidence = new Map<number, Array<[number, number]>>();
+  for (const c of scored) if (best.includes(c.n)) evidence.set(c.n, c.spans);
+  return { named: best, spans: evidence };
+}
+
 /** 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
@@ -903,6 +1136,86 @@ export function allWindowsAreScaffolding(
   return sawOne;
 }
 
+/** Per offset of `bytes`: 1 when the W-window there is a stored form contained
+ *  in more than √N places (corpus-global scaffolding; see the floor below),
+ *  else 0.  Memoised per
+ *  byte array for the life of the store's read-only response. */
+export function hubWindows(ctx: MindContext, bytes: Uint8Array): Uint8Array {
+  const hit = hubWindowMemo.get(bytes);
+  if (hit !== undefined) return hit;
+  const W = ctx.space.maxGroup;
+  // Floored at the write side's arity: inside ONE deposit's fold a window is
+  // already contained by up to `chainReach(W)` chunks and branches, so on a
+  // store of a few facts the √N reading would call every window frame — that
+  // is fold structure, not corpus commonality.
+  const bound = Math.max(hubBound(ctx), chainReach(W));
+  const hub = new Uint8Array(Math.max(0, bytes.length - W + 1));
+  for (let o = 0; o < hub.length; o++) {
+    const ids = leafIdRun(ctx, bytes, o, o + W);
+    const id = ids === null ? null : ctx.store.findBranch(ids);
+    if (id !== null && ctx.store.containersSlice(id, bound, 1).length > 0) {
+      hub[o] = 1;
+    }
+  }
+  hubWindowMemo.set(bytes, hub);
+  return hub;
+}
+const hubWindowMemo = new WeakMap<Uint8Array, Uint8Array>();
+
+/** The query's SCAFFOLDING CORE, as spans: the bytes every W-window over which
+ *  is a hub (see {@link hubWindows}) — what is nothing but frame, where
+ *  {@link scaffoldExtents} is what a frame window reaches. */
+export function scaffoldSpans(
+  ctx: MindContext,
+  query: Uint8Array,
+): Array<[number, number]> {
+  const W = ctx.space.maxGroup;
+  const hub = hubWindows(ctx, query);
+  const n = hub.length;
+  if (n <= 0) return [];
+  const spans: Array<[number, number]> = [];
+  let start = -1;
+  for (let i = 0; i < query.length; i++) {
+    let all = true;
+    for (let o = Math.max(0, i - W + 1); o <= Math.min(i, n - 1); o++) {
+      if (!hub[o]) {
+        all = false;
+        break;
+      }
+    }
+    if (all && start < 0) start = i;
+    if (!all && start >= 0) {
+      spans.push([start, i]);
+      start = -1;
+    }
+  }
+  if (start >= 0) spans.push([start, query.length]);
+  return spans;
+}
+
+/** The EXTENTS of the query's SCAFFOLDING windows, merged: every byte some
+ *  W-window reaches that is a stored form contained in more than √N places —
+ *  corpus-global commonality (commonality.md), the same "hub" reading as
+ *  {@link allWindowsAreScaffolding} and the bridge's `explainedSpan`.  A window
+ *  the store never saw is NOT scaffolding.  The extent, not the core, is what
+ *  a coverage test needs: a span that still holds one hub window can be
+ *  "carried" by any fact that holds that window. */
+export function scaffoldExtents(
+  ctx: MindContext,
+  query: Uint8Array,
+): Array<[number, number]> {
+  const W = ctx.space.maxGroup;
+  const hub = hubWindows(ctx, query);
+  const spans: Array<[number, number]> = [];
+  for (let o = 0; o < hub.length; o++) {
+    if (!hub[o]) continue;
+    const last = spans[spans.length - 1];
+    if (last !== undefined && o <= last[1]) last[1] = o + W;
+    else spans.push([o, o + W]);
+  }
+  return spans;
+}
+
 // ── THE PREFIX SUPPLY ───────────────────────────────────────────────────────
 //
 // A RETRIEVAL capability, not a grounding one: "which trained forms does this

package/src/mind/types.ts

@@ -12,6 +12,7 @@ import type { MindConfig } from "../config.js";
 import type { Meter } from "../meter.js";
 import type { GraphSearch, Leaf, Seg, Site } from "./graph-search.js";
 import type { Rationale } from "./rationale.js";
+import type { WindowIndex } from "./evidence.js";
 import type { ContentFold, Grid } from "../geometry.js";
 
 /** One {@link MindContext._depositTrees} entry — see that field's doc.
@@ -411,6 +412,11 @@ export interface MindContext extends GraphSearchHost {
    *  ordinary respond() and for the first turn of a conversation. */
   currentTurnStart: number;
   _edgeGuide: Vec | null;
+  /** 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;
   _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

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