@hviana/sema 0.9.1 → 0.9.3

package/dist/src/meter.d.ts

@@ -197,6 +197,25 @@ export declare class Meter {
     /** Times the reasoner pivoted on a span its answer contains and stepped
      *  across that fact. */
     pivotSteps: number;
+    /** `chooseNext` picks the question NAMED — a continuation one of whose own
+     *  establishing contexts the question (plus the node) wholly witnesses
+     *  (traverse.ts, the exact tier). */
+    askedContinuations: number;
+    /** Predecessor rows that exact tier read, against its shared √N budget. */
+    askedPredecessorReads: number;
+    /** Times the tier abstained on a read it could not trust: the continuations
+     *  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;
     /** Canon probes REFUSED because the canon budget ran out — the one thing the
      *  budget does that nothing could see.  The budget itself is derived
      *  (`bytes.length · chainReach(W)²`, recognition.ts), and the cheap exact route

package/dist/src/meter.js

@@ -207,6 +207,25 @@ export class Meter {
     /** Times the reasoner pivoted on a span its answer contains and stepped
      *  across that fact. */
     pivotSteps = 0;
+    /** `chooseNext` picks the question NAMED — a continuation one of whose own
+     *  establishing contexts the question (plus the node) wholly witnesses
+     *  (traverse.ts, the exact tier). */
+    askedContinuations = 0;
+    /** Predecessor rows that exact tier read, against its shared √N budget. */
+    askedPredecessorReads = 0;
+    /** Times the tier abstained on a read it could not trust: the continuations
+     *  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;
     /** Canon probes REFUSED because the canon budget ran out — the one thing the
      *  budget does that nothing could see.  The budget itself is derived
      *  (`bytes.length · chainReach(W)²`, recognition.ts), and the cheap exact route

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

@@ -0,0 +1,30 @@
+/** Where each W-window of one source first occurs.  Built once per source and
+ *  reused across every form asked against it. */
+export type WindowIndex = Map<string, number>;
+export declare function windowIndex(bytes: Uint8Array, W: number): WindowIndex;
+/** The windows of `index` (over `bytes`) that `spoken` does not hold — what
+ *  of the question no product of the derivation has restated yet.  The keys
+ *  keep their positions in `bytes`, so a witnessing span still names the
+ *  asker's bytes. */
+export declare function unspoken(index: WindowIndex, spoken: ReadonlyArray<WindowIndex>): WindowIndex;
+/** How a form is witnessed by a list of sources. */
+export interface Witnessing {
+    /** Every byte of the form lies in a window some source holds. */
+    complete: boolean;
+    /** The windows SOURCE 0 alone supplied — windows no later source holds — as
+     *  merged spans of source 0.  With the question as source 0, this is what the
+     *  asker said about the form that the derivation did not already have. */
+    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
+ *  only with what nothing else at hand supplies. */
+export declare function witness(form: Uint8Array, indexes: ReadonlyArray<WindowIndex>, W: number): Witnessing;

package/dist/src/mind/evidence.js

@@ -0,0 +1,102 @@
+// evidence.ts — what of a stored form the material at hand WITNESSES.
+//
+// A stored form is WITNESSED by some material when every one of its bytes lies
+// inside a W-window that occurs literally in that material — in any order, at
+// any place.  It is the order-free reading of correspondence (`alignRuns` is
+// its run-producing sibling, `junctionContainersFrom(…, unordered)` its
+// container-finding one): a learnt form is evidenced by bytes that hold all of
+// its windows, whichever way the asker happened to arrange them.
+//
+// The material is a LIST of sources because what a derivation has at hand is
+// more than the question: the node it stands on is material too.  A trained
+// question `Edmond T. Gréville place of death` is in neither the asker's
+// `Where was the place of death of the director of film Beat Girl?` nor the
+// fact `The director of Beat Girl is Edmond T. Gréville.` the first hop reached
+// — and both together hold every byte of it.  The witness records which source
+// held each window, so a consumer can tell the question's share (what the asker
+// SAID about the form) from what the derivation itself brought.
+//
+// Exact, deterministic and linear: one window index per source, one probe per
+// window of the form.  Below one window a byte agreement is chance (the floor
+// identityBar, attestedQ and the site test all draw), so a form shorter than W
+// is never witnessed.
+//
+// Layering: bytes only — importable from traverse.ts and everything above it.
+import { latin1 } from "../bytes.js";
+export function windowIndex(bytes, W) {
+    const index = new Map();
+    for (let o = 0; o + W <= bytes.length; o++) {
+        const key = latin1(bytes.subarray(o, o + W));
+        if (!index.has(key))
+            index.set(key, o);
+    }
+    return index;
+}
+/** The windows of `index` (over `bytes`) that `spoken` does not hold — what
+ *  of the question no product of the derivation has restated yet.  The keys
+ *  keep their positions in `bytes`, so a witnessing span still names the
+ *  asker's bytes. */
+export function unspoken(index, spoken) {
+    const out = new Map();
+    for (const [key, at] of index) {
+        if (!spoken.some((s) => s.has(key)))
+            out.set(key, at);
+    }
+    return out;
+}
+/** Witness `form` against `sources` (their window indexes, same order).  A
+ *  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) {
+    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++) {
+        const key = latin1(form.subarray(o, o + W));
+        let at = -1;
+        let from = -1;
+        for (let s = indexes.length - 1; s >= 0; s--) {
+            const p = indexes[s].get(key);
+            if (p !== undefined) {
+                at = p;
+                from = s;
+                break;
+            }
+        }
+        if (from < 0)
+            continue;
+        covered.fill(1, o, o + W);
+        if (from === 0)
+            own.push([at, at + W]);
+    }
+    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) {
+        const last = spans[spans.length - 1];
+        if (last !== undefined && s <= last[1])
+            last[1] = Math.max(last[1], e);
+        else
+            spans.push([s, e]);
+    }
+    let bytes = 0;
+    for (const [s, e] of spans)
+        bytes += e - s;
+    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 } 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";
@@ -179,7 +179,7 @@ export const coverMechanism = {
         const { rec, computed } = pre;
         // 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));
         if (computed.length > 0 && sites.length < rec.sites.length) {
@@ -191,6 +191,19 @@ export const coverMechanism = {
                 s.end,
             ])), "a computation always wins: recognised forms overlapping a computed span are dropped");
         }
+        // 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
@@ -278,8 +291,17 @@ export const coverMechanism = {
         // 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 = 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 [{
                 bytes: composed,

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, corpusN, 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
@@ -102,9 +112,56 @@ export async function recallByResonance(ctx, query, pre) {
             // conversation reads as if it were the next thing to say.
             if (g !== null && g.length > 0 &&
                 !lawRestates(query, g, 0, { proper: true })) {
-                return ground(g, "argument binding — the query's sole edge-source constituent, continuation followed", [[arg.start, arg.end]], STEP);
+                // 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], ...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
@@ -178,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
@@ -303,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

@@ -47,6 +47,7 @@ export interface Conversation {
     readonly id: number;
 }
 import type { AttentionRead, MindContext, Recognition } from "./types.js";
+import type { WindowIndex } from "./evidence.js";
 export type { AnchorRejectionReason, ClimbConsensusData, ConsensusAnchorTrace, ConsensusReachTrace, ConsensusRegionTrace, CrossRegionTier, JunctionVoteTrace, RegionOutcome, } from "./attention.js";
 export type { AncestorReach, SaturationReason, SaturationStop, } from "./types.js";
 import { type CostReport, Meter } from "../meter.js";
@@ -165,6 +166,12 @@ export declare class Mind implements MindContext {
      *  first-edge behaviour) and the reverse projection uses it for
      *  reverse-recall disambiguation via `chooseAmong`. */
     _edgeGuide: Vec | null;
+    /** See {@link MindContext._edgeAsked}. */
+    _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
      *  context node. */

package/dist/src/mind/mind.js

@@ -104,6 +104,8 @@ export class Mind {
      *  first-edge behaviour) and the reverse projection uses it for
      *  reverse-recall disambiguation via `chooseAmong`. */
     _edgeGuide = null;
+    /** See {@link MindContext._edgeAsked}. */
+    _edgeAsked = null;
     /** Per-response memo of {@link chooseNext} picks — ensures every mechanism
      *  of a single response follows the SAME continuation for each ambiguous
      *  context node. */
@@ -334,6 +336,7 @@ export class Mind {
         this.canon = null;
         this.canonMemo = null;
         this._edgeGuide = null;
+        this._edgeAsked = null;
         this._edgeChoice.clear();
     }
     /** Shared response core — the one path from bytes to voiced answer.