@hviana/sema 0.5.2 → 0.5.3

package/dist/src/mind/{prefix-completion.js → mechanisms/prefix-completion.js}

@@ -1,5 +1,20 @@
-// prefix-completion.ts — Grounding a query that IS the opening of a trained
-// form.
+// mechanisms/prefix-completion.ts — Grounding a query that IS the opening of a
+// trained form (Grounding V).
+//
+// A MECHANISM, NOT A TIER.  This used to run inside recall's refusal path, in
+// a fixed if-chain that first-match-wins — the shape CAST was refactored away
+// from, where placement rather than the cost ladder decided.  Its claim is
+// maximal (every query byte literally matched, from offset zero, against a
+// trained form) at one STEP, so as a market candidate it competes honestly and
+// the decider weighs it like everything else.  It is registered LAST: recall's
+// exact self-match makes an IDENTITY claim about the query while this makes a
+// CONTAINMENT one, and on an exact grade tie the identity claim is the
+// stronger evidence — the same ordering §2.3's ladders use.
+//
+// Its SUPPLY moved too, and further: `formsOpenedBy` (traverse.ts) answers a
+// question about the STORE — "which trained forms does this byte run open?" —
+// so it is retrieval machinery any mechanism may ask, not this one's private
+// helper.
 //
 // THE SHAPE.  `The capital of France is` grounds nothing, while
 // `The capital of France is Paris.` is trained and reads back byte-exact.  The
@@ -74,95 +89,10 @@
 // Uniqueness is judged on the continuation BYTES, not on the candidate id: the
 // same continuation reached through two trained forms is one answer, not an
 // ambiguity.
