@hviana/sema 0.9.1 → 0.9.3

package/src/mind/traverse.ts

@@ -8,14 +8,21 @@
 
 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 { gistOf, read, resolve } from "./primitives.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 { concatBytes, indexOf, latin1 } from "../bytes.js";
+import { type WindowIndex, windowIndex, witness } from "./evidence.js";
 import type { RationaleItem } from "./rationale.js";
 
 // ── Session structural memo ─────────────────────────────────────────────
@@ -686,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;
@@ -696,8 +705,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 +732,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 +830,543 @@ 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;
+}
+
+/** 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
+ *  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);
+  // 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;
+}
+
+/** 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.
+  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
+    .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;
+      // 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);
+      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 byCoInstance(ctx, id, nx, asked, formCap, allowance);
+  }
+  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 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
@@ -903,6 +1468,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