@hviana/sema 0.8.0 → 0.8.2

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

@@ -159,24 +159,22 @@ export async function recallByResonance(ctx, query, pre) {
             }
         }
     }
-    // The query-relative grounding fraction, shared by tiers 2–4 — gated on
-    // the FRACTION OF THE QUERY the grounding explains, not the raw cosine.
-    // Root gists are unit vectors, but their magnitudes are recoverable from
-    // the byte lengths (‖·‖ = √len under the linear fold):
-    // cos = shared/√(lenQ·lenG), so shared/lenQ = cos·√(lenG/lenQ).
-    // The raw cosine punished honest containment — a query fully inside a
-    // longer grounded answer scored √(lenQ/lenG) and was refused — and let a
-    // long answer sharing only scaffolding pass; the query-relative fraction
-    // measures exactly what the reach bar means: how much of THE QUERY the
-    // store accounts for.
-    // Chance similarity survives the length conversion AMPLIFIED: the same
-    // √(lenG/lenQ) factor that converts an honest shared fraction into a
-    // query-relative one multiplies the estimator/chance floor too, so a long
-    // stored form (√(lenG/lenQ) ≈ 10 at 100×) lifted a noise-level cosine past
-    // the reach bar and grounded pure gibberish (observed).  Only the
-    // ABOVE-CHANCE part of the similarity is evidence of shared content —
-    // subtract the significance bar (3/√D, §8.3) before converting.  Derived
-    // from the existing bars; never tuned.
+    // The query-relative grounding fraction, shared by tiers 2–4 — gated on the
+    // FRACTION OF THE QUERY the grounding explains, not the raw cosine. Root
+    // gists are unit vectors, but their magnitudes are recoverable from the byte
+    // lengths (‖·‖ = √len under the linear fold): cos = shared/√(lenQ·lenG), so
+    // shared/lenQ = cos·√(lenG/lenQ). The raw cosine punished honest containment
+    // — a query fully inside a longer grounded answer scored √(lenQ/lenG) and was
+    // refused — and let a long answer sharing only scaffolding pass; the
+    // query-relative fraction measures exactly what the reach bar means: how much
+    // of THE QUERY the store accounts for. Chance similarity survives the length
+    // conversion AMPLIFIED: the same √(lenG/lenQ) factor that converts an honest
+    // shared fraction into a query-relative one multiplies the estimator/chance
+    // floor too, so a long stored form (√(lenG/lenQ) ≈ 10 at 100×) lifted a
+    // noise-level cosine past the reach bar and grounded pure gibberish
+    // (observed). Only the ABOVE-CHANCE part of the similarity is evidence of
+    // shared content — subtract the significance bar (3/√D, thresholds.md) before
+    // converting. Derived from the existing bars; never tuned.
     const sig = significanceBar(ctx.store.D);
     const reach = reachThreshold(ctx.space.maxGroup);
     const fracOfQuery = (cos, otherLen) => Math.min(1, Math.max(0, cos - sig) *
@@ -305,14 +303,14 @@ export async function recallByResonance(ctx, query, pre) {
             }
         }
     }
-    // 3b. Corroborated-substitution bridge — refusal-path only (bridge.ts).
-    // The bridge's proposal source is the response's ONE top-k read — the same
-    // list recall already ranked above — never an exhaustive √N scan.  The
-    // bridge's own candidate cap is 2·recallQueryK, so top-k proposals are
-    // exactly the budget it can consume, and every proposal is byte-verified
-    // downstream (§2.3).  Reuse the memoised `resonance()`; scanning every IVF
-    // cluster here once made every honest refusal cost hundreds of ms regardless
-    // of k.
+    // 3b. Corroborated-substitution bridge — refusal-path only (bridge.ts). The
+    // bridge's proposal source is the response's ONE top-k read — the same list
+    // recall already ranked above — never an exhaustive √N scan. The bridge's own
+    // candidate cap is 2·recallQueryK, so top-k proposals are exactly the budget
+    // it can consume, and every proposal is byte-verified downstream
+    // (exact-vs-approximate.md). Reuse the memoised `resonance()`; scanning every
+    // IVF cluster here once made every honest refusal cost hundreds of ms
+    // regardless of k.
     const wideIds = async () => (await pre.resonance()).map((h) => h.id);
     // Every gist-based tier has failed; before refusing, align the query
     // byte-for-byte against the trained contexts its own stored windows