-import { bytesEqual } from "../bytes.js";
-import { rItem } from "./trace.js";
-import { canonicalWindows, leafIdPrefix } from "./canonical.js";
-import { hubBound } from "./traverse.js";
-/** Trained forms the query may OPEN, proposed from the write side's own
- *  leaf-id window index — the supply of last resort for {@link
- *  prefixCompletion}.
- *
- *  WHY A SECOND SUPPLY EXISTS.  The ranked list this mechanism normally reads
- *  is a resonance list, and resonance cannot rank a proper prefix: measured on
- *  the trained store, cos(prefix, form) falls from 0.9629 at a one-byte
- *  truncation to 0.6206 at three bytes, against a reachThreshold of 0.8750.
- *  Three bytes of truncation put the answer out of reach on GEOMETRY, not on a
- *  bug, so no k and no re-ranking recovers it.
- *
- *  WHY THIS ROUTE WORKS WHERE THE FOLD DOES NOT.  A query's own fold is
- *  useless here: content addressing is not phrase-position-invariant, so a
- *  standalone prefix folds to a DIFFERENT node than the same bytes sitting
- *  inside a longer deposit, and neither the prefix's own node nor its
- *  ancestors lead to the deposit (measured: the 22-byte prefix of the
- *  photosynthesis form resolves, is shared by 6 contexts, and does not have
- *  the form among its ancestors).  Leaf ids ARE position-invariant — they are
- *  content-addressed on single bytes — and `indexSubSpans` already interns a
- *  flat branch over every canonical WINDOW of a deposit's leaf-id stream, with
- *  containment edges to the chunks that window spans.  A query that is a
- *  prefix therefore shares those window nodes exactly, and reaches the deposit
- *  by climbing containment then parents.  Nothing is added to the write side;
- *  this reads an index training already built.
- *
- *  BOUNDED (§2.8), AND WITH NO NEW THRESHOLD.  The window whose containment is
- *  SMALLEST carries the most evidence, and one saturated at `hubBound` carries
- *  none — that is the same √N reading of "hub" the rest of the mind uses, not
- *  a tuned knob.  The upward walk spends a budget of `hubBound` nodes and
- *  fans out by W, so a hub query enumerates nothing and the caller stays
- *  silent rather than guessing (§2.13).  Measured on the trained store: the
- *  photosynthesis form at a one-byte truncation picks a window with 52
- *  containers, visits 446 nodes, and yields exactly ONE candidate that
- *  survives the caller's byte compare — the form itself.
- *
- *  These are PROPOSALS only.  Every candidate still faces the byte-exact
- *  prefix compare and all three guards below, so a wrong proposal costs one
- *  bounded read and can never be voiced (§2.3). */
-export function prefixCandidates(ctx, query) {
-    const store = ctx.store;
-    const W = ctx.space.maxGroup;
-    const run = leafIdPrefix(ctx, query);
-    // The widest canonical window is the most discriminative one the write side
-    // ever interned; a query too short to spell one carries no window evidence.
-    const len = canonicalWindows(W)[1];
-    if (run.length < len)
-        return [];
-    const bound = hubBound(ctx);
-    let best = null;
-    let bestN = 0;
-    for (let off = 0; off + len <= run.length; off++) {
-        const wid = store.findBranch(run.slice(off, off + len));
-        if (wid === null)
-            continue;
-        const n = store.containersSlice(wid, 0, bound).length;
-        // Empty says the window spans no chunk; saturated says it is a hub, whose
-        // containment discriminates nothing.  Neither is evidence.
-        if (n === 0 || n >= bound)
-            continue;
-        if (best === null || n < bestN) {
-            best = wid;
-            bestN = n;
-        }
-    }
-    if (best === null)
-        return [];
-    let frontier = store.containersSlice(best, 0, bound);
-    const seen = new Set(frontier);
-    let budget = bound;
-    while (frontier.length > 0 && budget > 0) {
-        const next = [];
-        for (const f of frontier) {
-            if (budget-- <= 0)
-                break;
-            for (const p of store.parentsFirst(f, W)) {
-                if (seen.has(p))
-                    continue;
-                seen.add(p);
-                next.push(p);
-            }
-        }
-        frontier = next;
-    }
-    return [...seen];
-}
+import { bytesEqual } from "../../bytes.js";
+import { rItem } from "../trace.js";
+import { formsOpenedBy } from "../traverse.js";
+import { STEP } from "../graph-search.js";
 /** The sole trained form the query opens — or null when no candidate opens with
  *  it, when the continuation is sub-quantum, when a candidate's continuation
  *  cannot be read through, or when the candidates disagree.
@@ -268,3 +198,46 @@ export function prefixCompletion(ctx, query, ranked) {
     }
     return done(found[0], "one trained form opens with this query, and continues perceivably", data);
 }
+// ── Pipeline mechanism ──────────────────────────────────────────────────────
+export const prefixMechanism = {
+    name: "prefix",
+    provenance: "prefix",
+    async floor(ctx, query, _pre, worthRunning) {
+        // One projection: the form is voiced whole, nothing is substituted.
+        // INVESTMENT DISCIPLINE — the supplies below are the response's wide
+        // candidate list and a bounded √N walk, so neither is touched until the
+        // bound can still beat the incumbent.
+        if (!worthRunning(STEP))
+            return STEP;
+        // A query with no room for a perceivable continuation inside the phrase
+        // cap cannot clear guard 2, so it is not worth a single read.
+        const cap = query.length * ctx.space.maxGroup;
+        if (query.length === 0 || cap < query.length + ctx.space.maxGroup) {
+            return null;
+        }
+        return STEP;
+    },
+    async run(ctx, query, pre) {
+        // The response's shared wide list first; only when it supplies nothing does
+        // the write side's window index propose.  That ordering is the whole cost
+        // story: a query the ranked list can already explain pays not one extra
+        // read, and the bounded walk is spent only where the alternative is an
+        // empty answer.  A second SUPPLY, not a second mechanism — the same three
+        // guards decide either way.
+        const completed = prefixCompletion(ctx, query, await pre.wideResonance()) ??
+            prefixCompletion(ctx, query, formsOpenedBy(ctx, query));
+        if (completed === null)
+            return [];
+        return [{
+                bytes: completed.form,
+                // Every query byte is literally matched against the form, so there is
+                // nothing to be humble about in the accounting — the same reading the
+                // IDENTITY bridge takes.
+                accounted: [[0, query.length]],
+                moves: STEP,
+                unexplained: "",
+                // NOT complete: the query is a proper PREFIX, so the form may carry more
+                // past the remainder this voiced.
+            }];
+    },
+};

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

@@ -1,10 +1,10 @@
-// mechanisms/recall.ts — Recall by resonance (Grounding IV).
+// mechanisms/recall.ts — Recall by resonance (Grounding VI).
 //
 // The recall mechanism resonates the whole query's gist against the content
 // index and grounds the nearest learned form.  Four tiers, orderly degrading
 // from exact self-match to honest echo.
 import { cosine } from "../../vec.js";
-import { conceptThreshold, consensusFloor, dominates, identityBar, reachThreshold, significanceBar, } from "../../geometry.js";
+import { consensusFloor, dominates, identityBar, reachThreshold, significanceBar, } from "../../geometry.js";
 import { gistOf, read, resolve } from "../primitives.js";
 import { bytesEqual, indexOf } from "../../bytes.js";
 import { allWindowsAreScaffolding, corpusN, hubBound } from "../traverse.js";
@@ -13,8 +13,6 @@ import { CONCEPT, STEP } from "../graph-search.js";
 import { unexplainedLabel } from "../rationale.js";
 import { rItem, rNode } from "../trace.js";
 import { substitutionBridge } from "../bridge.js";
-import { frameFillerSubstitution } from "../frame-filler.js";
-import { prefixCandidates, prefixCompletion } from "../prefix-completion.js";
 /** Recall the answer by resonating the whole query against the content index. */
 export async function recallByResonance(ctx, query, pre) {
     const t = ctx.trace?.enter("recallByResonance", [
@@ -110,7 +108,10 @@ export async function recallByResonance(ctx, query, pre) {
             }
         }
     }
-    const whole = await ctx.store.resonate(queryGist, k);
+    // 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
+    // single ANN query rather than two identical ones.
+    const whole = await pre.resonance();
     if (whole.length === 0) {
         return ground(null, "empty store — nothing to resonate with", [], 0);
     }
@@ -293,42 +294,10 @@ export async function recallByResonance(ctx, query, pre) {
         }
     }
     // 3b. Corroborated-substitution bridge — refusal-path only (bridge.ts).
