@hviana/sema 0.9.2 → 0.9.4

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

@@ -19,9 +19,9 @@ import type {
 } from "../graph-search.js";
 import { read, resolve } from "../primitives.js";
 import {
+  answersOtherQuestions,
   guidedFirst,
   hubBound,
-  namedContinuations,
   scaffoldSpans,
 } from "../traverse.js";
 import { conceptHop } from "../match.js";
@@ -259,27 +259,11 @@ export const coverMechanism: PipelineMechanism = {
       );
     }
 
-    // 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.  Choosing one of
-    // several such continuations by popularity voices some other question's
-    // answer, and the cover used to account the fragment's bytes as explained by
-    // it.  A fragment with several continuations leads somewhere FOR THIS
-    // QUESTION only when the question names one (traverse.ts, the exact tier).
-    // 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.
-    const asked = ctx._edgeAsked;
-    const W0 = ctx.space.maxGroup;
-    const leading = asked === null
-      ? sites
-      : sites.filter((s) =>
-        query.length - (s.end - s.start) < W0 ||
-        !(ctx.store.hasParents(s.payload) ||
-          ctx.store.hasContainers(s.payload)) ||
-        ctx.store.nextFirst(s.payload, 2).length < 2 ||
-        namedContinuations(ctx, s.payload, asked) !== null
-      );
+    // 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;

package/src/mind/mechanisms/recall.ts

@@ -17,10 +17,14 @@ import { gistOf, read, resolve } from "../primitives.js";
 import { indexOf } from "../../bytes.js";
 import {
   allWindowsAreScaffolding,
+  answersOtherQuestions,
   askedEvidence,
+  canonHeldPoints,
+  coInstanceFiller,
   corpusN,
   guidedFirst,
   hubBound,
+  namedContinuations,
 } from "../traverse.js";
 import {
   follow,
@@ -108,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
@@ -140,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
@@ -176,6 +192,53 @@ export async function recallByResonance(
         );
       }
     }
+    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
@@ -272,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
@@ -403,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

