@hviana/sema 0.5.3 → 0.5.4

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

@@ -1,327 +0,0 @@
-// extraction.ts — Extraction (Skill) — Section 4 of the mind.
-//
-// Given a query and its consensus-ranked anchors, find the first span-shaped
-// skill exemplar among the ranked anchors and read the analogous span of the
-// query.  A skill exemplar is a learnt fact whose context and answer together
-// form a span-in-context pattern: the answer is a subsequence of the context
-// (or one of its pieces is), and the context is the smallest spanning frame
-// that contains it.
-import { locate } from "../match.js";
-import { concatBytes, indexOf } from "../../bytes.js";
-import { decodeText, unexplainedLabel } from "../rationale.js";
-import { CONCEPT, STEP } from "../graph-search.js";
-import { rItem, rNode, traceFail } from "../trace.js";
-// ── Extraction ────────────────────────────────────────────────────────────
-/** Find the first span-shaped skill exemplar among the ranked anchors from
- *  climbAttentionAll and read the analogous span from the query.  Returns
- *  the extracted bytes PLUS the query spans the skill ACCOUNTED FOR — the
- *  located frames AND any read span BOUNDED by located frames on both
- *  sides, the elementary evidence think's grounding decider weighs.  A
- *  bounded read is explained: the skill located both its borders in the
- *  query and emitted exactly what sits between them.  An OPEN-ENDED read
- *  (the exemplar's answer reaches the context's end, so the query is read
- *  to its own end with no located right border) remains a guess about where
- *  the span stops — it stays unaccounted, priced by exclusion like the
- *  cover's bridged bytes.  (Accounting frames only — the earlier convention
- *  — let a CAST juxtaposition that merely echoed the query's exact site
- *  outweigh a correct bounded extraction: the same span counted as
- *  explained for one mechanism and not the other, and the asymmetry, not
- *  the answers' merits, decided the grounding.)  Null when no skill
- *  applies. */
-export async function extractBySkill(ctx, query, pre) {
-    const t = ctx.trace?.enter("extractBySkill", [
-        rItem(query, "query"),
-    ]);
-    const fail = traceFail(t);
-    // Use climbAttentionAll to get the FULL ranked list, not just the
-    // roots that cleared commitVotes' significance floor.  The floor
-    // gates further points of attention for fusion, but extraction only
-    // needs ONE anchor that IS a span-shaped skill exemplar — and on
-    // some seeds the top-voted anchor is not one (e.g. a concept-merge
-    // nickname outvotes the painting exemplars on shared substrings,
-    // while the exemplars' votes fall below the floor).  Iterating the
-    // ranked list instead of just the roots lets extraction reach the
-    // first painting-exemplar anchor regardless of its floor status.
-    //
-    const { ranked } = await pre.attention();
-    if (ranked.length === 0) {
-        return fail("no consensus anchor — no skill to apply");
-    }
-    // Try ranked anchors IN ORDER until one yields a USABLE extraction — not
-    // merely a span-shaped exemplar, but one whose extracted span clears the
-    // same one-river-fold quantum (W) cover.ts's restatedSpan gate already
-    // treats as the floor below which byte overlap is chance, not evidence.
-    // isSpanShaped (spanShapedOf) is a deliberately permissive sparse-
-    // subsequence check — see the section note below — so it accepts exemplars
-    // whose relation to the query is coincidental gap-matching, not genuine
-    // structure.  Stopping at the FIRST such exemplar let a coincidental match
-    // early in the ranked list win outright and read out a sub-quantum
-    // fragment (observed: a 3-byte "Hel" pulled from an unrelated exemplar,
-    // while a later ranked anchor would have read the query's own "Hello…"
-    // correctly).  Trying further anchors when one produces nothing usable is
-    // the same idiom this loop already uses for non-exemplars — extended to
-    // cover a bad extraction, not just a structural non-match.
-    //
-    // The retry is bounded at pre.k — the SAME evidence-breadth constant every
-    // other consumer of a ranked list already self-limits to (resonance, the
-    // weave, the climb itself; see Precomputed.k's own doc comment) — not the
-    // full ranked list.  locate()'s frame match has an EXACT-byte tier with no
-    // significance correction of its own (short W-byte frames are cheap to
-    // match by pure chance), so trying every ranked anchor turns that per-
-    // anchor chance into a near-certainty over enough attempts: on a pure-
-    // gibberish query, 170 anchors deep found an unrelated Zulu exemplar whose
-    // short frame happened to byte-match, producing "xyzzy pl" — a coincidence
-    // no different in kind from the "RaBitQ estimate overshot the reach bar
-    // and grounded pure gibberish" failure recall.ts's own significance
-    // correction exists to prevent (see recallByResonance's reach-threshold
-    // comment).  Bounding the search to the ranked list's own top-k restores
-    // the "genuinely relevant but not root-significant" exemplars this loop
-    // was built for, without the unbounded tail's chance collisions.
-    const W = ctx.space.maxGroup;
-    const searched = ranked.slice(0, pre.k);
-    let shapeMisses = 0;
-    let subQuantum = 0;
-    for (const cand of searched) {
-        const exemplar = await pre.spanShapedOf(cand.anchor);
-        if (!exemplar) {
-            shapeMisses++;
-            continue;
-        }
-        const built = buildFromExemplar(ctx, query, pre, exemplar);
-        if (built === null || built.bytes.length < W) {
-            subQuantum++;
-            continue;
-        }
-        // AN UNANCHORED READ IS NOT AN EXTRACTION.  This function's contract (see
-        // the doc above) is that `accounted` carries "the located frames AND any
-        // read span BOUNDED by located frames on both sides", while an open-ended
-        // read "remains a guess about where the span stops — it stays unaccounted".
-        // EMPTY accounted is the degenerate case of that: NO frame of the exemplar
-        // was located in the query at all, so nothing ties the bytes just read to
-        // this question — the skill applied its exemplar's geometry to a query it
-        // never matched.
-        //
-        // The live case (analyze_training.ts F, the battery's ONLY wrong non-silent
-        // answer): "Which city is France's seat of government?" answered "Which ci"
-        // — a fragment of the query itself — from the exemplar "What is dll", with
-        // accounted=[] and pieces=1.  isSpanShaped is deliberately permissive (a
-        // sparse-subsequence check), so it accepts exemplars whose relation to the
-        // query is coincidental gap-matching; requiring at least one LOCATED frame
-        // is the structural evidence that permissiveness leaves out.
-        //
-        // Scoped to extraction ON PURPOSE.  The same test at the pipeline's
-        // post-grounding density check was tried and REVERTED: `accounted` is passed
-        // empty BY CONVENTION on recall's own tiers (recall.ts's ground(…, [], …)),
-        // so a density veto there refused six legitimate reverse-recall groundings.
-        // Here the field is this mechanism's own output and carries its documented
-        // meaning, so the test is sound exactly where the convention does not reach.
-        if (built.accounted.length === 0) {
-            subQuantum++;
-            continue;
-        }
-        if (shapeMisses > 0 || subQuantum > 0) {
-            ctx.trace?.step("trySkillAnchors", [
-                rItem(query.subarray(0, 0), `skipped ${shapeMisses + subQuantum}`),
-                rNode(ctx, cand.anchor, "chosen"),
-            ], [], `skipped ${shapeMisses} non-exemplar and ${subQuantum} sub-quantum ` +
-                `anchor(s) before one yielded a usable extraction`);
-        }
-        t?.done([rItem(built.bytes, "extracted")], built.pieces === 1
-            ? `apply a learnt extraction skill — read the analogous span of the query` +
-                ` framed like "${decodeText(exemplar.answerBytes)}" sits in its exemplar`
-            : `apply a learnt MULTI-PIECE skill — read ${built.pieces} analogous` +
-                ` pieces of the query and synthesize them like "${decodeText(exemplar.answerBytes)}"`);
-        return {
-            bytes: built.bytes,
-            accounted: built.accounted,
-            unexplained: unexplainedLabel(query, built.accounted),
-        };
-    }
-    if (shapeMisses === searched.length) {
-        ctx.trace?.step("trySkillAnchors", [], [], `none of the top ${searched.length} ranked anchor(s) (of ${ranked.length} total) ` +
-            `is a span-shaped skill exemplar`);
-        return fail("no consensus root is a span-shaped skill exemplar");
-    }
-    return fail("no ranked anchor yielded an extraction at or above the quantum floor");
-}
-/** Build the extracted bytes for ONE already-accepted span-shaped exemplar —
- *  factored out of {@link extractBySkill} so its anchor loop can try
- *  successive ranked candidates instead of committing to the first
- *  structural match.  Null when the exemplar's answer does not decompose
- *  against its context, or no piece's frame locates in the query. */
-function buildFromExemplar(ctx, query, pre, exemplar) {
-    const { contextBytes, answerBytes } = exemplar;
-    const ansCtxRuns = answerRunsInContext(ctx, contextBytes, answerBytes);
-    if (ansCtxRuns === null || ansCtxRuns.length === 0) {
-        return null;
-    }
-    if (ansCtxRuns.length > 1) {
-        ctx.trace?.step("decomposeAnswer", [rItem(answerBytes, "multi-piece-answer")], ansCtxRuns.map((r) => rItem(contextBytes.subarray(r.start, r.end), "piece", undefined, [
-            r.start,
-            r.end,
-        ])), `answer splits into ${ansCtxRuns.length} piece(s) within the exemplar context`);
-    }
-    const pieces = [];
-    const accounted = [];
-    for (let ri = 0; ri < ansCtxRuns.length; ri++) {
-        const run = ansCtxRuns[ri];
-        const isLast = ri === ansCtxRuns.length - 1;
-        const framePreLen = Math.min(run.start, ctx.space.maxGroup);
-        const framePre = run.start > 0
-            ? contextBytes.subarray(run.start - framePreLen, run.start)
-            : null;
-        const frames = [];
-        let start = 0;
-        if (framePre) {
-            const prePos = locate(ctx, query, framePre, 0, pre.rec.sites);
-            if (prePos < 0)
-                continue;
-            start = prePos + framePre.length;
-            frames.push([prePos, start]); // the located frame IS matched evidence
-        }
-        let end;
-        if (isLast) {
-            if (run.end < contextBytes.length) {
-                const framePostLen = Math.min(contextBytes.length - run.end, ctx.space.maxGroup);
-                const framePost = contextBytes.subarray(run.end, run.end + framePostLen);
-                const postPos = locate(ctx, query.subarray(start), framePost, 0, pre.rec.sites);
-                if (postPos < 0)
-                    continue;
-                end = start + postPos;
-                frames.push([end, end + framePost.length]); // matched post-frame
-            }
-            else {
-                end = query.length;
-            }
-        }
-        else {
-            const nextRun = ansCtxRuns[ri + 1];
-            const nextPreLen = Math.min(nextRun.start, ctx.space.maxGroup);
-            const nextPre = contextBytes.subarray(nextRun.start - nextPreLen, nextRun.start);
-            const nextPos = locate(ctx, query.subarray(start), nextPre, 0, pre.rec.sites);
-            if (nextPos < 0) {
-                end = start + run.ansLen;
-            }
-            else {
-                end = start + nextPos;
-                frames.push([end, end + nextPre.length]); // matched next-frame
-            }
-        }
-        if (start >= end)
-            continue;
-        pieces.push(query.subarray(start, end));
-        accounted.push(...frames);
-        // Bounded on both sides ⇒ the read span itself is explained (see doc).
-        // frames carries the pre-border (when the answer is not at the context's
-        // start) and the located right border (post-frame or next piece's
-        // pre-frame); only when BOTH borders were located is the read bounded.
-        const preBounded = run.start === 0 || frames.some(([, e]) => e === start);
-        const postBounded = frames.some(([b]) => b === end);
-        if (preBounded && postBounded)
-            accounted.push([start, end]);
-    }
-    if (pieces.length === 0) {
-        return null;
-    }
-    const out = pieces.length === 1 ? pieces[0] : concatBytes(pieces);
-    return { bytes: out, accounted, pieces: pieces.length };
-}
-// ── The two span-shape readings: OPEN acceptance vs. STRONG decomposition ──
-//
-// isSpanShaped and answerRunsInContext read the SAME relation ("the answer is
-// drawn from the context") at two deliberately different strengths, and they
-// are NOT interchangeable:
-//
-//   • isSpanShaped — the OPEN reading: any in-order embedding (a sparse
-//     subsequence, arbitrary gaps).  O(|context|) byte scan.  Used to ACCEPT
-//     an exemplar candidate.
-//   • answerRunsInContext — the STRONG reading: a greedy longest-run
-//     DECOMPOSITION into contiguous pieces.  Greedy-longest is strictly
-//     stronger than subsequence (a long late match can consume context an
-//     earlier shorter choice needed), so an ACCEPTED exemplar can still fail
-//     to decompose — extractBySkill then fails with "answer is not a
-//     subsequence of the context" and think falls through to recall.  That
-//     fall-through is BEHAVIOUR, pinned by the extraction suites: do not
-//     "unify" the two into one machine — replacing the open reading with the
-//     strong one silently rejects exemplars extraction today accepts, and
-//     replacing the strong one with a backtracking embedding changes which
-//     pieces are read out of the query.
-/** Decompose an answer into substrings of its surrounding context, in order —
- *  the STRONG span-shape reading (see the section note above).  Returns null
- *  when no greedy longest-run decomposition exists.  Adjacent runs that
- *  connect contiguously are merged. */
-export function answerRunsInContext(_ctx, context, answer) {
-    const pos = indexOf(context, answer, 0);
-    if (pos >= 0) {
-        return [{ start: pos, end: pos + answer.length, ansLen: answer.length }];
-    }
-    const runs = [];
-    let ai = 0;
-    let ci = 0;
-    while (ai < answer.length) {
-        // Longest match of the remaining answer at any position of the remaining
-        // context: one direct extend per context position — O(|ctx|·match) per
-        // run, replacing the previous longest-first indexOf countdown whose
-        // repeated scans were cubic on long sparse-subsequence answers.
-        let bestLen = 0;
-        let bestPos = -1;
-        for (let p = ci; p < context.length; p++) {
-            let l = 0;
-            const maxL = Math.min(context.length - p, answer.length - ai);
-            if (maxL <= bestLen)
-                break; // no later position can beat the best
-            while (l < maxL && context[p + l] === answer[ai + l])
-                l++;
-            if (l > bestLen) {
-                bestLen = l;
-                bestPos = p;
-                if (ai + l === answer.length)
-                    break; // the whole remainder matched
-            }
-        }
-        if (bestLen === 0)
-            return null;
-        runs.push({ start: bestPos, end: bestPos + bestLen, ansLen: bestLen });
-        ai += bestLen;
-        ci = bestPos + bestLen;
-    }
-    const merged = [];
-    for (const r of runs) {
-        const last = merged[merged.length - 1];
-        if (last && r.start === last.end) {
-            last.end = r.end;
-            last.ansLen += r.ansLen;
-        }
-        else {
-            merged.push({ ...r });
-        }
-    }
-    return merged.length > 0 ? merged : null;
-}
-// ── Pipeline mechanism ──────────────────────────────────────────────────────
-export const extractionMechanism = {
-    name: "extraction",
-    provenance: "extract",
-    async floor(_ctx, _query, pre, worthRunning) {
-        // Extraction's floor is always exactly CONCEPT+STEP when it exists —
-        // same investment discipline as CAST's (see cast.ts): when the bound
-        // already cannot beat the incumbent, return it UNINVESTED (never
-        // first-touch the climb just to be pruned).
-        if (!worthRunning(CONCEPT + STEP))
-            return CONCEPT + STEP;
-        if ((await pre.attention()).ranked.length === 0)
-            return null;
-        return CONCEPT + STEP;
-    },
-    async run(ctx, query, pre) {
-        const ex = await extractBySkill(ctx, query, pre);
-        if (!ex)
-            return [];
-        return [{
-                bytes: ex.bytes,
-                accounted: ex.accounted,
-                moves: CONCEPT + STEP * ex.accounted.length,
-                unexplained: ex.unexplained,
-            }];
-    },
-};