-    // MEMOISED ACROSS EVERY REMAINING TIER, and that is load-bearing rather than
-    // tidy: the bridge, prefix completion and the frame filler all read the SAME
-    // candidate list, so the exhaustive branch runs at most once per response.
-    // Without the memo each tier re-issues it — measured at 490 ms median against
-    // 13 ms non-exhaustive (36x).
-    const wideIdsOnce = async () => {
-        // When the top resonance hit is below the concept threshold, the query
-        // gist has no concept-level match to any stored form — an exhaustive √N
-        // ANN would only score more vectors below the bar (profiled at 38K–40K
-        // annVectorReads per refusing query on a 325K-context store).  The
-        // bridge's structural channels (junction walks, anchor climbs) are the
-        // correct proposal source for a query whose gist has no clean match;
-        // the ANN cannot propose what the gist cannot rank.
-        // The condition above is the SCORE of the top hit, not the size of the
-        // corpus.  It used to be spelled `corpusN(ctx) <= (k · W)³`, which asks
-        // a different question and answers it wrongly at exactly the scale the
-        // note was written from: on the trained store N = 325,608 with k = 24
-        // and W = 4 puts the cube at 884,736, so that store took the exhaustive
-        // branch — the very branch measured here as 38K–40K annVectorReads.
-        // Measured cost of the mismatch: substitutionBridge 8,544ms of a
-        // 19,548ms think (44%), against 1,248ms and 14,218ms without it, with
-        // every answer in the battery byte-identical and the suite unchanged
-        // at 445/445.  Corpus size was never the discriminator; whether the
-        // gist ranks ANYTHING at concept level is.
-        //
-        // Reading it as the note states also removes a duplicated (k · W)³ —
-        // the same cube gates crossRegionVotes' walk budget, where it likewise
-        // never engages at real scale (see attention.ts).
-        if (whole.length > 0 && whole[0].score >= conceptThreshold(ctx.store.D)) {
-            const exhaustive = await ctx.store.resonate(queryGist, hubBound(ctx), true);
-            return exhaustive.map((h) => h.id);
-        }
-        return whole.map((h) => h.id);
-    };
-    let wide = null;
-    const wideIds = () => (wide ??= wideIdsOnce());
+    // The WIDE candidate list every past-the-top-k mechanism reads lives on
+    // Precomputed (see wideResonance): shared across the whole response, so the
+    // exhaustive branch runs at most once whoever first-touches it.
+    const wideIds = () => pre.wideResonance();
     // Every gist-based tier has failed; before refusing, align the query
     // byte-for-byte against the trained contexts its own stored windows
     // anchor, accepting mismatches only as corpus-attested, concept-bar
