@hviana/sema 0.9.1 → 0.9.3

package/src/mind/mechanisms/cast.ts

@@ -15,10 +15,14 @@ import type { MindContext } from "../types.js";
 import type { Vec } from "../../vec.js";
 import { read } from "../primitives.js";
 import {
+  answersOtherQuestions,
   argmaxBy,
+  coInstanceFiller,
   corpusN,
   edgeAncestors,
   hubBound,
+  hubWindows,
+  offsetCanon,
   sharedReachMemo,
 } from "../traverse.js";
 import {
@@ -31,7 +35,7 @@ import {
 } from "../match.js";
 import { joinWithBridge } from "../resonance.js";
 import { CONCEPT, STEP } from "../graph-search.js";
-import { indexOf } from "../../bytes.js";
+import { indexOf, latin1 } from "../../bytes.js";
 import { consensusFloor, dominates } from "../../geometry.js";
 import { restates, unexplainedSpans } from "../derivation.js";
 import { rItem, rNode } from "../trace.js";
@@ -116,7 +120,7 @@ export interface CastResult {
  *  painted by Leonardo da Vinci.") must be seated by that establishing
  *  sentence, NOT by its own biography fact — voicing the bio leaks exactly
  *  what a comparison must keep out, and loses the embedded "Mona Lisa"
- *  term C3 relies on for a further hop.
+ *  term C3's further-hop candidate lives in.
  *
  *  The distinguishing signal is content-addressed, not a count: a genuine
  *  establishing predecessor's bytes CONTAIN id's own bytes — it names or
@@ -693,9 +697,22 @@ export async function counterfactualTransfer(
   // its own fact — so the same bar applies.  The displaced structure is only
   // recognised as the slot being overridden and is never voiced, so it is
   // deliberately not gated here.
+  // …and the substitute must lead somewhere FOR THIS QUESTION: a fragment
+  // whose continuations the question names none of answers other questions
+  // (traverse.ts, `answersOtherQuestions`).  `ong)?`, the tail of every
+  // `… (… Song)?` question, was "named" by `What is the place of birth of the
+  // performer of song Heaven (Namie Amuro Song)?`, and redirection voiced
+  // its most-poured stranger's birthplace.
+  const stranger = last !== undefined &&
+    answersOtherQuestions(
+      ctx,
+      last.point.anchor,
+      query.length,
+      last.run.qe - last.run.qs,
+    );
   if (
     last !== undefined && last.point !== dominant && displaced &&
-    voiceable(last.point)
+    voiceable(last.point) && !stranger
   ) {
     const g = await project(ctx, last.point.anchor, qv);
     if (g !== null) {
@@ -1084,6 +1101,41 @@ export async function counterfactualTransfer(
     : [];
   const cmpGaps = unexplainedSpans(query.length, cmpAccounted);
   const cmpMaxGap = cmpGaps.reduce((n, [s, e]) => Math.max(n, e - s), 0);
+  // TWO THINGS NAMED.  A comparison voices two structures, so the question
+  // must evidence the second one with material of its own: a W-window of the
+  // question that the analog holds — on its aligned runs, or anywhere in its
+  // own form under the response's equivalence (the witness reading,
+  // evidence.md) — and that is neither inside the dominant's runs nor corpus
+  // scaffolding (`hubWindows`, the reading of "what the question owes").
+  // `father of Frederick II?` reached `Peter III of Aragon father` through
+  // ` father`, which the dominant `Frederick II father` already holds, and
+  // ` of `, which every fact holds — one structure named, and the comparison
+  // glued the analog's bare question onto the answer (`…is Peter III of
+  // Aragon.Peter III of Aragon father`).  `How is ice like steel?` names
+  // `Ice is cold` with `ice `, a window no byte-exact run aligns (the case
+  // differs) and the dominant `Steel is hard` lacks.
+  const analogOwnsEvidence = (): boolean => {
+    if (bestAnalog === null) return false;
+    const W = ctx.space.maxGroup;
+    const hub = hubWindows(ctx, query);
+    const mine = runSpans(dominant);
+    const owns = (o: number): boolean =>
+      !hub[o] && !mine.some(([ms, me]) => o >= ms && o + W <= me);
+    for (const [s, e] of runSpans(bestAnalog.point ?? bestAnalog.src)) {
+      for (let o = s; o + W <= e; o++) if (owns(o)) return true;
+    }
+    const asked = ctx._edgeAsked;
+    if (asked === null) return false;
+    const form = offsetCanon(
+      ctx,
+      read(ctx, bestAnalog.anchor, asked.bytes.length * W),
+    );
+    for (let o = 0; o + W <= form.length; o++) {
+      const at = asked.index.get(latin1(form.subarray(o, o + W)));
+      if (at !== undefined && owns(at)) return true;
+    }
+    return false;
+  };
   // An analog that is not itself a directly ALIGNED point (point !== null —
   // its own runs are query bytes, the query NAMED it) was only reached
   // through a continuation hop or the structural-hub fallback.  Voicing
@@ -1208,9 +1260,24 @@ export async function counterfactualTransfer(
   // supply were never the ones that test is about.
   const cmpDismisses = !bestHalo &&
     dismissedKnownContent(ctx, query, cmpAccounted);
+  // …and the dominant must be something the question is ABOUT.  A co-instance
+  // of the question (traverse.ts, `coInstanceFiller`) is its frame around
+  // another filler, and its seat is that filler's own answer: `Where was the
+  // performer of song God (Lennon Song) born?` compared `Where was Shakira
+  // (Shakira Song) born?` with `John Lennon` and voiced Shakira's birthplace.
+  const asked = ctx._edgeAsked;
+  const dominantOtherInstance = asked !== null &&
+    coInstanceFiller(
+        ctx,
+        read(ctx, dominant.anchor, 2 * query.length + 1),
+        [asked.index],
+        asked.bytes,
+      ) !== null;
   if (
     bestAnalog !== null &&
     (bestHalo || analogNamed || rootTrusted) &&
+    analogOwnsEvidence() &&
+    !dominantOtherInstance &&
     !cmpDismisses &&
     queryScale(dominant.ctx.length) &&
     roots.length <= 1 &&
@@ -1346,6 +1413,13 @@ export async function counterfactualTransfer(
         ? `the best analog carries no halo-tier company evidence, was never ` +
           `named by the query, and no committed root's consensus vote ` +
           `clears the floor, so comparison refuses to voice it`
+        : dominantOtherInstance
+        ? `the dominant is another instance of the question's frame — its ` +
+          `seat is another filler's answer, not what the question asks about`
+        : !analogOwnsEvidence()
+        ? `the question evidences the analog only with windows the dominant ` +
+          `already holds or the corpus' scaffolding — it names one structure, ` +
+          `not two, so there is nothing to compare`
         : cmpDismisses
         ? `a frame-tier analog under an untrusted root dismisses stored ` +
           `query content its alignment never accounted for — comparison ` +

package/src/mind/mechanisms/cover.ts

@@ -18,7 +18,12 @@ import type {
   Site,
 } from "../graph-search.js";
 import { read, resolve } from "../primitives.js";
-import { guidedFirst, hubBound } from "../traverse.js";
+import {
+  answersOtherQuestions,
+  guidedFirst,
+  hubBound,
+  scaffoldSpans,
+} from "../traverse.js";
 import { conceptHop } from "../match.js";
 import { bridge } from "../resonance.js";
 import { liftAnswer, liftedScaffolding, segRestatesQuery } from "../types.js";
@@ -229,7 +234,7 @@ export const coverMechanism: PipelineMechanism = {
 
     // Masking: computed spans are authoritative.  Remove recognised sites
     // that overlap any computed span before building the cover search.
-    const sites = computed.length === 0
+    let sites = computed.length === 0
       ? rec.sites
       : rec.sites.filter((s) =>
         !computed.some((u) => s.start < u.j && u.i < s.end)
@@ -254,6 +259,29 @@ export const coverMechanism: PipelineMechanism = {
       );
     }
 
+    // A FRAGMENT ANSWERS OTHER QUESTIONS (traverse.ts) — and the cover used to
+    // account the fragment's bytes as explained by the stranger's answer.
+    const leading = sites.filter((s) =>
+      !answersOtherQuestions(ctx, s.payload, query.length, s.end - s.start)
+    );
+    if (leading.length < sites.length) {
+      if (ctx.meter) {
+        ctx.meter.unaskedFragments += sites.length - leading.length;
+      }
+      ctx.trace?.step(
+        "unaskedFragments",
+        sites.filter((s) => !leading.includes(s)).map((s) =>
+          rItem(query.subarray(s.start, s.end), "fragment", s.payload, [
+            s.start,
+            s.end,
+          ])
+        ),
+        [],
+        "a piece of other forms whose continuations the question names none of — it answers other questions",
+      );
+      sites = leading;
+    }
+
     if (sites.length === 0 && computed.length === 0) return [];
 
     const connectors = ctx.meter
@@ -382,8 +410,19 @@ export const coverMechanism: PipelineMechanism = {
     // restated span contributes nothing to the composed answer, so it must
     // not be priced as if it did (PASS-carried bytes are priced already;
     // the diagnostic label reflects the same distinction).
+    //
+    // …and a span made of nothing but corpus-global scaffolding names nothing:
+    // every window of it is a piece of more than √N stored forms, so the form
+    // recognised there — the song `What`, in the trained store — is one of
+    // thousands it could be.  Voicing that form's fact explains no byte the
+    // asker owes: measured, `What country is Jerry Bock a citizen of?` was won
+    // by `The performer of What is Melinda Marx.` glued onto the right fact.
+    const scaffold = scaffoldSpans(ctx, query);
     const accounted: Array<[number, number]> = segs
-      .filter((s) => s.rec && !segRestatesQuery(s, query, query.length, W))
+      .filter((s) =>
+        s.rec && !segRestatesQuery(s, query, query.length, W) &&
+        !scaffold.some(([a, b]) => a <= s.i && s.j <= b)
+      )
       .map((s) => [s.i, s.j]);
 
     return [{

package/src/mind/mechanisms/recall.ts

@@ -15,7 +15,17 @@ import {
 import type { MindContext } from "../types.js";
 import { gistOf, read, resolve } from "../primitives.js";
 import { indexOf } from "../../bytes.js";
-import { allWindowsAreScaffolding, corpusN, hubBound } from "../traverse.js";
+import {
+  allWindowsAreScaffolding,
+  answersOtherQuestions,
+  askedEvidence,
+  canonHeldPoints,
+  coInstanceFiller,
+  corpusN,
+  guidedFirst,
+  hubBound,
+  namedContinuations,
+} from "../traverse.js";
 import {
   follow,
   project,
@@ -102,13 +112,13 @@ export async function recallByResonance(
   // constituent bar is the same two-quanta (2W) reading confluence binds
   // under, nested recognitions collapse to their MAXIMAL span, and two
   // distinct maximal arguments mean the query asks about neither alone.
-  if (qId === null) {
-    const W2 = 2 * ctx.space.maxGroup;
-    const args = pre.rec.sites.filter((s) =>
-      s.end - s.start >= W2 &&
-      s.end - s.start < query.length &&
-      ctx.store.hasNext(s.payload)
-    );
+  // The argument binding, given its candidate arguments (`args`) and the
+  // recognised fragments that answer other questions (`strangerIds`).
+  const W2 = 2 * ctx.space.maxGroup;
+  const bindArgument = async (
+    args: Array<{ start: number; end: number; payload: number }>,
+    strangerIds: ReadonlySet<number>,
+  ) => {
     // Maximal spans by one sorted sweep (starts ascending, ties longest
     // first): every earlier span starts at or before s, so s is contained
     // exactly when the running max end already covers it.  O(m log m) — a
@@ -134,13 +144,25 @@ export async function recallByResonance(
     // binding to the argument's continuation would answer past content
     // the query itself already carries forward.  Derived from the same W2
     // bar the argument itself is held to, never a separate tuned number.
+    // A fragment that answers other questions is not such a piece.
     const hasSubstantialOutside = maximal.length === 1 &&
       pre.rec.sites.some((s) =>
-        s.end - s.start >= W2 &&
+        s.end - s.start >= W2 && !strangerIds.has(s.payload) &&
         (s.end <= maximal[0].start || s.start >= maximal[0].end)
       );
     if (maximal.length === 1 && !hasSubstantialOutside) {
       const arg = maximal[0];
+      // An argument whose several continuations the question names none of
+      // outright would be followed by popularity.  Another instance of the
+      // question may name one (traverse.ts, `byCoInstance`), and its
+      // proposals are the consensus climb's points — so the climb is asked
+      // for first, exactly where the choice would otherwise be blind.
+      const asked = ctx._edgeAsked;
+      if (
+        asked !== null && asked.points === undefined &&
+        ctx.store.nextFirst(arg.payload, 2).length >= 2 &&
+        namedContinuations(ctx, arg.payload, asked) === null
+      ) await pre.attention();
       const g = await follow(ctx, arg.payload, queryGist);
       // The same "no restated fragment" guard tier 2 applies below (§ "the
       // anchor cleared the consensus floor..."): a followed continuation
@@ -154,14 +176,69 @@ export async function recallByResonance(
         g !== null && g.length > 0 &&
         !lawRestates(query, g, 0, { proper: true })
       ) {
+        // EVIDENCE TRAVELS: when the question NAMED the continuation followed
+        // (traverse.ts, the exact tier — `Who is the father of Frederick II?`
+        // witnesses the father fact's own question `Frederick II father`), the
+        // spans that named it are explained too, not only the argument.
+        const hop = guidedFirst(ctx, arg.payload);
+        const named = hop === undefined
+          ? []
+          : askedEvidence(ctx, arg.payload, hop);
         return ground(
           g,
           "argument binding — the query's sole edge-source constituent, continuation followed",
-          [[arg.start, arg.end]],
+          [[arg.start, arg.end], ...named],
           STEP,
         );
       }
     }
+    return null;
+  };
+  let canonArgumentPending = false;
+  let strangers: ReadonlySet<number> = new Set();
+  if (qId === null) {
+    const recognised = pre.rec.sites.filter((s) =>
+      s.end - s.start >= W2 &&
+      s.end - s.start < query.length &&
+      ctx.store.hasNext(s.payload)
+    );
+    // An argument must lead somewhere FOR THIS QUESTION: a fragment whose
+    // continuations the question names none of answers other questions
+    // (traverse.ts) — `director`, inside `When was the director of film Jinpa
+    // born?`, bound the most-poured of fifty-five directors.  Such a fragment
+    // is no argument, and no independent piece of the query either.
+    const strangerIds = new Set<number>();
+    for (const s of recognised) {
+      if (
+        answersOtherQuestions(ctx, s.payload, query.length, s.end - s.start)
+      ) strangerIds.add(s.payload);
+    }
+    const args = recognised.filter((s) => !strangerIds.has(s.payload));
+    if (args.length === 0 && strangerIds.size > 0) {
+      if (ctx.meter) ctx.meter.unaskedFragments += strangerIds.size;
+      ctx.trace?.step(
+        "unaskedFragments",
+        recognised.filter((s) => strangerIds.has(s.payload)).map((s) =>
+          rItem(query.subarray(s.start, s.end), "fragment", s.payload, [
+            s.start,
+            s.end,
+          ])
+        ),
+        [],
+        "the only arguments are pieces of other forms whose continuations the question names none of — they answer other questions",
+      );
+    }
+    const bound = await bindArgument(args, strangerIds);
+    if (bound !== null) return bound;
+    // NO ARGUMENT BY BYTES IS NOT NO ARGUMENT.  Recognition matches bytes, so
+    // `Man At Bath` (2Wiki title-cases its questions) is no site of the stored
+    // `Man at Bath`.  When nothing recognised can bind, the points the
+    // consensus climb reaches that the question holds under the response's
+    // equivalence are arguments too (traverse.ts, `canonHeldPoints`) — read
+    // after the clean-resonance tier, which answers a near-identical question
+    // without any climb.
+    canonArgumentPending = ctx.canon !== null && args.length === 0;
+    strangers = strangerIds;
   }
 
   // The response's ONE top-k read (Precomputed.resonance) — the same list the
@@ -258,6 +335,20 @@ export async function recallByResonance(
         Math.sqrt(otherLen / Math.max(1, query.length)),
     );
 
+  // The argument the question holds only under the response's equivalence
+  // (above).  Not gated on the whole-query resonance: a question whose only
+  // argument is a case variant (`… film Man At Bath work at?`) resonates
+  // below the significance bar as a whole.
+  if (canonArgumentPending) {
+    await pre.attention();
+    const held = canonHeldPoints(ctx, W2).filter((s) =>
+      ctx.store.hasNext(s.payload) &&
+      !answersOtherQuestions(ctx, s.payload, query.length, s.end - s.start)
+    );
+    const bound = await bindArgument(held, strangers);
+    if (bound !== null) return bound;
+  }
+
   // 2. Scaffolding-dominated.
   if (top.score >= sig) {
     // The committed points of attention ARE the shared climb's roots (same
@@ -389,7 +480,28 @@ export async function recallByResonance(
         forest[0].anchor,
         query.length * ctx.space.maxGroup + 1,
       );
-      if (g !== null && voicesDisplacedFiller(ctx, query, anchorBytes, g)) {
+      // …and the same refusal read from the anchor's side: an anchor the query
+      // witnesses in every byte but one filler of its own is ANOTHER INSTANCE
+      // of the question (traverse.ts, `coInstanceFiller`).  The query-side
+      // reading above needs the shared frame to dominate the QUERY, which a
+      // long slot defeats: `Where was the performer of song God (John Lennon
+      // Song) born?` elected `Where was Nicki Minaj (Nicki Minaj Song) born?`
+      // and answered Nicki Minaj's birthplace.
+      const asked = ctx._edgeAsked;
+      const co = asked === null
+        ? null
+        : coInstanceFiller(ctx, anchorBytes, [asked.index], asked.bytes);
+      if (co !== null) {
+        ctx.trace?.step(
+          "coInstanceAnchor",
+          [rItem(query, "query"), rNode(ctx, forest[0].anchor, "anchor")],
+          [rItem(anchorBytes.subarray(co.span[0], co.span[1]), "filler")],
+          "refused — the anchor is another instance of the question's frame, " +
+            "and its continuation speaks of its own filler",
+        );
+      } else if (
+        g !== null && voicesDisplacedFiller(ctx, query, anchorBytes, g)
+      ) {
         ctx.trace?.step(
           "displacedFiller",
           [rItem(query, "query"), rNode(ctx, forest[0].anchor, "anchor")],

package/src/mind/mechanisms/reference.ts

@@ -37,6 +37,8 @@
 import type { MindContext } from "../types.js";
 import type { FrameInstance } from "../match.js";
 import { carriesFillers, distinct, follow, substituteAll } from "../match.js";
+import { resolve } from "../primitives.js";
+import { hubBound } from "../traverse.js";
 import { dominates } from "../../geometry.js";
 import { bytesEqual } from "../../bytes.js";
 import { restates } from "../derivation.js";
@@ -186,7 +188,6 @@ export async function bindReference(
   if (!distinct(referents)) {
     return fail("two slots name the same bytes — the binding is ambiguous");
   }
-
   // ── THE LICENCE ────────────────────────────────────────────────────────
   // Every instance must agree, against the first, that its continuation is its
   // own fillers carried through one fixed form.  Unanimity, exactly as the
@@ -199,11 +200,33 @@ export async function bindReference(
   // discard them.  Each goes through the shared projection, so an ambiguous
   // instance is disambiguated exactly as it would be anywhere else.
   const leadsNowhere = "an instance of the frame leads nowhere";
+  // A FACT FILED UNDER ITS FILLER IS NOT A CARRIAGE.  When an instance's
+  // filler is itself a stored context leading to that instance's answer, the
+  // answer is something the corpus knows ABOUT that filler (`The place of
+  // birth of Peter Jackson is Wellington.` is a continuation of `Peter
+  // Jackson`), not a form any occupant takes — and two such facts can agree
+  // by chance (two people born in Wellington).  `Run gcc hello.c` is filed
+  // under the question alone.
+  const filedUnderFiller = (inst: FrameInstance, cont: Uint8Array): boolean => {
+    const c = resolve(ctx, cont);
+    if (c === null) return false;
+    return inst.slots.some((s) => {
+      const f = resolve(ctx, s.filler);
+      return f !== null &&
+        ctx.store.nextFirst(f, hubBound(ctx)).includes(c);
+    });
+  };
   const first = await follow(ctx, frame[0].id, pre.guide);
   if (first === null || first.length === 0) return fail(leadsNowhere);
+  if (filedUnderFiller(frame[0], first)) {
+    return fail("the frame's answer is a fact filed under its filler");
+  }
   for (let i = 1; i < frame.length; i++) {
     const cont = await follow(ctx, frame[i].id, pre.guide);
     if (cont === null || cont.length === 0) return fail(leadsNowhere);
+    if (filedUnderFiller(frame[i], cont)) {
+      return fail("the frame's answer is a fact filed under its filler");
+    }
     if (
       !carriesFillers(first, fillersOf(frame[0]), cont, fillersOf(frame[i]))
     ) {

package/src/mind/mind.ts

@@ -141,6 +141,7 @@ import {
   leadsSomewhere,
 } from "./traverse.js";
 import { invalidateJunctionCache } from "./junction.js";
+import type { WindowIndex } from "./evidence.js";
 import { follow } from "./match.js";
 import { recognise, segment } from "./recognition.js";
 import { meaningOf } from "./resonance.js";
@@ -333,6 +334,10 @@ export class Mind implements MindContext {
    *  first-edge behaviour) and the reverse projection uses it for
    *  reverse-recall disambiguation via `chooseAmong`. */
   _edgeGuide: Vec | null = null;
+  /** See {@link MindContext._edgeAsked}. */
+  _edgeAsked:
+    | { bytes: Uint8Array; index: WindowIndex; points?: readonly number[] }
+    | null = null;
   /** Per-response memo of {@link chooseNext} picks — ensures every mechanism
    *  of a single response follows the SAME continuation for each ambiguous
    *  context node. */
@@ -647,6 +652,7 @@ export class Mind implements MindContext {
     this.canon = null;
     this.canonMemo = null;
     this._edgeGuide = null;
+    this._edgeAsked = null;
     this._edgeChoice.clear();
   }
 

package/src/mind/pipeline-mechanism.ts

@@ -225,7 +225,21 @@ export class Precomputed {
     return this._attention ??= this.shared(
       "attention",
       () => climbAttentionAll(this.ctx, this.query, this.k),
-    );
+    ).then((read) => {
+      // The climb's scored anchors are what the exact tier reads co-instances
+      // of the question from (traverse.ts, `relationFrames`): the
+      // approximate climb proposes, witnessing decides.
+      // A pick made before the points existed read less evidence than one
+      // made after, so the response's pick memo starts over (traverse.ts,
+      // guidedNext: a pick is a function of the store, the guide AND the
+      // points — traced and untraced responses must agree).
+      const asked = this.ctx._edgeAsked;
+      if (asked !== null && asked.points === undefined) {
+        asked.points = read.ranked.map((a) => a.anchor);
+        this.ctx._edgeChoice.clear();
+      }
+      return read;
+    });
   }
 
   private _weave?: Promise<WeaveInfo>;

package/src/mind/pipeline.ts

@@ -27,7 +27,9 @@ import {
 } from "./derivation.js";
 import { rItem } from "./trace.js";
 import { unexplainedLabel } from "./rationale.js";
-import { hubBound } from "./traverse.js";
+import { hubBound, offsetCanon, scaffoldExtents } from "./traverse.js";
+import { windowIndex, witness } from "./evidence.js";
+import { indexOf } from "../bytes.js";
 import {
   type MechanismResult,
   type PipelineMechanism,
@@ -189,6 +191,13 @@ export async function think(
   if (query.length === 0) return null;
 
   ctx._edgeGuide = gistOf(ctx, query);
+  {
+    const asked = offsetCanon(ctx, query);
+    ctx._edgeAsked = {
+      bytes: asked,
+      index: windowIndex(asked, ctx.space.maxGroup),
+    };
+  }
   ctx._edgeChoice.clear();
 
   const t = ctx.trace?.enter("think", [rItem(query, "query")]);
@@ -690,7 +699,21 @@ export async function think(
   const explained = priced.filter(([a, b]) =>
     windowOf([a, b], answer, query, ctx.space.maxGroup) !== null
   );
-  const paid = remainderOf(query.length, explained, ctx.space.maxGroup);
+  // THE DERIVATION IS BORN OWING ITS DISCRIMINATIVE MATERIAL.  The bytes a
+  // corpus-global scaffolding window reaches (traverse.ts, `scaffoldExtents`)
+  // are nobody's debt — otherwise a later step could claim to pay them by
+  // restating ` is `, which every fact holds, and the law (which measures
+  // carrying by any window of what is owed) would admit it; the substitution
+  // bridge reads gaps the same way (`explainedSpan`).  PRICING is untouched:
+  // the ladder still charges every unexplained byte, because for a question
+  // made of nothing but scaffolding (`How are you today?`) covering those bytes
+  // IS the evidence.
+  const scaffold = scaffoldExtents(ctx, query);
+  const paid = remainderOf(
+    query.length,
+    [...explained, ...scaffold],
+    ctx.space.maxGroup,
+  );
   // WHAT THE CONSTRUCTION WITHHOLDS, at or above one quantum: the difference between
   // the remainder paid in full and the remainder paid by carrying.  Both readings
   // are the law's, so the floor is applied once and in one place — and the
@@ -711,8 +734,31 @@ export async function think(
   const uncovered = state.remainder;
 
   // ── Post-grounding, gated by the declaration and the remainder ────────
+  // WHAT THE GROUNDING SPOKE FOR, when it did not declare it: the forms inside
+  // the answer that the ASKER already holds.  An answer is the asker's material
+  // plus what the corpus added — the fact's own value — and only the former was
+  // spoken for: re-entering it walks back to the question.  The latter is what a
+  // chain continues THROUGH.  Consuming every form recognised in the answer
+  // consumed that too, so a chain could start only where recognition happened
+  // to miss the next entity — measured on 133 held-out 2Wiki compositional
+  // questions, 3 pivot steps in all once interior recognition named the entity
+  // inside every fact.  Witnessed exactly, as `chooseNext`'s exact tier reads the
+  // question (evidence.ts); a form below one window cannot be witnessed, and is
+  // consumed as before.
+  const asked = ctx._edgeAsked;
   const preConsumed = declaredUsed ??
-    new Set(recognise(ctx, answer).sites.map((s) => s.payload));
+    new Set(
+      recognise(ctx, answer).sites
+        .filter((s) =>
+          asked === null || s.end - s.start < ctx.space.maxGroup ||
+          witness(
+            offsetCanon(ctx, answer.subarray(s.start, s.end)),
+            [asked.index],
+            ctx.space.maxGroup,
+          ).complete
+        )
+        .map((s) => s.payload),
+    );
   // A grounding that DECLARED itself complete is not extended: the answer is
   // already a trained form's own continuation, reached through an identity
   // claim about the query, so a multi-hop pivot could only chain past the
@@ -727,13 +773,14 @@ export async function think(
   // Reading the used anchors' OWN bytes here says something stronger and
   // wrong: that nothing INSIDE what was voiced may be pivoted through.  A
   // comparison's seat sentence legitimately contains further terms with
-  // their own unrelated facts, and C3 pins exactly that — `Mona Lisa`, inside
-  // the voiced seat `The Mona Lisa was painted by Leonardo da Vinci.`, leads
-  // on to `Mona Lisa hangs in the Louvre`, which is about neither analog.
+  // their own unrelated facts — `Mona Lisa`, inside the voiced seat `The Mona
+  // Lisa was painted by Leonardo da Vinci.`, leads on to `Mona Lisa hangs in
+  // the Louvre`, which is about neither analog (test/29 C3: a candidate the
+  // walk takes only when the question names it).
   // The withheld content is the used anchors' CONTINUATIONS, so that is what
   // the containment rule reads: `speare` is contained in `Shakespeare wrote
   // 39 plays` and stays refused, while `Mona Lisa` appears in no withheld
-  // continuation and the genuine further hop fires.
+  // continuation and stays a candidate.
   //
   // Only a mechanism carrying its own `used` set (cast/join) gets this: there
   // `preConsumed` is a deliberate, short list of the anchors the answer
@@ -741,8 +788,17 @@ export async function think(
   // `preConsumed` is derived by re-recognising the answer — "everything in
   // it", not "what it voiced" — and a containment rule over that would
   // suppress every pivot the answer legitimately contains.
+  //
+  // …and a continuation the ANSWER ITSELF holds was voiced, not withheld.  A
+  // substitution that answers with its anchor's own continuation (`The director
+  // of Beat Girl is Edmond T. Gréville.`) declared that anchor used, so reading
+  // its continuations as withheld refused every pivot inside the answer — the
+  // chain could never step past the entity the first hop introduced.
   const voiced = declaredUsed === undefined ? [] : [...declaredUsed].flatMap(
-    (id) => ctx.store.nextFirst(id, hubBound(ctx)).map((n) => read(ctx, n)),
+    (id) =>
+      ctx.store.nextFirst(id, hubBound(ctx))
+        .map((n) => read(ctx, n))
+        .filter((v) => indexOf(answer, v, 0) < 0),
   );
   // WHAT THIS BRANCH READ, published where it was read.  Post-grounding decides
   // by the DECLARATION (`decided.used`, which becomes `voiced`), by what the