@hviana/sema 0.5.2 → 0.5.4

package/src/mind/mechanisms/reference.ts

@@ -0,0 +1,343 @@
+// 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 type { MindContext } from "../types.js";
+import type { FrameInstance } from "../match.js";
+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 type {
+  MechanismResult,
+  PipelineMechanism,
+  Precomputed,
+} from "../pipeline-mechanism.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: FrameInstance,
+  W: number,
+  queryLen: number,
+): boolean {
+  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: ReadonlyArray<FrameInstance>,
+  W: number,
+  queryLen: number,
+): FrameInstance[] {
+  const bySignature = new Map<string, FrameInstance[]>();
+  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: FrameInstance[] = [];
+  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: MindContext,
+  query: Uint8Array,
+  pre: Precomputed,
+): Promise<MechanismResult | null> {
+  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): [number, number] => [s.qs, s.qe]);
+  const fillersOf = (inst: FrameInstance) => 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: Array<[number, number]> = [
+    ...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: PipelineMechanism = {
+  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/src/mind/mind.ts

@@ -304,7 +304,7 @@ export class Mind implements MindContext {
   /** Per-response memo of {@link chooseNext} picks — ensures every mechanism
    *  of a single response follows the SAME continuation for each ambiguous
    *  context node. */
-  _edgeChoice = new Map<number, number>();
+  _edgeChoice: Map<number, number> = new Map<number, number>();
 
   /** Previous deposit's seen node ids for incremental change detection. */
   _prevSeen: Set<number> | null = null;
@@ -312,7 +312,7 @@ export class Mind implements MindContext {
   /** Session cache of node-id → perceived gist for candidate scoring — see
    *  {@link MindContext._gistCache}.  32 MB ≈ 8K gists at D=1024; hub
    *  candidate sets (√N at most) fit comfortably and recur across queries. */
-  _gistCache = new BoundedMap<number, Vec>(
+  _gistCache: BoundedMap<number, Vec> = new BoundedMap<number, Vec>(
     32_000_000,
     (v) => v.byteLength,
   );
@@ -320,12 +320,16 @@ export class Mind implements MindContext {
   // bounded: a pyramid costs ~KB per content byte (one D-float gist per
   // interior node), and only the few live conversation chains need to stay
   // warm, so 8 entries is the honest budget.
-  _depositTrees = new BoundedMap<
-    string,
-    import("./types.js").DepositCacheEntry
-  >(8);
-  _depositLens = new Set<number>();
-  _internIds = new WeakMap<import("../sema.js").Sema, number>();
+  _depositTrees: BoundedMap<string, import("./types.js").DepositCacheEntry> =
+    new BoundedMap<
+      string,
+      import("./types.js").DepositCacheEntry
+    >(8);
+  _depositLens: Set<number> = new Set<number>();
+  _internIds: WeakMap<import("../sema.js").Sema, number> = new WeakMap<
+    import("../sema.js").Sema,
+    number
+  >();
 
   // ── Conversation state ──────────────────────────────────────────────────
 

package/src/mind/pipeline-mechanism.ts

@@ -16,14 +16,21 @@
 import type { AncestorReach, MindContext, Recognition } from "./types.js";
 import type { AttentionRead } from "./types.js";
 import type { ComputedSpan } from "../extension.js";
+import type { Hit } from "../store.js";
 import type { Vec } from "../vec.js";
 import { indexOf } from "../bytes.js";
-import { dominates } from "../geometry.js";
+import { conceptThreshold, dominates } from "../geometry.js";
 import { windowIds } from "./canonical.js";
 import { read, resolve } from "./primitives.js";
-import { alignGraded, type GradedRun, skillExemplar } from "./match.js";
+import {
+  alignGraded,
+  type FrameInstance,
+  frameSlots,
+  type GradedRun,
+  skillExemplar,
+} from "./match.js";
 import { climbAttentionAll } from "./attention.js";
-import { sharedReachMemo } from "./traverse.js";
+import { hubBound, sharedReachMemo } from "./traverse.js";
 
 // ── Precomputed ──────────────────────────────────────────────────────────────
 //
@@ -125,6 +132,116 @@ export class Precomputed {
     return meter ? meter.time(phase, fn) : fn();
   }
 
+  private _resonance?: Promise<ReadonlyArray<Hit>>;
+  /** The response's ONE top-k content-index read: the k learnt forms nearest
+   *  the whole-query gist, ranked.  Recall's every gist tier is built on it,
+   *  and {@link frames} assembles the frame inventory from it.
+   *
+   *  An ANN query is the single most expensive read in the engine, and two
+   *  mechanisms asking the same question of the same gist is the one
+   *  duplication a profile shows as doubled `annVectorReads` with nothing to
+   *  account for it.  Cached BY PROMISE, so a second caller awaits the first. */
+  resonance(): Promise<ReadonlyArray<Hit>> {
+    return this._resonance ??= this.shared(
+      "resonance",
+      () => this.ctx.store.resonate(this.guide, this.k),
+    );
+  }
+
+  private _wide?: Promise<ReadonlyArray<number>>;
+  /** The response's WIDE candidate list — the top-k when the query's gist has
+   *  no concept-level match anywhere, and an exhaustive √N read when it does.
+   *
+   *  Every mechanism that has to look PAST the top-k reads this one list: the
+   *  substitution bridge, prefix completion and the frame filler all did, and
+   *  it was memoised inside recall for exactly that reason (measured: 490 ms
+   *  median re-issued against 13 ms non-exhaustive, 36x).  A memo inside one
+   *  mechanism only serves that mechanism's own tiers, so it lives here now —
+   *  the same move `resonance` made for the top-k.
+   *
+   *  THE CONDITION IS THE TOP HIT'S SCORE, NOT THE CORPUS SIZE.  When nothing
+   *  ranks at concept level, an exhaustive ANN only scores more vectors below
+   *  the bar (profiled at 38K–40K annVectorReads per refusing query on a 325K-
+   *  context store); the structural channels — junction walks, anchor climbs,
+   *  the write side's window index — are the correct proposal source there,
+   *  because the ANN cannot propose what the gist cannot rank.  This was once
+   *  spelled `corpusN(ctx) <= (k · W)³`, which asks a different question and
+   *  answers it wrongly at exactly the scale it was written from: at N =
+   *  325,608 with k = 24 and W = 4 the cube is 884,736, so that store took the
+   *  exhaustive branch — the very branch measured above.  Measured cost of the
+   *  mismatch: substitutionBridge 8,544 ms of a 19,548 ms think (44%), against
+   *  1,248 ms and 14,218 ms without it, every answer byte-identical. */
+  wideResonance(): Promise<ReadonlyArray<number>> {
+    return this._wide ??= this.shared("wideResonance", async () => {
+      const hits = await this.resonance();
+      if (
+        hits.length > 0 &&
+        hits[0].score >= conceptThreshold(this.ctx.store.D)
+      ) {
+        const exhaustive = await this.ctx.store.resonate(
+          this.guide,
+          hubBound(this.ctx),
+          true,
+        );
+        return exhaustive.map((h) => h.id);
+      }
+      return hits.map((h) => h.id);
+    });
+  }
+
+  private _frames?: Promise<ReadonlyArray<FrameInstance>>;
+  /** THE FRAME INVENTORY — every ranked candidate that reads as an instance of
+   *  the same frame as the query, each with the query spans it leaves VARIABLE
+   *  ({@link FrameInstance}).  The one place the engine represents "a position
+   *  whose occupant comes from the context rather than the corpus".
+   *
+   *  AN INVENTORY, NOT AN ELECTION.  It reports every pairing and elects no
+   *  frame, deliberately: a slot is a property of a PAIRING, not of the query,
+   *  and different candidates put slots in different places.  Committing to one
+   *  reading here would push whichever consumer asked first onto everyone else
+   *  — the market's decoupling (§2.6) broken from inside the shared container,
+   *  and the population error §2.7 names.  Each consumer groups and commits
+   *  for its own question; reference elects the modal slot signature, and a
+   *  consumer wanting a different reading is not fighting this one.
+   *
+   *  NO LICENCE EITHER.  Knowing a span is variable is safe for every consumer
+   *  — it can only improve an alignment.  Knowing one may be VOICED through is
+   *  a different and much stronger claim, gated separately by
+   *  {@link carriesFillers}, which needs projections this must not perform. */
+  frames(): Promise<ReadonlyArray<FrameInstance>> {
+    return this._frames ??= this.shared("frames", async () => {
+      const ctx = this.ctx;
+      const W = ctx.space.maxGroup;
+      // PHRASE SCALE, the same bound the bridge and the frame filler put on a
+      // candidate's bytes: a form an order of magnitude longer than the query
+      // is not a candidate for BEING it with a span replaced.
+      const capBytes = this.query.length * W;
+      const out: FrameInstance[] = [];
+      for (const h of await this.resonance()) {
+        // REJECT BY LENGTH BEFORE RECONSTRUCTING (§2.8): `contentLen` is an
+        // indexed read, `bytesPrefix` rebuilds a subtree.  ONLY the phrase-scale
+        // cap is applied — it is a bounded-read discipline, not a judgement.
+        //
+        // A LOWER bound was here too (`dominates(len, query.length)`, on the
+        // reasoning that a candidate shorter than half the query cannot supply
+        // a frame that dominates it).  That is reference's gate wearing a cost
+        // argument's clothes, and it hid the very pairings another consumer
+        // needs: `What is the capital of France?` (30 B) against `What is the
+        // capital of the country where the Eiffel Tower is?` (61 B) was
+        // rejected before it was ever read — a definite description standing
+        // where a noun stands, which is exactly the shape the frame filler
+        // exists for.
+        const len = ctx.store.contentLen(h.id, capBytes + 1);
+        if (len === 0 || len > capBytes) continue;
+        const cand = ctx.store.bytesPrefix(h.id, capBytes + 1);
+        if (cand.length === 0 || cand.length > capBytes) continue;
+        const inst = frameSlots(ctx, this.query, cand, h.id);
+        if (inst !== null) out.push(inst);
+      }
+      return out;
+    });
+  }
+
   private _attention?: Promise<AttentionRead>;
   /** The full consensus climb (roots + ranked anchors) — the query-level
    *  evidence CAST, confluence, extraction, recall's scaffolding tier, and

package/src/mind/pipeline.ts

@@ -23,6 +23,8 @@ import { coverMechanism } from "./mechanisms/cover.js";
 import { castMechanism } from "./mechanisms/cast.js";
 import { confluenceMechanism } from "./mechanisms/confluence.js";
 import { extractionMechanism } from "./mechanisms/extraction.js";
+import { referenceMechanism } from "./mechanisms/reference.js";
+import { prefixMechanism } from "./mechanisms/prefix-completion.js";
 import { recallMechanism } from "./mechanisms/recall.js";
 
 // Re-exports: cover's pre-resolution helpers and the ALU adapter kept
@@ -60,13 +62,23 @@ async function collectComputed(
 // floor pruning every mechanism is already subject to — not by asking
 // "is this an extension?". Grade TIES keep the earlier candidate, so this
 // order is also the tie-break priority: cover, cast, confluence, extraction,
-// recall.
+// reference, recall.
+//
+// REFERENCE sits after extraction and before recall because that is what its
+// claim is worth: extraction READS a span out of the query (no synthesis),
+// reference voices one through a learnt slot, and recall's tiers degrade
+// toward echo and silence.  It does not PRUNE recall — its floor is two
+// projections, so recall's one-STEP floor still clears `worthRunning` — and it
+// is not meant to: both run, share one resonance read
+// (Precomputed.resonance), and the ladder decides.
 export const defaultMechanisms: PipelineMechanism[] = [
   coverMechanism,
   castMechanism,
   confluenceMechanism,
   extractionMechanism,
+  referenceMechanism,
   recallMechanism,
+  prefixMechanism,
 ];
 
 // ── think — the main inference pipeline ─────────────────────────────────────
@@ -76,8 +88,10 @@ export type Provenance =
   | "join"
   | "cover"
   | "extract"
+  | "reference"
   | "recall"
-  | "recall-echo";
+  | "recall-echo"
+  | "prefix";
 
 export interface Thought {
   bytes: Uint8Array;