@@ -439,73 +408,6 @@ export async function recallByResonance(ctx, query, pre) {
                 bridged.subs.length === 0);
             }
         }
-        // 3b′. PREFIX COMPLETION — refusal-path only (prefix-completion.ts).
-        // Inside the bridge's block, and deliberately: it consumes `wideIds`, the
-        // list the bridge has already fetched, so it costs a bounded byte compare
-        // per candidate and not one resonance.  The claim it makes is the
-        // strongest in the ladder — every query byte is a LITERAL match from
-        // offset zero of a trained form — so it needs no projection and no reach
-        // gate.  It runs after the bridge only because the bridge answers the
-        // richer relation when it can; a prefix match that the bridge also
-        // explains is the same trained form either way.
-        {
-            // The resonance list first; only when it supplies nothing does the
-            // write side's leaf-id window index propose (prefixCandidates).  That
-            // ordering is the whole cost story: a query the ranked list can already
-            // explain pays not one extra read, and the fallback's bounded walk is
-            // spent only where the alternative is an empty answer.  It is a second
-            // SUPPLY, not a second mechanism — the same three guards decide.
-            const completed = prefixCompletion(ctx, query, await wideIds()) ??
-                prefixCompletion(ctx, query, prefixCandidates(ctx, query));
-            if (completed !== null) {
-                return ground(completed.form, "prefix completion — the query IS the opening of exactly one " +
-                    "trained form, which this grounds whole", 
-                // Every query byte is literally matched against the form.  The
-                // completion is the form's own continuation, not a substitution, so
-                // there is nothing to be humble about in the accounting — the same
-                // reading the IDENTITY bridge above takes.
-                whole_, STEP, false, 
-                // NOT complete: the query is a proper PREFIX, so the form may carry
-                // more past the remainder this tier voiced.
-                false);
-            }
-        }
-    }
-    // 3c. FRAME-FILLER SUBSTITUTION — refusal-path only (frame-filler.ts).
-    // The bridge has failed, and for the shape this tier answers it MUST fail:
-    // a definite description standing where a proper noun stands is not a
-    // similarity relation the bridge can price (raw balance refuses
-    // `dominates(6, 37)`, and correctly — that is the France/Spain trap).  This
-    // tier makes a different claim: not that the two spans resemble each other,
-    // but that the store ALREADY HOLDS this query with the filler in the
-    // description's place, byte-exactly.  A key the store does not hold is
-    // discarded, so the answer is always a trained continuation.
-    {
-        // THE COHORT NEEDS EVIDENCE, AND THE REFUSAL PATH HAS ALREADY BOUGHT IT.
-        // This tier reads constituency from what a cohort of exemplars does NOT
-        // share, so its resolution is bounded by how many instances of the frame it
-        // can see.  The top-k resonance hits are too few — on the two-hop probe the
-        // exemplars holding the query's discriminative content number TWO, and two
-        // structures agree on so little that a whole clause reads as content.  The
-        // exhaustive list the bridge fetched is the same evidence at ~570 wide, and
-        // it is already paid for (memoised above, so this costs no ANN call).
-        const filled = frameFillerSubstitution(ctx, query, await wideIds());
-        if (filled !== null) {
-            const g = await project(ctx, filled.id, queryGist);
-            // The same restated-fragment and manufactured-answer guards every tier
-            // above applies: a projection contained in the FILLER is the
-            // substitution restated as if it were knowledge, not knowledge.
-            if (g !== null && g.length > 0 && !restates(g) &&
-                indexOf(filled.filler, g, 0) < 0 &&
-                !(g.length < query.length && indexOf(query, g, 0) >= 0)) {
-                return ground(g, "frame-filler substitution — a trained form IS this query with a " +
-                    "corroborated filler in the described span's place", 
-                // The frame is literally matched against the resolved form and the
-                // described span is explained by the substitution — the same
-                // matched-plus-substituted accounting the bridge reports.
-                [[0, query.length]], CONCEPT + STEP);
-            }
-        }
     }
     // The refusal/echo decision.  The echo returns a stored form's bytes AS
     // the answer — a near-identity claim about the query — and identity-grade

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