@@ -362,12 +360,12 @@ export async function recallByResonance(ctx, query, pre) {
             // prefixCompletion runs a few lines below and carries the three guards
             // this tier lacks — unreadable-continuation veto, sub-quantum
             // continuation, and UNIQUENESS (distinct continuations ⇒ refuse), which
-            // is exactly what 4,300 competing values must trip.  So this is not a
-            // new rule and not a new threshold: it is deferring a prefix decision to
-            // the tier that owns it (§2.5, one factored machinery).  Byte-strict on
-            // purpose — a candidate differing by case or punctuation ("what is the
-            // capital of france" → "What is the capital of France?") is NOT a byte
-            // prefix, keeps grounding here, and is unaffected.
+            // is exactly what 4,300 competing values must trip. So this is not a new
+            // rule and not a new threshold: it is deferring a prefix decision to the
+            // tier that owns it (match-project.md, one factored machinery).
+            // Byte-strict on purpose — a candidate differing by case or punctuation
+            // ("what is the capital of france" → "What is the capital of France?") is
+            // NOT a byte prefix, keeps grounding here, and is unaffected.
             const strictPrefix = g !== null &&
                 cBytes.length > query.length &&
                 indexOf(cBytes, query, 0) === 0;
@@ -425,15 +423,15 @@ export async function recallByResonance(ctx, query, pre) {
             }
         }
     }
-    // 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
+    // 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
     // decisions are never made on an estimated score ("approximate scores may
-    // rank and propose; they may never decide", §6.2): the RaBitQ estimate
-    // overshooting the reach bar echoed a WRONG-entity neighbour ("capital of
-    // Zamunda?" echoed the Armenia fact, observed).  The bytes are read
-    // anyway to be echoed, so the decision uses their EXACT fold: one river
-    // fold of the top hit, measured in the same query-relative,
-    // chance-corrected units as the tier above.
+    // rank and propose; they may never decide", exact-vs-approximate.md): the
+    // RaBitQ estimate overshooting the reach bar echoed a WRONG-entity neighbour
+    // ("capital of Zamunda?" echoed the Armenia fact, observed). The bytes are
+    // read anyway to be echoed, so the decision uses their EXACT fold: one river
+    // fold of the top hit, measured in the same query-relative, chance-corrected
+    // units as the tier above.
     const topBytes = read(ctx, top.id);
     const exact = topBytes.length > 0
         ? cosine(queryGist, gistOf(ctx, topBytes))

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

@@ -2,8 +2,8 @@
 // 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:
+// pipeline of its own. The three parts it configures live where
+// match-project.md 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
@@ -29,10 +29,10 @@
 // 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
+// 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.
+// population for the other is the error commonality.md names. The notion is
+// made AVAILABLE, never imposed.
 import { carriesFillers, distinct, follow, substituteAll } from "../match.js";
 import { dominates } from "../../geometry.js";
 import { bytesEqual, indexOf } from "../../bytes.js";
@@ -43,16 +43,16 @@ import { rItem, rNode, traceFail } from "../trace.js";
  *  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). */