@@ -335,7 +335,9 @@ export class Mind implements MindContext {
    *  reverse-recall disambiguation via `chooseAmong`. */
   _edgeGuide: Vec | null = null;
   /** See {@link MindContext._edgeAsked}. */
-  _edgeAsked: { bytes: Uint8Array; index: WindowIndex } | null = null;
+  _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. */

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

@@ -773,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

package/src/mind/reasoning.ts

@@ -9,6 +9,7 @@ import type { Attention, MindContext } from "./types.js";
 import { read, resolve } from "./primitives.js";
 import { countClusters } from "./attention.js";
 import {
+  coInstanceFiller,
   guidedFirst,
   hubBound,
   namedContinuations,
@@ -255,16 +256,12 @@ export function walkLayer(
   // 30 s); and raising it from 12 to 200 changed neither the answer nor
   // `pivotSteps` on the chain fixtures.
   const qv = pre.guide; // the response-wide guide IS the query's gist
-  // WHOSE EXTENSION IS THIS?  `voiced` is what the mechanism WITHHELD (the
-  // pipeline sends the used anchors' CONTINUATIONS, not their bytes), so a
-  // non-empty `voiced` means exactly what that note says: the grounding came
-  // from a mechanism that carries its own short `used` set (cast/join) and
-  // therefore OWNS the shape of its answer.  The further terms inside such a
-  // seat are legitimately followable (test/29 C3's `Mona Lisa` lives inside the
-  // voiced seat and leads on to a fact about neither analog), which the law
-  // expresses as the identity species of progress — `moves` — declared by the
-  // reporter and never inferred from the mechanism's name.
-  const producerOwnsShape = voiced.length > 0;
+  // NO PRODUCER OWNS THE NEXT STEP.  A grounding that declared what it voiced
+  // (cast/join) used to MOVE through any further term inside its answer,
+  // unasked — `Who is the director of The Jerk?` grounded by CAST walked on to
+  // `The country of citizenship of Carl Reiner is American.`  What it voiced
+  // still bounds what may be pivoted through (`voiced`, pivotInto); whether a
+  // step is taken is the naming rule below, the same for every mechanism.
   let hop = 0;
   let t: ReturnType<Rationale["enter"]> | undefined;
   // WHAT THE OFFERED STEP WOULD BE.  The law decides, so the accepted step is
@@ -439,7 +436,7 @@ export function walkLayer(
       const hop = guidedFirst(ctx, pivot);
       named = names !== null && hop !== undefined && names.includes(hop);
     }
-    if (!named && !producerOwnsShape && closed(d)) {
+    if (!named && closed(d)) {
       ctx.trace?.step(
         "pivotUnasked",
         [rItem(cur, "answer"), rNode(ctx, pivot, "pivot")],
@@ -449,15 +446,14 @@ export function walkLayer(
       return null;
     }
     pending = { kind: "pivot", cur, pivot, fc };
-    // Offered with the identity species when the grounding declared what it
-    // speaks for, or when the question names the step; otherwise the law
-    // requires this step to carry question material the grounding left
+    // Offered with the identity species when the question names the step;
+    // otherwise the law requires this step to carry question material the grounding left
     // unaccounted, which is the drift the extension tests pin — refused by the
     // law's own measure, not by a private window test.
     return {
       product: fc,
       contains: true,
-      reaches: producerOwnsShape || named,
+      reaches: named,
       cost: STEP,
     };
   };
@@ -833,6 +829,28 @@ export function fusionLayer(
       // again would only restate it.  Deliberately NOT a magnitude measure:
       // it fires on exact content-addressed recurrence, not on how strongly
       // the root resonates.
+      // ANOTHER INSTANCE IS NOT ANOTHER TOPIC.  A root the question witnesses
+      // in every byte but one contiguous span is the question's own frame
+      // around a different filler (evidence.ts, `coInstanceFiller`): the climb
+      // committed `Where was Peter Jackson born?` as a second point of
+      // `Where was the director of film Beat Girl born?` on the frame windows
+      // alone, and fusing it voiced Peter Jackson's birthplace beside the
+      // answer.  Such a root says what the question's relation IS (traverse.ts,
+      // `byCoInstance`), never what it asks about.
+      const asked = ctx._edgeAsked;
+      if (asked !== null) {
+        const form = read(ctx, root.anchor, 2 * query.length);
+        const co = coInstanceFiller(ctx, form, [asked.index], asked.bytes);
+        if (co !== null) {
+          ctx.trace?.step(
+            "coInstanceRoot",
+            [rNode(ctx, root.anchor, "point", root.vote)],
+            [rItem(form.subarray(co.span[0], co.span[1]), "filler")],
+            "the question witnesses this point in every byte but one filler of its own — another instance of the question's frame, not a further topic",
+          );
+          continue;
+        }
+      }
       const cont = await follow(ctx, root.anchor, qv);
       if (
         cont !== null && cont.length > 0 &&

package/src/mind/resonance.ts

@@ -307,8 +307,9 @@ export async function joinWithBridge(
  *  Shakespeare" (id 676) and the pivot hopped through "speare" (id 606, not
  *  in `consumed`) straight into that analog's own biography, which is exactly
  *  what the comparison had refused to voice.  The rule is CONTAINMENT, not
- *  overlap, so C3's genuine further hop — "Mona Lisa", a term inside the seat
- *  sentence but part of NEITHER analog — still fires. */
+ *  overlap, so C3's further term — "Mona Lisa", inside the seat sentence but
+ *  part of NEITHER analog — stays a candidate; whether the walk steps through
+ *  it is the naming rule's decision (reasoning.ts, evidence.md). */
 export async function pivotInto(
   ctx: MindContext,
   answer: Uint8Array,