@@ -0,0 +1,6 @@
+import type { MindContext } from "../types.js";
+import type { MechanismResult, PipelineMechanism, Precomputed } from "../pipeline-mechanism.js";
+/** Voice the query's referents through their frame's own attested carriage, or
+ *  null when the corpus does not attest one. */
+export declare function bindReference(ctx: MindContext, query: Uint8Array, pre: Precomputed): Promise<MechanismResult | null>;
+export declare const referenceMechanism: PipelineMechanism;

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

@@ -0,0 +1,296 @@
+// mechanisms/reference.ts — Reference: voice a slot with the context's own
+// bytes (Grounding IV).
+//
+// This file is a CONFIGURATION of the shared frame reading in match.ts, not a
+// pipeline of its own.  The three parts it configures live where §2.5 puts
+// them and are reachable by any mechanism:
+//
+//   matcher     Precomputed.frames() — the frame INVENTORY: which ranked
+//               candidates read as instances of the query's own frame, and
+//               where each leaves the query VARIABLE.  Shared, election-free.
+//   projection  follow() — each instance's own learnt continuation.
+//   gate        carriesFillers() — the carriage licence.
+//
+// What this file adds is the reading and the price: elect one frame from the
+// inventory, demand the licence of it, splice, and state the cost.
+//
+// WHAT KIND OF ACT THIS IS.  bridge.ts refuses this shape and is right to:
+// `attestedQ` demands the query-side span be corpus-attested, because a
+// SUBSTITUTION asserts equivalence ("these two spans mean the same"), and
+// nothing can corroborate an equivalence claim about bytes the corpus has
+// never seen.  A REFERENCE asserts no equivalence.  It asserts POSITION —
+// "this is the thing you named, where the corpus keeps one" — and the bytes
+// come from the asker, so voicing them cannot fabricate corpus knowledge.
+// What CAN be fabricated is the relation claimed about them, which is exactly
+// what the licence withholds.
+//
+// The same reasoning is why the bridge is NOT rewired to consult the frame
+// inventory, though it is now free to: the bridge grounds through its
+// candidate's continuation UNSUBSTITUTED, so admitting a slot-gap there would
+// voice the corpus's filler for the asker's referent — the misreference
+// measured live on the trained store ("How do you say 'flurbish' in French?"
+// answered "the way to say hello is \"Bonjour\"").  Nor is CAST rewired: its
+// frame gate is WEAVE-local while a slot is COHORT-local, and substituting one
+// population for the other is the error §2.7 names.  The notion is made
+// AVAILABLE, never imposed.
+import { carriesFillers, distinct, follow, substituteAll } from "../match.js";
+import { dominates } from "../../geometry.js";
+import { bytesEqual, indexOf } from "../../bytes.js";
+import { unexplainedLabel } from "../rationale.js";
+import { STEP } from "../graph-search.js";
+import { rItem, rNode, traceFail } from "../trace.js";
+/** The minimum number of instances that can establish a frame.  One instance
+ *  agrees with nothing, so no carriage is attested — the same "two or no
+ *  constituent" reading frame-filler's contentRuns applies.
+ *
+ *  THIS IS ALSO THE MECHANISM'S REACH.  Evidence comes from the shared top-k
+ *  resonance, so a frame the corpus instantiates only ONCE within k is not
+ *  reachable here.  Measured on the trained store: `How do you say 'flurbish'
+ *  in French?` finds one instance of its frame in the top 24 — the rest are
+ *  `How do you make …`, a different frame — so this abstains and recall's
+ *  scaffolding-dominated tier answers with the CORPUS's filler.  That
+ *  misreference is recall's, and widening the supply is not the fix: the
+ *  exhaustive √N list recall's refusal path builds costs hundreds of
+ *  milliseconds and this runs before it.  Abstaining on thin evidence is the
+ *  honest reading (§2.13). */
+const MIN_INSTANCES = 2;
+/** THE VOICING GATES — this mechanism's own reading of a pairing, applied here
+ *  and NOT in the shared matcher.
+ *
+ *  Every one of these is a requirement for SUBSTITUTING AND SPEAKING, not for
+ *  knowing where a pairing varies, so each belongs to the consumer that
+ *  speaks.  They lived in `frameSlots` first and made the shared reading
+ *  reference-shaped: three of four real pairings were hidden from every other
+ *  consumer, including a definite description standing where a noun stands —
+ *  the shape the frame filler exists for.  A shared layer with one usable
+ *  consumer is private code at a public address.
+ *
+ *  1. EVERY slot must be a SUBSTITUTION.  An insertion or deletion means the
+ *     query says more or less than the frame does, and there is no occupant to
+ *     carry.  (A consumer that WANTS insertions — "what did the asker add?" —
+ *     now sees them; this one cannot use them.)
+ *  2. EVERY slot must reach one river window on BOTH sides.  Below one window
+ *     byte overlap is chance, not evidence — the floor identityBar, the
+ *     bridge's attestedQ and recognition's site test all draw.
+ *  3. The FRAME MUST DOMINATE the query, or this is a different sentence that
+ *     happens to align somewhere.  It is also what bounds the slot count
+ *     without a constant: every slot costs at least a window, and the frame
+ *     must still be more than half the query.
+ *  4. FILLERS PAIRWISE DISTINCT.  Two slots holding the same bytes make the
+ *     occurrence → referent mapping ambiguous, and no evidence resolves it. */
+function voiceable(inst, W, queryLen) {
+    if (inst.slots.length === 0)
+        return false;
+    for (const slot of inst.slots) {
+        if (slot.kind !== "substitution")
+            return false;
+        if (slot.qe - slot.qs < W || slot.ce - slot.cs < W)
+            return false;
+    }
+    if (!dominates(inst.covered, queryLen))
+        return false;
+    return distinct(inst.slots.map((s) => s.filler));
+}
+/** Elect ONE frame from the inventory: the voiceable instances that place
+ *  their slots in the same query spans.
+ *
+ *  THE ELECTION IS THIS MECHANISM'S, not the inventory's (see
+ *  Precomputed.frames).  Demanding that everything which aligned agree would
+ *  be the wrong population: the top-k is ranked by gist, not by frame, so it
+ *  mixes them — measured, `How do you say 'flurbish' in French?` returns one
+ *  instance of its own frame and a dozen of `How do you make …`, which align
+ *  on the shared opening and put their slot somewhere else entirely.  One
+ *  dissenting frame would then veto every binding.
+ *
+ *  Instances of ONE frame put their slots in ONE place, so grouping by the
+ *  whole slot signature and keeping the modal group IS the frame.  The
+ *  signature is every slot, not one: two candidates agreeing about a file name
+ *  but disagreeing about whether a second thing was named are instances of two
+ *  different frames, and mixing them would let a one-slot instance vouch for a
+ *  two-slot binding it says nothing about. */
+function electFrame(inventory, W, queryLen) {
+    const bySignature = new Map();
+    for (const inst of inventory) {
+        if (!voiceable(inst, W, queryLen))
+            continue;
+        const key = inst.slots.map((s) => `${s.qs}:${s.qe}`).join(",");
+        const group = bySignature.get(key);
+        if (group === undefined)
+            bySignature.set(key, [inst]);
+        else
+            group.push(inst);
+    }
+    let best = [];
+    for (const group of bySignature.values()) {
+        // Ties keep the FIRST group in insertion order, which is resonance rank —
+        // corpus-determined, like every other tie-break here (§2.1).
+        if (group.length > best.length)
+            best = group;
+    }
+    return best;
+}
+/** Voice the query's referents through their frame's own attested carriage, or
+ *  null when the corpus does not attest one. */
+export async function bindReference(ctx, query, pre) {
+    const t = ctx.trace?.enter("bindReference", [rItem(query, "query")]);
+    const fail = traceFail(t);
+    const frame = electFrame(await pre.frames(), ctx.space.maxGroup, query.length);
+    if (frame.length < MIN_INSTANCES) {
+        return fail(`${frame.length} instance(s) of one frame — agreement needs ` +
+            `${MIN_INSTANCES}`);
+    }
+    const slots = frame[0].slots.map((s) => [s.qs, s.qe]);
+    const fillersOf = (inst) => inst.slots.map((s) => s.filler);
+    const referents = slots.map(([s, e]) => query.subarray(s, e));
+    // A referent must be the ASKER's, never the engine's own words.  A completed
+    // reply stays available to recognition and the climb as context, but quoting
+    // it back as a referent launders the engine's own output into evidence — the
+    // same rule the weave applies when it aligns only the asker's stream.  ANY
+    // slot falling inside one refuses the whole binding.
+    for (const [rs, re] of slots) {
+        for (const [as_, ae] of ctx.answeredSpans) {
+            if (rs < ae && as_ < re) {
+                return fail("a referent lies inside a completed reply — not the asker's");
+            }
+        }
+    }
+    // Two slots may not name the same bytes, for the same reason two fillers may
+    // not (frameSlots applies it to every instance): the mapping from occurrence
+    // to referent would be ambiguous.
+    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
+    // bridge's `unanimous` demands of a frame before it will substitute.
+    //
+    // Continuations are followed ONE AT A TIME, inside the test, because the
+    // overwhelmingly common outcome is refusal and a refusal usually comes from
+    // the first comparison — a filler-dependent frame disagrees on instance 2 of
+    // 12.  Reading all of them up front pays the whole cohort's projections to
+    // 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";
+    const first = await follow(ctx, frame[0].id, pre.guide);
+    if (first === null || first.length === 0)
+        return fail(leadsNowhere);
+    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 (!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");
+            return fail("the frame's answer is not a carriage of its fillers");
+        }
+    }
+    // THE BINDING IS A BYTE CONSTRUCTION, NOT A SEARCH, and deliberately so.
+    // Articulation splices through ctx.search.cover because WHICH voicing wins is
+    // genuinely searched — several candidate substitutions compete.  Here the
+    // licence has already determined the substitution byte-exactly; a search that
+    // can only confirm a determined result is ceremony, not composition.  The
+    // precedent is frame-filler, which constructs its lookup key the same way.
+    const bytes = substituteAll(first, fillersOf(frame[0]).map((needle, s) => ({ needle, repl: referents[s] })));
+    if (bytes.length === 0)
+        return fail("the binding produced nothing");
+    // Answering with the question is not answering — the same restated-fragment
+    // guard every recall tier applies.
+    if (bytes.length < query.length && indexOf(query, bytes, 0) >= 0) {
+        return fail("the binding restates part of the question");
+    }
+    const carried = !bytesEqual(bytes, first);
+    ctx.trace?.step("bindReferent", [
+        ...referents.map((r, s) => rItem(r, `referent ${s + 1}`, undefined, slots[s])),
+        ...frame.map((inst) => rNode(ctx, inst.id, "instance")),
+    ], [rItem(bytes, "bound")], carried
+        ? `carry the asker's ${slots.length} referent(s) through the frame's own ` +
+            `answer — ${frame.length} instances attest the carriage byte-exactly`
+        : `the frame's answer does not depend on its filler(s) — ` +
+            `${frame.length} instances attest the same continuation`);
+    // WHAT THIS EXPLAINS: the frame it matched literally, AND every slot.  A slot
+    // is not a hole in the explanation — it is an act this mechanism PAID for,
+    // one STEP each in `moves` below, and leaving it unaccounted charges the same
+    // act twice (once as a move, once at PASS per byte, which is far the larger).
+    // The bridge records the same reasoning for its own substitutions.
+    const accounted = [
+        ...frame[0].matched.filter(([s, e]) => e > s),
+        ...slots,
+    ].sort((a, b) => a[0] - b[0]);
+    t?.done([rItem(bytes, "answer")], "reference — the asker's referent(s) voiced through a slot the corpus " +
+        "attests as a carriage");
+    return {
+        bytes,
+        accounted,
+        // The acts: one BINDING per slot plus one edge FOLLOW across the frame's
+        // own continuation — the same per-projection price CAST's substitution
+        // schema pays for the structurally analogous act.  Not CONCEPT: the ladder
+        // reserves that for halo-mediated acts, and a reference is decided by byte
+        // identity, not distributional company.  Per-slot matters: a two-slot
+        // binding claims strictly more than a one-slot binding, so where both are
+        // licensed the smaller claim wins.
+        moves: STEP * slots.length + STEP,
+        unexplained: unexplainedLabel(query, accounted),
+        // NOT scaffolding.  That field counts answer bytes carried through BECAUSE
+        // NOTHING EXPLAINED THEM; a referent is carried because the frame's slot
+        // explains it, and it is accounted above.  Reporting it would make every
+        // licensed binding lose its equal-grade tie-breaks by construction.
+        //
+        // COMPLETE — post-grounding must not extend a binding.  The bound answer is
+        // a byte string this mechanism CONSTRUCTED; the corpus never said it, so
+        // pivoting through it treats the engine's own construction as a trained
+        // fact — the same laundering the answeredSpans guard above refuses in the
+        // other direction.  Measured: with the frame "How do I compile X?" ->
+        // "Run gcc X" and a stored "Run gcc main.c" -> "then execute ./a.out", the
+        // binding produced "Run gcc main.c" and reason() pivoted straight past it,
+        // answering "then execute ./a.out" — the referent gone AND the question
+        // unanswered.  This is what MechanismResult.complete documents: the query
+        // IS a trained context (here, an instance of a trained frame), so its
+        // continuation is the whole read-out.  Fusion still runs; it is gated on
+        // the query REMAINDER, which a binding accounting frame plus slots leaves
+        // empty.
+        complete: true,
+    };
+}
+// ── Pipeline mechanism ──────────────────────────────────────────────────────
+export const referenceMechanism = {
+    name: "reference",
+    provenance: "reference",
+    async floor(ctx, query, pre, worthRunning) {
+        // The floor is exactly one binding plus one follow — the cheapest shape a
+        // result can take.  INVESTMENT DISCIPLINE: when that already cannot beat
+        // the incumbent, return it UNINVESTED rather than first-touching the shared
+        // inventory (cast.ts and extraction.ts are the reference implementations).
+        const bound = STEP + STEP;
+        if (!worthRunning(bound))
+            return bound;
+        // A frame needs a query long enough to hold one, and a slot needs at least
+        // one window of its own beside it.
+        if (query.length < 2 * ctx.space.maxGroup)
+            return null;
+        // A query the store holds outright is not a reference to anything — its own
+        // edges answer it, and binding would re-derive what recall reads directly.
+        // O(|query|) probes, already computed for this response.
+        if (pre.queryResolved !== null)
+            return null;
+        // NO SCAFFOLDING GATE HERE, DELIBERATELY.  `allWindowsAreScaffolding` gates
+        // recall's scaffolding-dominated tier and looks like the obvious third
+        // gate, but it is calibrated for mechanisms grounding THROUGH the query's
+        // stored windows, where "every window is a hub" means the query says
+        // nothing the corpus can be held to.  A reference query's discriminative
+        // content is the SLOT — exactly the part the corpus cannot attest — so the
+        // predicate reports "all scaffolding" for the purest references there are.
+        // Measured on the byte-modality fixture (test/76): the frame's windows sit
+        // in all three instances and the referents' in none, so the gate fired and
+        // the mechanism abstained on an answer it had already derived correctly.
+        //
+        // What holds this honest is not window rarity but the licence: instances
+        // agreeing on one slot signature, each leading somewhere, and unanimous
+        // BYTE-EXACT carriage across all of them.
+        return bound;
+    },
+    async run(ctx, query, pre) {
+        const bound = await bindReference(ctx, query, pre);
+        return bound === null ? [] : [bound];
+    },
+};

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

@@ -145,7 +145,7 @@ export declare class Mind implements MindContext {
     _gistCache: BoundedMap<number, Vec>;
     _depositTrees: BoundedMap<string, import("./types.js").DepositCacheEntry>;
     _depositLens: Set<number>;
-    _internIds: WeakMap<Sema, number>;
+    _internIds: WeakMap<import("../sema.js").Sema, number>;
     private _nextConvId;
     private _conversations;
     /** Canonical node id of a byte span.  Required by GraphSearchHost & MindContext. */