package/dist/src/mind/mechanisms/prefix-completion.d.ts

@@ -1,22 +0,0 @@
-import type { MindContext } from "../types.js";
-import type { PipelineMechanism } from "../pipeline-mechanism.js";
-/** A trained form the query opens, and the bytes by which it continues. */
-export interface PrefixCompletion {
-    /** The trained form whose opening the query is — the answer, voiced whole. */
-    id: number;
-    /** The form's own bytes.  The mechanism grounds a FORM, never a slice of
-     *  one: slicing at the query's end would cut at an offset the geometry has
-     *  no reason to treat as a boundary. */
-    form: Uint8Array;
-    /** The bytes past the query — carried for the rationale and for the
-     *  uniqueness comparison, not voiced on its own. */
-    continuation: Uint8Array;
-}
-/** 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.
- *
- *  `ranked` must be a list the caller has ALREADY fetched; this mechanism never
- *  resonates on its own (see the header's cost note). */
-export declare function prefixCompletion(ctx: MindContext, query: Uint8Array, ranked: ReadonlyArray<number>): PrefixCompletion | null;
-export declare const prefixMechanism: PipelineMechanism;

package/dist/src/mind/mechanisms/prefix-completion.js

@@ -1,243 +0,0 @@
-// 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
-// query is not SIMILAR to that form, it is a PROPER PREFIX of it: every query
-// byte is a literal match, in order, from offset zero.  That is the strongest
-// grounding relation in the store — stronger than the bridge's corroborated
-// substitution, which pays a CONCEPT per substituted span, and stronger than
-// resonance, which only claims an angle.  Nothing is invented: the answer IS a
-// trained form, voiced whole.
-//
-// NO NOTION OF TEXT.  This mechanism reads bytes and geometry only.  It has no
-// separator, no character class, no "word": the only structural quantity it
-// uses is W, the river's grouping window, which is the same capacity the
-// perception tree groups by and the same bar the argument-binding tier holds
-// its constituents to.  A completion shorter than one grouping window carries
-// no structure the geometry can perceive, whatever the modality — that is a
-// statement about the fold, not about punctuation.  Presentation (what is
-// "spacing", what is "case") belongs to the injected canon and to the modality
-// entry point, never here; see src/canon.ts.
-//
-// WHY THE EARLIER TIERS CANNOT DO IT.  Two independent reasons, both measured:
-//
-//   1. `resolve(prefix)` is null.  A proper prefix of a deposited stream has no
-//      branch of its own unless it was itself deposited, so the exact tiers
-//      have nothing to find.
-//   2. The form is not among the resonance candidates AT ALL.  Measured on the
-//      trained store: cos(query, that form) = 0.5752, yet the form is absent
-//      from `resonate(k)` at k = 24, 256 AND 2048 — while forms scoring LOWER
-//      (Germany 0.5670, Yemen 0.5591) are returned.  `k` only reorders WITHIN
-//      the IVF clusters already probed, exactly as Store.resonate's doc warns,
-//      so no k recovers it.  With `exhaustive` it ranks 8.
-//
-// So this is a RETRIEVABILITY gap, not a semantic one, and it is repaired by
-// reading the candidate list recall's refusal path has ALREADY fetched
-// exhaustively for the substitution bridge — never by resonating on its own.
-// Measured cost of the scan over those 570 candidates: 2.9 ms warm, 20.4 ms
-// cold, against a ~700 ms refusal path.  Issuing a FRESH exhaustive call would
-// cost 490 ms median against 13 ms non-exhaustive (36×), which is why this tier
-// takes the candidate list as an argument and adds nothing to it.
-//
-// THREE GUARDS, each falsified into existence by measurement — do not drop any:
-//
-//   1. AN UNREADABLE CONTINUATION VETOES.  Reads are bounded (a stored span can
-//      run to hundreds of kilobytes), so a candidate that opens with the query
-//      but SATURATES the read continues in a way nobody can see.  It is a
-//      standing disagreement: if any such candidate exists, nothing is grounded.
-//      It must NOT be quietly skipped, and that is not a stylistic point — the
-//      skip is what MANUFACTURES a fragment.  Measured on a one-deposit fixture
-//      whose form exceeds the cap: the query matched BOTH the whole 138-byte
-//      form (saturating) AND an interior fold node of 34 bytes (unsaturated,
-//      continuing `" Paris, an"`).  Skipping the saturated candidate removed the
-//      only evidence that disagreed, uniqueness then passed on the interior
-//      node, and a mid-form slice was voiced as an answer.  Suppressing the
-//      disagreement is what created the fabrication.
-//      (Testing instead whether a candidate is a "complete form" via the fold
-//      does NOT work and was measured: content addressing makes an interior
-//      node resolve to ITSELF, so self-resolution says nothing about
-//      completeness.)
-//   2. THE CONTINUATION MUST REACH ONE GROUPING WINDOW.  A trained
-//      `What is the capital of France??` opens with `What is the capital of
-//      France?` and continues by a single byte.  Below W the continuation is
-//      sub-quantum — the fold groups nothing from it — and voicing it produces
-//      the degenerate reply that is a known failure smell.
-//   3. UNIQUENESS.  Several trained forms may open with the query and continue
-//      differently, and then the corpus does not say which continuation the
-//      asker means.  Distinct continuations ⇒ refuse.  This is the documented
-//      PREFIX TRAP, and it is real — just not for every prefix.  Measured: of
-//      15 battery probes exactly ONE yields a unique continuation, and all
-//      three honest-silence probes yield none (including `What is the capital
-//      of Zamunda?`, whose top hit scores 0.83).
-//
-// 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 { 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.
- *
- *  `ranked` must be a list the caller has ALREADY fetched; this mechanism never
- *  resonates on its own (see the header's cost note). */
-export function prefixCompletion(ctx, query, ranked) {
-    const W = ctx.space.maxGroup;
-    const t = ctx.trace?.enter("prefixCompletion", [rItem(query, "query")]);
-    const done = (hit, note, data) => {
-        t?.done(hit === null ? [] : [rItem(hit.continuation, "continuation", hit.id)], note, data);
-        return hit;
-    };
-    // Reads are bounded to phrase scale, the same bound the frame filler uses.
-    // A query with no room for a whole grouping window past its own length
-    // cannot clear guard 2, so it is not worth a single read.
-    const cap = query.length * W;
-    if (query.length === 0 || cap < query.length + W) {
-        return done(null, "no room for a perceivable continuation within the cap");
-    }
-    // Distinct continuations, each with the first form that offered it.  Held as
-    // a list, not a byte-keyed map: candidates that open with the query are few
-    // (measured: 1 on the trained store's winning query), and a linear byte
-    // compare needs no string encoding of content.  Uniqueness (guard 3) is
-    // decided over this list, so the scan cannot stop early — a second
-    // continuation IS the refusal, and finding it is the point.
-    const found = [];
-    let opened = 0;
-    let unreadable = 0;
-    let subQuantum = 0;
-    for (const id of ranked) {
-        const form = ctx.store.bytesPrefix(id, cap);
-        if (form.length <= query.length)
-            continue;
-        let opens = true;
-        for (let i = 0; i < query.length; i++) {
-            if (form[i] !== query[i]) {
-                opens = false;
-                break;
-            }
-        }
-        if (!opens)
-            continue;
-        opened++;
-        // Guard 1: a saturated read continues out of sight — a disagreement that
-        // cannot be resolved, so it ends the search rather than being skipped.
-        if (form.length >= cap) {
-            unreadable++;
-            continue;
-        }
-        const rest = form.subarray(query.length);
-        // Guard 2: below one grouping window there is no structure to voice.
-        if (rest.length < W) {
-            subQuantum++;
-            continue;
-        }
-        if (!found.some((f) => bytesEqual(f.continuation, rest))) {
-            found.push({ id, form, continuation: rest });
-        }
-    }
-    const data = {
-        candidates: ranked.length,
-        opened,
-        unreadable,
-        subQuantum,
-        distinctContinuations: found.length,
-    };
-    if (unreadable > 0 && found.length > 0) {
-        return done(null, "a form opens with this query but continues past the read bound — " +
-            "its continuation cannot be read, so none is licensed", data);
-    }
-    // Guard 2b: A SUB-QUANTUM CONTINUATION IS STILL A DISAGREEMENT.  Guard 2
-    // refuses to VOICE a below-window continuation, and rightly — there is no
-    // structure there to speak.  But dropping such a candidate from the
-    // uniqueness tally silently converts "the corpus offers many continuations,
-    // most of them unvoiceable" into "the corpus offers exactly one", and
-    // guard 3 then passes VACUOUSLY on the sole survivor.  That is precisely
-    // the failure guard 1 documents for unreadable continuations — suppressing
-    // the disagreement is what manufactures the answer — so it is answered the
-    // same way, and for the same reason.
-    //
-    // Measured on a 4,300-fact fixture of "what is the value of <i>?": the
-    // query "what is the value of" drew candidates continuing " 0?", " 4?",
-    // " 8?" (3 bytes, sub-quantum at W=4) and " 10?" (4 bytes).  The first
-    // three were dropped, leaving one survivor, and the mechanism reported
-    // "exactly one trained form" and voiced "the value of 10 is 20" — an
-    // arbitrary pick from thousands of equally-good readings, with the
-    // evidence of ambiguity discarded on the way.
-    //
-    // Note this can only ever cause SILENCE, never a different answer: it
-    // withholds a completion the corpus does not uniquely license.
-    if (subQuantum > 0 && found.length > 0) {
-        return done(null, "other trained forms open with this query but continue below one " +
-            "grouping window — the corpus offers competing readings, so no " +
-            "single completion is licensed", data);
-    }
-    // Guard 3: the corpus must agree on ONE continuation.
-    if (found.length !== 1) {
-        return done(null, found.length === 0
-            ? "no trained form opens with this query and continues perceivably"
-            : "trained forms open with this query but continue differently — " +
-                "the corpus does not say which continuation is meant", data);
-    }
-    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.d.ts

@@ -1,16 +0,0 @@
-import type { MindContext } from "../types.js";
-import type { PipelineMechanism, Precomputed } from "../pipeline-mechanism.js";
-/** A recall result. */
-export interface RecallResult {
-    bytes: Uint8Array;
-    echoed: boolean;
-    accounted: Array<[number, number]>;
-    moves: number;
-    unexplained: string;
-    /** See {@link import("../pipeline-mechanism.js").MechanismResult.complete}
-     *  — set by the IDENTITY-bridge tier alone. */
-    complete?: boolean;
-}
-/** Recall the answer by resonating the whole query against the content index. */
-export declare function recallByResonance(ctx: MindContext, query: Uint8Array, pre: Precomputed): Promise<RecallResult | null>;
-export declare const recallMechanism: PipelineMechanism;