+ *  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 (INVARIANTS.md). */
 const MIN_INSTANCES = 2;
 /** THE VOICING GATES — this mechanism's own reading of a pairing, applied here
  *  and NOT in the shared matcher.
@@ -123,7 +123,7 @@ function electFrame(inventory, W, queryLen) {
     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).
+        // corpus-determined, like every other tie-break here (determinism.md).
         if (group.length > best.length)
             best = group;
     }

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

@@ -1,5 +1,6 @@
 import { Vec } from "../vec.js";
 import { Sema, Space } from "../sema.js";
+import type { CorpusResult } from "./corpus.js";
 import { Alphabet } from "../alphabet.js";
 import { Grid } from "../geometry.js";
 import { BoundedMap, type Store } from "../store.js";
@@ -49,10 +50,40 @@ import type { AttentionRead, MindContext, Recognition } from "./types.js";
 export type { AnchorRejectionReason, ClimbConsensusData, ConsensusAnchorTrace, ConsensusReachTrace, ConsensusRegionTrace, CrossRegionTier, JunctionVoteTrace, RegionOutcome, } from "./attention.js";
 export type { AncestorReach, SaturationReason, SaturationStop, } from "./types.js";
 import { type CostReport, Meter } from "../meter.js";
+/** A stored pair as TEXT — the text helper's view of {@link CorpusPair}. */
+export interface CorpusTextPair {
+    context: string;
+    continuation: string;
+    contextId: number;
+    continuationId: number;
+    matchedBytes: number;
+    contextTruncated: boolean;
+    continuationTruncated: boolean;
+}
+/** {@link CorpusResult} as text, plus the prose for why nothing matched.  The
+ *  byte layer reports a STATE; saying it in words belongs to the text layer. */
+export interface CorpusTextResult {
+    query: string;
+    pairs: CorpusTextPair[];
+    resolved: number;
+    reached: number;
+    totalContexts: number;
+    browsed: boolean;
+    note?: string;
+}
 export interface MindOptions {
     seed?: number;
     recallQueryK?: number;
     haloQueryK?: number;
+    /** Items one rationale step may itemise — see {@link MindConfig}. */
+    rationaleSampleK?: number;
+    /** Corpus-reading capacities and budgets — see {@link MindConfig}. */
+    corpusLimitMax?: number;
+    corpusClimbs?: number;
+    corpusContextsPerClimb?: number;
+    corpusSampleProbes?: number;
+    corpusPreviewBytes?: number;
+    corpusSampleFloorBytes?: number;
     normalizeEpsilon?: number;
     cosineEpsilon?: number;
     geometry?: Partial<import("../config.js").GeometryConfig>;
@@ -64,13 +95,12 @@ export interface MindOptions {
     /** Factories that receive the {@link ExtensionHost} and return mechanisms. */
     mechanismFactories?: ((host: import("../extension.js").ExtensionHost) => import("./pipeline-mechanism.js").PipelineMechanism)[];
     /** Measure the computational usage of every inference call — see
-     *  src/meter.ts.  Off by default and free when off (one null check per
-     *  store read); on, each `respond`/`respondTurn` leaves a {@link
-     *  Mind.lastCost} report behind.  Counters are deterministic, so two runs
-     *  of the same query on the same store are diffable; the millisecond
-     *  fields are not.  Profiling NEVER changes an answer — but note that
-     *  attaching a RATIONALE does (traced responses bypass the ctx memos,
-     *  AGENTS §2.11), so profile without a trace. */
+     *  src/meter.ts. Off by default and free when off (one null check per store
+     * read); on, each `respond`/`respondTurn` leaves a {@link Mind.lastCost}
+     * report behind. Counters are deterministic, so two runs of the same query on
+     * the same store are diffable; the millisecond fields are not. Profiling
+     * NEVER changes an answer — but attaching a RATIONALE does: a traced response
+     * bypasses the ctx memos (memoization.md), so profile without a trace. */
     profile?: boolean;
     /** Content canonicalizer applied to EVERY response (any modality) for
      *  equivalence-class resolution — see src/canon.ts.  Text entry points
@@ -154,6 +184,10 @@ export declare class Mind implements MindContext {
      *  `traverse.ts`'s ONE definition (edge or halo, with its response-scoped
      *  cache).  The search holds a bare Store and cannot reach that cache itself,
      *  so it asks through this hook; a bare host keeps its raw-store fallback. */
+    /** The canonical identity for the search (see GraphSearchHost). */
+    canonResolve(bytes: Uint8Array): number | null;
+    /** Feed a search refusal into the rationale (see GraphSearchHost). */
+    reportSearch(name: string, parts: ReadonlyArray<Uint8Array>, note: string): void;
     leadsSomewhere(id: number): boolean;
     recogniseSpan(bytes: Uint8Array): {
         sites: ReadonlyArray<Site>;
@@ -168,6 +202,8 @@ export declare class Mind implements MindContext {
      *  with the most distributional evidence (highest `prevOf` count — the
      *  structural manifestation of its halo).  When evidence is equal the
      *  first-inserted edge wins. */
+    /** See {@link GraphSearchHost.contentCuts}. */
+    contentCuts(bytes: Uint8Array): readonly number[];
     chooseNext(node: number): number | undefined;
     constructor(opts?: MindOptions);
     constructor(cfg: MindConfig, store: Store, _fromStore: true);
@@ -250,6 +286,24 @@ export declare class Mind implements MindContext {
      *  as one form, provided the store's canon index is built
      *  ({@link buildCanonIndex}). */
     respondText(input: string, inspectRationale?: InspectRationale): Promise<string>;
+    /** Which stored notes does this query REACH?  BYTES in, BYTES out — this
+     *  method has no notion of text or encoding; the text case is
+     *  {@link searchCorpusText}, which is one caller of this.
+     *
+     *  Exact content addressing through the machinery an answer already uses
+     *  (see src/mind/corpus.ts): the query's recognised sites are the resolved
+     *  subtrees, the climb goes up from the biggest, and a result is a context
+     *  that carries a learnt continuation.  Nothing is written and nothing is
+     *  indexed. */
+    searchCorpus(queryBytes: Uint8Array, limit?: number): CorpusResult;
+    /** Browse real pairs.  Deterministic: `from` is the caller's own offset in
+     *  [0,1), so browsing twice with different offsets shows different notes
+     *  without a random draw. */
+    sampleCorpus(limit?: number, from?: number): CorpusResult;
+    /** The TEXT case of {@link searchCorpus}: encode, search, decode.  The search
+     *  itself exists once, in the byte layer above; only the rendering lives
+     *  here, with the rest of this class's text modality. */
+    searchCorpusText(query: string, limit?: number): CorpusTextResult;
     /** Begin a new conversation, optionally restoring from a previously-saved
      *  {@link ConversationState}.  The returned handle is required for
      *  {@link respondTurn} and {@link endConversation}.

package/dist/src/mind/mind.js

@@ -9,8 +9,9 @@
 // Architecture: 4 primitives × 2 patterns = all inference.
 // Implementation split across src/mind/*.ts — this file assembles the Mind class.
 import { makeKeyring, rng, setVecConfig } from "../vec.js";
+import { sampleCorpus, searchCorpus } from "./corpus.js";
 import { Alphabet } from "../alphabet.js";
-import { contentFoldIncremental, reachThreshold, } from "../geometry.js";
+import { contentBoundaries, contentFoldIncremental, reachThreshold, } from "../geometry.js";
 import { BoundedMap } from "../store.js";
 import { SQliteStore } from "../store-sqlite.js";
 import { resolveConfig } from "../config.js";
@@ -19,7 +20,7 @@ import { bytesEqual, concat2 } from "../bytes.js";
 import { GraphSearch, } from "./graph-search.js";
 import { Alu } from "../alu/src/index.js";
 import { decodeText, Rationale, } from "./rationale.js";
-import { gistOf, inputBytes, perceive as perceiveImpl, perceiveKey, resolve as resolveImpl, } from "./primitives.js";
+import { canonResolve as canonResolveImpl, gistOf, inputBytes, perceive as perceiveImpl, perceiveKey, resolve as resolveImpl, } from "./primitives.js";
 import { chooseNext, edgeAncestors as edgeAncestorsFn, invalidateStructuralCaches, leadsSomewhere, } from "./traverse.js";
 import { invalidateJunctionCache } from "./junction.js";
 import { follow } from "./match.js";
@@ -33,6 +34,21 @@ import { rItem } from "./trace.js";
 // The work meter is exported from src/index.ts (via src/meter.ts) — the one
 // definition; the Mind only consumes it.
 import { Meter } from "../meter.js";
+/** What the text helper says when the byte layer reports a miss. */
+const CORPUS_NOTE = {
+    "nothing-resolved": "No trained note sits above the parts of that text the mind recognised. " +
+        "It addresses content exactly, so try wording closer to something it was " +
+        "actually given — or browse the examples instead.",
+    "no-continuations": "That text reaches stored nodes, but none of them carries a learnt " +
+        "continuation.",
+};
+/** UTF-8 of bytes for display: reuse {@link decodeText} (the mind's own text
+ *  conversion), then drop the replacement character a byte-boundary cut leaves
+ *  behind.  Much of a real corpus is non-Latin, so that trailing U+FFFD is the
+ *  common case, not an exotic one — and it is the ONLY thing added here. */
+function previewCorpusText(bytes) {
+    return decodeText(bytes).replace(/\uFFFD+$/, "").replace(/\s+/g, " ").trim();
+}
 // ═══════════════════════════════════════════════════════════════════════════
 // THE MIND
 // ═══════════════════════════════════════════════════════════════════════════
@@ -116,6 +132,14 @@ export class Mind {
      *  `traverse.ts`'s ONE definition (edge or halo, with its response-scoped
      *  cache).  The search holds a bare Store and cannot reach that cache itself,
      *  so it asks through this hook; a bare host keeps its raw-store fallback. */
+    /** The canonical identity for the search (see GraphSearchHost). */
+    canonResolve(bytes) {
+        return canonResolveImpl(this, bytes);
+    }
+    /** Feed a search refusal into the rationale (see GraphSearchHost). */
+    reportSearch(name, parts, note) {
+        this.trace?.step(name, parts.map((b) => rItem(b)), [], note);
+    }
     leadsSomewhere(id) {
         return leadsSomewhere(this, id);
     }
@@ -136,6 +160,10 @@ export class Mind {
      *  with the most distributional evidence (highest `prevOf` count — the
      *  structural manifestation of its halo).  When evidence is equal the
      *  first-inserted edge wins. */
+    /** See {@link GraphSearchHost.contentCuts}. */
+    contentCuts(bytes) {
+        return contentBoundaries(this.space, bytes);
+    }
     chooseNext(node) {
         return chooseNext(this, node, this._edgeGuide);
     }
@@ -411,6 +439,48 @@ export class Mind {
         const r = await this.respond(input, inspectRationale);
         return decodeText(r.bytes);
     }
+    // ── Reading the trained memory back ─────────────────────────────────────
+    /** Which stored notes does this query REACH?  BYTES in, BYTES out — this
+     *  method has no notion of text or encoding; the text case is
+     *  {@link searchCorpusText}, which is one caller of this.
+     *
+     *  Exact content addressing through the machinery an answer already uses
+     *  (see src/mind/corpus.ts): the query's recognised sites are the resolved
+     *  subtrees, the climb goes up from the biggest, and a result is a context
+     *  that carries a learnt continuation.  Nothing is written and nothing is
+     *  indexed. */
+    searchCorpus(queryBytes, limit) {
+        return searchCorpus(this, queryBytes, limit);
+    }
+    /** Browse real pairs.  Deterministic: `from` is the caller's own offset in
+     *  [0,1), so browsing twice with different offsets shows different notes
+     *  without a random draw. */
+    sampleCorpus(limit, from) {
+        return sampleCorpus(this, limit, from);
+    }
+    /** The TEXT case of {@link searchCorpus}: encode, search, decode.  The search
+     *  itself exists once, in the byte layer above; only the rendering lives
+     *  here, with the rest of this class's text modality. */
+    searchCorpusText(query, limit) {
+        const result = this.searchCorpus(new TextEncoder().encode(query), limit);
+        return {
+            query,
+            pairs: result.pairs.map((p) => ({
+                context: previewCorpusText(p.context),
+                continuation: previewCorpusText(p.continuation),
+                contextId: p.contextId,
+                continuationId: p.continuationId,
+                matchedBytes: p.matchedBytes,
+                contextTruncated: p.contextTruncated,
+                continuationTruncated: p.continuationTruncated,
+            })),
+            resolved: result.resolved,
+            reached: result.reached,
+            totalContexts: result.totalContexts,
+            browsed: result.browsed,
+            note: result.miss === "matched" ? undefined : CORPUS_NOTE[result.miss],
+        };
+    }
     // ── Conversation API ────────────────────────────────────────────────────
     /** Begin a new conversation, optionally restoring from a previously-saved
      *  {@link ConversationState}.  The returned handle is required for

package/dist/src/mind/pipeline-mechanism.d.ts

@@ -69,14 +69,16 @@ export declare class Precomputed {
      *  ({@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.
+     * 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 (mechanism-market.md) broken from inside the shared
+     * container, and the population error commonality.md 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

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

@@ -5,7 +5,7 @@
 // a list of PipelineMechanism objects — it never imports a mechanism-specific
 // type and never has a special-case branch for any mechanism.
 //
-// The four constraints of the free-will architecture (§14.5):
+// The four constraints of the free-will architecture (mechanism-market.md):
 //   1. DECOUPLING — mechanisms import nothing from each other or from pipeline.
 //   2. DECLARED COMPETENCE — floor() returns null when impossible, a number when
 //      possible.  Binary, auditable, no learned scores.
@@ -128,31 +128,33 @@ export class Precomputed {
     resonance() {
         return this._resonance ??= this.shared("resonance", () => this.ctx.store.resonate(this.guide, this.k));
     }
-    // REMOVED — the WIDE exhaustive-√N resonance list (`wideResonance`).  It ran
+    // REMOVED — the WIDE exhaustive-√N resonance list (`wideResonance`). It ran
     // `resonate(guide, √N, exhaustive=true)` whenever the top hit cleared
-    // conceptThreshold, so consumers could look "past the top-k".  Every consumer
+    // conceptThreshold, so consumers could look "past the top-k". Every consumer
     // only ever needed ≤ 2·recallQueryK proposals (the substitution bridge's own
     // candidate cap) or a content-addressed answer (prefix completion's
-    // formsOpenedBy), and every proposal is byte-verified downstream (§2.3), so
-    // the exhaustive scan bought recall at O(index) cost for an O(k) need —
-    // measured: 244K annVectorReads per refusing query, ~1.5 s, every answer
-    // byte-identical to a top-k read.  The two consumers now read `resonance()`
-    // (the one top-k read) and the write side's window index respectively — see
-    // recall.ts and prefix-completion.ts.
+    // formsOpenedBy), and every proposal is byte-verified downstream
+    // (exact-vs-approximate.md), so the exhaustive scan bought recall at O(index)
+    // cost for an O(k) need — measured: 244K annVectorReads per refusing query,
+    // ~1.5 s, every answer byte-identical to a top-k read. The two consumers now
+    // read `resonance()` (the one top-k read) and the write side's window index
+    // respectively — see recall.ts and prefix-completion.ts.
     _frames;
     /** 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.
+     * 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 (mechanism-market.md) broken from inside the shared
+     * container, and the population error commonality.md 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
@@ -168,9 +170,10 @@ export class Precomputed {
             const capBytes = this.query.length * W;
             const out = [];
             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.
+                // REJECT BY LENGTH BEFORE RECONSTRUCTING (bounded-reads.md):
+                // `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
@@ -458,7 +461,8 @@ function computeWeave(ctx, query, pre, climb) {
     // IDF — gates the aligner has no equivalent of.
     //
     // So the climb PROPOSES the pairing (which structure, which query span) and
-    // bytes DECIDE its terms (§2.3).  Three gates, each one measured:
+    // bytes DECIDE its terms (exact-vs-approximate.md). Three gates, each one
+    // measured:
     //
     //   • it may only take query bytes NO literal run claimed.  Run inline with
     //     phase 1 this did the opposite of "exact decides" — a higher-ranked

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

@@ -38,15 +38,15 @@ export interface NarrowDecisionData {
     margin: number;
 }
 /** Structured payload of the "regimePrediction" rationale step — the R8
- *  observation exposed as data.  After the first mechanism (cover, which §2.6
- *  runs first) grounds or abstains, the market's whole outcome is already
- *  determined by the one cost ladder: the consensus climb runs exactly when
- *  `worthRunning(2 * STEP)` is true — CAST (floor 2·STEP) is the cheapest
- *  mechanism that first-touches it, and confluence (3·STEP) / extraction
- *  (CONCEPT+STEP) are only reached after CAST is.  An incumbent at or below
- *  that floor prunes CAST and, with it, the climb (retrieval); anything above
- *  — or no incumbent — runs the full market and the climb (composition).
- *  Purely observational; never read by inference. */
+ *  observation exposed as data. After the first mechanism (cover, which
+ * mechanism-market.md runs first) grounds or abstains, the market's whole
+ * outcome is already determined by the one cost ladder: the consensus climb
+ * runs exactly when `worthRunning(2 * STEP)` is true — CAST (floor 2·STEP) is
+ * the cheapest mechanism that first-touches it, and confluence (3·STEP) /
+ * extraction (CONCEPT+STEP) are only reached after CAST is. An incumbent at or
+ * below that floor prunes CAST and, with it, the climb (retrieval); anything
+ * above — or no incumbent — runs the full market and the climb (composition).
+ * Purely observational; never read by inference. */
 export interface RegimePredictionData {
     version: 1;
     /** retrieval | composition — the two regimes R1 measured as a ~100× cost