@hviana/sema 0.9.2 → 0.9.3

package/dist/src/meter.d.ts

@@ -207,6 +207,12 @@ export declare class Meter {
      *  came back at the √N cap, or its predecessor budget ran out before every
      *  continuation was asked about — the distributional ladder decided. */
     askedReadsSaturated: number;
+    /** Picks named by a CO-INSTANCE of the question — another instance of its
+     *  frame whose continuation carries the relation over to this node by an
+     *  exact substitution (traverse.ts, `byCoInstance`). */
+    coInstanceNamings: number;
+    /** Proposed co-instances that tier read and witnessed. */
+    coInstanceReads: number;
     /** Cover sites dropped as FRAGMENTS whose several continuations the question
      *  names none of (mechanisms/cover.ts). */
     unaskedFragments: number;

package/dist/src/meter.js

@@ -217,6 +217,12 @@ export class Meter {
      *  came back at the √N cap, or its predecessor budget ran out before every
      *  continuation was asked about — the distributional ladder decided. */
     askedReadsSaturated = 0;
+    /** Picks named by a CO-INSTANCE of the question — another instance of its
+     *  frame whose continuation carries the relation over to this node by an
+     *  exact substitution (traverse.ts, `byCoInstance`). */
+    coInstanceNamings = 0;
+    /** Proposed co-instances that tier read and witnessed. */
+    coInstanceReads = 0;
     /** Cover sites dropped as FRAGMENTS whose several continuations the question
      *  names none of (mechanisms/cover.ts). */
     unaskedFragments = 0;

package/dist/src/mind/evidence.d.ts

@@ -17,6 +17,12 @@ export interface Witnessing {
     spans: Array<[number, number]>;
     /** Bytes of source 0 inside `spans`. */
     bytes: number;
+    /** The form's own bytes no source witnesses, as merged spans of the FORM —
+     *  empty exactly when `complete`.  ONE residue span is the shape of a
+     *  co-instance: the same frame around a different filler (`When was Peter
+     *  Jackson born?` read against `When was the director of film Jinpa
+     *  born?` leaves `Peter Jackson`). */
+    residue: Array<[number, number]>;
 }
 /** Witness `form` against `sources` (their window indexes, same order).  A
  *  window is credited to the LAST source holding it — so source 0 is credited

package/dist/src/mind/evidence.js

@@ -48,9 +48,14 @@ export function unspoken(index, spoken) {
  *  window is credited to the LAST source holding it — so source 0 is credited
  *  only with what nothing else at hand supplies. */
 export function witness(form, indexes, W) {
-    const none = { complete: false, spans: [], bytes: 0 };
-    if (form.length < W || indexes.length === 0)
-        return none;
+    if (form.length < W || indexes.length === 0) {
+        return {
+            complete: false,
+            spans: [],
+            bytes: 0,
+            residue: form.length > 0 ? [[0, form.length]] : [],
+        };
+    }
     const covered = new Uint8Array(form.length);
     const own = [];
     for (let o = 0; o + W <= form.length; o++) {
@@ -71,9 +76,16 @@ export function witness(form, indexes, W) {
         if (from === 0)
             own.push([at, at + W]);
     }
-    for (let i = 0; i < form.length; i++)
-        if (!covered[i])
-            return none;
+    const residue = [];
+    for (let i = 0; i < form.length; i++) {
+        if (covered[i])
+            continue;
+        const last = residue[residue.length - 1];
+        if (last !== undefined && last[1] === i)
+            last[1] = i + 1;
+        else
+            residue.push([i, i + 1]);
+    }
     own.sort((a, b) => a[0] - b[0]);
     const spans = [];
     for (const [s, e] of own) {
@@ -86,5 +98,5 @@ export function witness(form, indexes, W) {
     let bytes = 0;
     for (const [s, e] of spans)
         bytes += e - s;
-    return { complete: true, spans, bytes };
+    return { complete: residue.length === 0, spans, bytes, residue };
 }

package/dist/src/mind/mechanisms/cast.d.ts

@@ -37,7 +37,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

package/dist/src/mind/mechanisms/cast.js

@@ -11,11 +11,11 @@
 // gate = the frame gate below + analogyStrength, projection = insert / project /
 // juxtapose.
 import { read } from "../primitives.js";
-import { argmaxBy, corpusN, edgeAncestors, hubBound, sharedReachMemo, } from "../traverse.js";
+import { answersOtherQuestions, argmaxBy, coInstanceFiller, corpusN, edgeAncestors, hubBound, hubWindows, offsetCanon, sharedReachMemo, } from "../traverse.js";
 import { analogyStrength, follow, project, reverseContext, sharedFrameStrengthOf, } 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";
@@ -81,7 +81,7 @@ const MIN_WEAVE = 2;
  *  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
@@ -591,8 +591,16 @@ export async function counterfactualTransfer(ctx, query, pre) {
     // 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) {
             ctx.trace?.step("projectCounterfactual", [
@@ -939,6 +947,42 @@ export async function counterfactualTransfer(ctx, query, pre) {
         : [];
     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 = () => {
+        if (bestAnalog === null)
+            return false;
+        const W = ctx.space.maxGroup;
+        const hub = hubWindows(ctx, query);
+        const mine = runSpans(dominant);
+        const owns = (o) => !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
@@ -1066,8 +1110,18 @@ export async function counterfactualTransfer(ctx, query, pre) {
     // 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 &&
@@ -1187,14 +1241,21 @@ export async function counterfactualTransfer(ctx, query, pre) {
             ? `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`
-            : cmpDismisses
-                ? `a frame-tier analog under an untrusted root dismisses stored ` +
-                    `query content its alignment never accounted for — comparison ` +
-                    `refuses to ignore what the store knows`
-                : `comparison's own accounted evidence leaves a ${cmpMaxGap}-byte gap in ` +
-                    `a ${query.length}-byte query against a ${dominant.ctx.length}-byte ` +
-                    `dominant — too large to be mere framing — so it refuses rather ` +
-                    `than paper over it with an analog the query never asked about`);
+            : 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 ` +
+                            `refuses to ignore what the store knows`
+                        : `comparison's own accounted evidence leaves a ${cmpMaxGap}-byte gap in ` +
+                            `a ${query.length}-byte query against a ${dominant.ctx.length}-byte ` +
+                            `dominant — too large to be mere framing — so it refuses rather ` +
+                            `than paper over it with an analog the query never asked about`);
     }
     t?.done(results.map((r) => rItem(r.bytes, "answer")), results.length > 0
         ? `${results.length} counterfactual schema(s) fired — the grounding decider weighs them`

package/dist/src/mind/mechanisms/cover.js

@@ -9,7 +9,7 @@
 // near-zero-cost incumbent that prunes the other mechanisms through the
 // ordinary admissible-floor check, with no extension special-case anywhere.
 import { read, resolve } from "../primitives.js";
-import { guidedFirst, hubBound, namedContinuations, scaffoldSpans, } 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";
@@ -191,25 +191,9 @@ export const coverMechanism = {
                 s.end,
             ])), "a computation always wins: recognised forms overlapping a computed span are dropped");
         }
-        // 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/dist/src/mind/mechanisms/recall.js

@@ -7,7 +7,7 @@ import { cosine } from "../../vec.js";
 import { consensusFloor, dominates, identityBar, reachThreshold, significanceBar, } from "../../geometry.js";
 import { gistOf, read, resolve } from "../primitives.js";
 import { indexOf } from "../../bytes.js";
-import { allWindowsAreScaffolding, askedEvidence, corpusN, guidedFirst, hubBound, } from "../traverse.js";
+import { allWindowsAreScaffolding, answersOtherQuestions, askedEvidence, canonHeldPoints, coInstanceFiller, corpusN, guidedFirst, hubBound, namedContinuations, } from "../traverse.js";
 import { follow, project, reverseContext, voicesDisplacedFiller, } from "../match.js";
 import { CONCEPT, STEP } from "../graph-search.js";
 import { restates as lawRestates } from "../derivation.js";
@@ -55,11 +55,10 @@ export async function recallByResonance(ctx, query, pre) {
     // 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, strangerIds) => {
         // 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
@@ -86,11 +85,22 @@ export async function recallByResonance(ctx, query, pre) {
         // 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 &&
+            pre.rec.sites.some((s) => 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
@@ -113,6 +123,45 @@ export async function recallByResonance(ctx, query, pre) {
                 return ground(g, "argument binding — the query's sole edge-source constituent, continuation followed", [[arg.start, arg.end], ...named], STEP);
             }
         }
+        return null;
+    };
+    let canonArgumentPending = false;
+    let strangers = 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();
+        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
     // frame inventory is assembled from, so a query that reaches both pays for a
@@ -186,6 +235,18 @@ export async function recallByResonance(ctx, query, pre) {
     const reach = reachThreshold(ctx.space.maxGroup);
     const fracOfQuery = (cos, otherLen) => Math.min(1, Math.max(0, cos - sig) *
         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
@@ -311,7 +372,22 @@ export async function recallByResonance(ctx, query, pre) {
             // is a stronger claim that needs the corpus's own carriage evidence, and
             // that is `reference`'s job.
             const anchorBytes = read(ctx, 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")], [rItem(g, "withheld")], "refused — the anchor's continuation speaks the anchor's own " +
                     "occupant of a position this query fills differently");
             } // The anchor cleared the consensus floor, but the floor prices the

package/dist/src/mind/mechanisms/reference.js

@@ -34,6 +34,8 @@
 // population for the other is the error commonality.md names. The notion is
 // made AVAILABLE, never imposed.
 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";
@@ -172,13 +174,36 @@ export async function bindReference(ctx, query, pre) {
     // 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, cont) => {
+        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]))) {
             ctx.trace?.step("referenceLicence", [rItem(first, "instance"), rNode(ctx, frame[i].id, "against")], [rItem(cont, "attested")], "refused — the frame's answer carries content that depends on WHICH " +
                 "filler, so the corpus cannot supply it for a new one");

package/dist/src/mind/mind.d.ts

@@ -170,6 +170,7 @@ export declare class Mind implements MindContext {
     _edgeAsked: {
         bytes: Uint8Array;
         index: WindowIndex;
+        points?: readonly number[];
     } | null;
     /** Per-response memo of {@link chooseNext} picks — ensures every mechanism
      *  of a single response follows the SAME continuation for each ambiguous

package/dist/src/mind/pipeline-mechanism.js

@@ -203,7 +203,21 @@ export class Precomputed {
      *  fusion all share.  Computed on first access; a query no mechanism
      *  climbs for (e.g. one an extension decided outright) never pays for it. */
     attention() {
-        return this._attention ??= this.shared("attention", () => climbAttentionAll(this.ctx, this.query, this.k));
+        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;
+        });
     }
     _weave;
     /** Result of {@link alignGraded} for the first k ranked anchors —

package/dist/src/mind/pipeline.js

@@ -538,13 +538,14 @@ export async function think(ctx, query, mechs) {
     // 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/dist/src/mind/reasoning.js

@@ -6,7 +6,7 @@ import { rItem, rNode } from "./trace.js";
 import { bytesEqual, indexOf, latin1 } from "../bytes.js";
 import { read, resolve } from "./primitives.js";
 import { countClusters } from "./attention.js";
-import { guidedFirst, hubBound, namedContinuations, offsetCanon, } from "./traverse.js";
+import { coInstanceFiller, guidedFirst, hubBound, namedContinuations, offsetCanon, } from "./traverse.js";
 import { unspoken, windowIndex } from "./evidence.js";
 import { containsSpan, follow, haloSiblings, project } from "./match.js";
 import { joinWithBridge, pivotInto } from "./resonance.js";
@@ -211,16 +211,12 @@ export function walkLayer(ctx, query, preConsumed, pre, voiced = []) {
     // 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;
     // WHAT THE OFFERED STEP WOULD BE.  The law decides, so the accepted step is
@@ -358,20 +354,19 @@ export function walkLayer(ctx, query, preConsumed, pre, voiced = []) {
             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")], [rItem(fc, "withheld")], "the derivation owes nothing and the question names no further step — not offered");
             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,
         };
     };
@@ -681,6 +676,23 @@ primarySpans = []) {
             // 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 &&
                 // The law's positional reading: the caller knows the material it is

package/dist/src/mind/resonance.d.ts

@@ -26,8 +26,9 @@ export declare function joinWithBridge(ctx: MindContext, left: Uint8Array, right
  *  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 declare function pivotInto(ctx: MindContext, answer: Uint8Array, consumed: ReadonlySet<number>, voiced?: readonly Uint8Array[]): Promise<number | null>;
 export declare function meaningOf(ctx: MindContext, bytes: Uint8Array, anchors: ReadonlyArray<{
     name: string;

package/dist/src/mind/resonance.js

@@ -236,8 +236,9 @@ export async function joinWithBridge(ctx, left, right) {
  *  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, answer, consumed, voiced = []) {
     // The pivot's OWN shortlist capacity — not `recallQueryK`: they are different
     // quantities (a mechanical sweep's probe budget vs the bridge's candidate-read