@hviana/sema 0.8.0 → 0.8.2

package/src/mind/mechanisms/reference.ts

@@ -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 type { MindContext } from "../types.js";
 import type { FrameInstance } from "../match.js";
@@ -52,16 +52,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
@@ -135,7 +135,7 @@ function electFrame(
   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).
+    // corpus-determined, like every other tie-break here (determinism.md).
     if (group.length > best.length) best = group;
   }
   return best;

package/src/mind/mind.ts

@@ -11,9 +11,12 @@
 
 import { cosine, makeKeyring, rng, setVecConfig, Vec } from "../vec.js";
 import { bindSeat, fold, Sema, Space } from "../sema.js";
+import { sampleCorpus, searchCorpus } from "./corpus.js";
+import type { CorpusPair, CorpusResult } from "./corpus.js";
 import { Alphabet } from "../alphabet.js";
 import {
   bytesToTree,
+  contentBoundaries,
   contentFoldIncremental,
   Grid,
   gridToTree,
@@ -146,6 +149,7 @@ interface ConversationData {
 import type { AttentionRead, MindContext, Recognition } from "./types.js";
 import { changedNodes, liftAnswer, spliceAll } from "./types.js";
 import {
+  canonResolve as canonResolveImpl,
   foldTree,
   gistOf,
   inputBytes,
@@ -194,10 +198,61 @@ import { type CostReport, Meter } from "../meter.js";
 
 // ── MindOptions ───────────────────────────────────────────────────────────
 
+/** 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;
+}
+
+/** What the text helper says when the byte layer reports a miss. */
+const CORPUS_NOTE: Record<string, string> = {
+  "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: Uint8Array): string {
+  return decodeText(bytes).replace(/\uFFFD+$/, "").replace(/\s+/g, " ").trim();
+}
+
 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>;
@@ -211,13 +266,12 @@ export interface MindOptions {
     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
@@ -348,6 +402,20 @@ export 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 {
+    return canonResolveImpl(this, bytes);
+  }
+
+  /** Feed a search refusal into the rationale (see GraphSearchHost). */
+  reportSearch(
+    name: string,
+    parts: ReadonlyArray<Uint8Array>,
+    note: string,
+  ): void {
+    this.trace?.step(name, parts.map((b) => rItem(b)), [], note);
+  }
+
   leadsSomewhere(id: number): boolean {
     return leadsSomewhere(this, id);
   }
@@ -375,6 +443,11 @@ export 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[] {
+    return contentBoundaries(this.space, bytes);
+  }
+
   chooseNext(node: number): number | undefined {
     return chooseNext(this, node, this._edgeGuide);
   }
@@ -738,6 +811,55 @@ export class Mind implements MindContext {
     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: Uint8Array, limit?: number): CorpusResult {
+    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?: number, from?: number): CorpusResult {
+    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: string, limit?: number): CorpusTextResult {
+    const result = this.searchCorpus(
+      new TextEncoder().encode(query),
+      limit,
+    );
+    return {
+      query,
+      pairs: result.pairs.map((p: CorpusPair): CorpusTextPair => ({
+        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

package/src/mind/pipeline-mechanism.ts

@@ -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.
@@ -148,17 +148,17 @@ export class Precomputed {
     );
   }
 
-  // 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.
 
   private _frames?: Promise<ReadonlyArray<FrameInstance>>;
   /** THE FRAME INVENTORY — every ranked candidate that reads as an instance of
@@ -166,14 +166,16 @@ export 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
@@ -189,9 +191,10 @@ export class Precomputed {
       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.
+        // 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
@@ -519,7 +522,8 @@ function computeWeave(
   // 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/src/mind/pipeline.ts

@@ -130,15 +130,15 @@ export interface NarrowDecisionData {
 }
 
 /** 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
@@ -187,13 +187,13 @@ export async function think(
   // ── Pre-computation ──────────────────────────────────────────────────
   const mechanisms = mechs ?? defaultMechanisms;
   const meter = ctx.meter;
-  // recognition is a shared analysis (§2.14 contract 5): it does the query's
+  // recognition is a shared analysis (meter.md contract 5): it does the query's
   // own store work (perceive → foldTree → resolve), which used to land in
   // `think` and in nothing narrower — the meter's one accounting surface must
   // charge it to itself, exactly as attention/weave/resonance are charged.
-  // SYNCHRONOUS phase: recognition is on the sync side of §2.10's seam, so it
-  // is timed with `timeSync` — wrapping it in a promise would make a profiled
-  // response await where an unprofiled one does not.
+  // SYNCHRONOUS phase: recognition is on the sync side of meter.md's seam, so
+  // it is timed with `timeSync` — wrapping it in a promise would make a
+  // profiled response await where an unprofiled one does not.
   const rec = meter
     ? meter.timeSync("recognise", () => recognise(ctx, query))
     : recognise(ctx, query);
@@ -225,15 +225,15 @@ export async function think(
     }
   }
 
-  // Phase 2: the shared pre-computation container.  Eager fields only
-  // (recognition, computed spans, guide) — every expensive analysis
-  // (consensus climb, weave, span-shape classification) is a lazily-cached
-  // method on Precomputed, first-touched by whichever mechanism's floor
-  // survives its cheap gates and the worthRunning check.  A query no
-  // mechanism climbs for (e.g. one an extension decided) never climbs.
-  // NOT phased: the constructor itself is trivial (it only derives `k`), so a
-  // phase here would add a zero-work entry to every profiled report — the meter
-  // attributes WORK (§2.14); the trace already represents structure.
+  // Phase 2: the shared pre-computation container. Eager fields only
+  // (recognition, computed spans, guide) — every expensive analysis (consensus
+  // climb, weave, span-shape classification) is a lazily-cached method on
+  // Precomputed, first-touched by whichever mechanism's floor survives its
+  // cheap gates and the worthRunning check. A query no mechanism climbs for
+  // (e.g. one an extension decided) never climbs. NOT phased: the constructor
+  // itself is trivial (it only derives `k`), so a phase here would add a
+  // zero-work entry to every profiled report — the meter attributes WORK
+  // (meter.md); the trace already represents structure.
   const pre = new Precomputed(ctx, query, rec, computed, ctx._edgeGuide);
 
   // ── Grounding: ONE lightest-derivation choice among the mechanisms ────
@@ -298,16 +298,17 @@ export async function think(
   const worthRunning = (floor: number) =>
     best === null || grade(floor) < grade(best.weight);
 
-  // REGIME PREDICTION (R8) — observational only.  Once the FIRST mechanism has
-  // had its turn (cover, which §2.6 places first and floors at 0), the market's
-  // 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, so an incumbent at or below
-  // grade 2 prunes CAST and, with it, confluence (3·STEP) and extraction
-  // (CONCEPT+STEP) (retrieval); anything above — or no incumbent — runs the
-  // full market and the climb (composition).  The predicate is `worthRunning`,
-  // the same function the loop itself uses — nothing is computed here that the
-  // engine had not already computed, and nothing is read back by inference.
+  // REGIME PREDICTION (R8) — observational only. Once the FIRST mechanism has
+  // had its turn (cover, which mechanism-market.md places first and floors at
+  // 0), the market's 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, so an
+  // incumbent at or below grade 2 prunes CAST and, with it, confluence (3·STEP)
+  // and extraction (CONCEPT+STEP) (retrieval); anything above — or no incumbent
+  // — runs the full market and the climb (composition). The predicate is
+  // `worthRunning`, the same function the loop itself uses — nothing is
+  // computed here that the engine had not already computed, and nothing is read
+  // back by inference.
   //
   // EMITTED BEFORE THE SECOND MECHANISM'S FLOOR, never after some mechanism's
   // run: a "prediction" published after the fact could assert "the climb will
@@ -544,12 +545,40 @@ export async function think(
       ctx.store.nextFirst(id, hubBound(ctx)).map((n) => read(ctx, n))
     )
     : [];
+  // REPORTABLE, NOT SILENT.  A declared-complete grounding ends the derivation
+  // here, and that decision is part of the derivation's shape: the reader of a
+  // rationale must be able to see that the chain stopped because the mechanism
+  // claimed the query WAS the context, not because nothing followed.  The step
+  // carries the claim, not a re-description of the answer — the extension is
+  // skipped, so there is no output item to show.
+  if (decided.complete) {
+    ctx.trace?.step(
+      "completeGrounding",
+      [rItem(answer, provenance)],
+      [],
+      "grounding declared complete — the query IS the context, so " +
+        "post-grounding extension is skipped",
+    );
+  }
+  // THE REASONER JUDGES ITS OWN EXTENSIONS BY THE PIPELINE'S REMAINDER, not by
+  // the ladder's `accounted` — and by the SAME reading the fuse gate below uses,
+  // with the same W floor.  `accounted` is a COST quantity (measured: a query
+  // fully explained by one computed span plus bridged connectors reports
+  // `accounted: []` while nothing is unexplained), and a remainder under one
+  // river-fold quantum is bridging punctuation, never a second topic — so it
+  // licenses no extension and blocks none.
+  const explained: Array<[number, number]> = [
+    ...decided.accounted,
+    ...pre.computed.map((u): [number, number] => [u.i, u.j]),
+  ];
+  const uncovered = unexplainedSpans(query.length, explained)
+    .filter(([a, b]) => b - a >= ctx.space.maxGroup);
   const reasoned = decided.complete ? answer : meter
     ? await meter.time(
       "reason",
-      () => reason(ctx, query, answer, preConsumed, pre, voiced),
+      () => reason(ctx, query, answer, preConsumed, pre, voiced, uncovered),
     )
-    : await reason(ctx, query, answer, preConsumed, pre, voiced);
+    : await reason(ctx, query, answer, preConsumed, pre, voiced, uncovered);
 
   // Fuse only when the query has a genuine REMAINDER no mechanism's
   // structural evidence touched at all.  `decided.accounted` alone
@@ -567,10 +596,6 @@ export async function think(
   // observed: a single space between two fully-computed arithmetic spans
   // ("2+2 3+3") registered as "unaccounted" and pulled in an unrelated
   // corpus fact, corrupting "4 6" into "4 63".
-  const explained: Array<[number, number]> = [
-    ...decided.accounted,
-    ...pre.computed.map((u): [number, number] => [u.i, u.j]),
-  ];
   const remainder = unaccounted(explained);
   // Whether the winning candidate's entire recognised substance is
   // COMPUTED — every accounted span exactly a pre.computed span, nothing

package/src/mind/primitives.ts

@@ -59,11 +59,11 @@ export function perceiveKey(
 /** Perceive input into a content-defined tree (the river fold).
  *  Deterministic — identical bytes always produce an identical tree.
  *
- *  `boundaries` is an optional sorted list of proper byte offsets where the
- *  fold must split so that each prefix segment folds identically to how it
- *  folded when it was learned (§10.3 stable-prefix contract).  Only the
- *  CALLER — who assembled the multi-turn context — knows where those
- *  boundaries are; the geometry never guesses them from the bytes. */
+ * `boundaries` is an optional sorted list of proper byte offsets where the fold
+ * must split so that each prefix segment folds identically to how it folded
+ * when it was learned (fold-contract.md stable-prefix contract). Only the
+ * CALLER — who assembled the multi-turn context — knows where those boundaries
+ * are; the geometry never guesses them from the bytes. */
 export function perceive(
   ctx: MindContext,
   input: Input,

package/src/mind/reasoning.ts

@@ -43,6 +43,10 @@ export async function reason(
   preConsumed: ReadonlySet<number>,
   pre: Precomputed,
   voiced: readonly Uint8Array[] = [],
+  /** The query material the GROUNDING left uncovered — the cost ladder's own
+   *  `unaccounted` spans.  Only the reasoner's OWN extensions are judged
+   *  against it; a mechanism carrying its own `used` set owns its shape. */
+  uncovered: readonly (readonly [number, number])[] = [],
 ): Promise<Uint8Array> {
   // Echo guard: a query that is ITSELF a learnt continuation (some context's
   // answer) is being asked back at the system — hopping forward from it would
@@ -200,6 +204,57 @@ export async function reason(
     const fc = await follow(ctx, pivot, qv);
     consumeAll(pivot);
     if (fc === null || bytesEqual(fc, cur) || restatesQuery(query, fc)) break;
+    // WHOSE EXTENSION IS THIS?
+    //
+    // `voiced` is what the mechanism WITHHELD (the pipeline sends the used
+    // anchors' CONTINUATIONS, not their bytes — see pipeline's own note), so a
+    // non-empty `voiced` means exactly what that note says: the grounding came
+    // from a mechanism that carries its own short `used` set (cast/join) and
+    // therefore owns the shape of its answer.  The further terms inside such a
+    // seat are legitimately followable — test/29 C3's `Mona Lisa` lives inside
+    // the voiced seat and leads on to a fact about neither analog.
+    //
+    // Every other grounding is ordinary, and an extension of it is the
+    // reasoner's own inference: it is taken only while question material the
+    // grounding left uncovered remains AND the step carries some of it, judged
+    // by the mind's own line between chance and evidence — one W-byte window,
+    // no word notion, no character class, no threshold.  Measured: the drift's
+    // second step (`the Eiffel Tower is in Paris` after `Paris is famous for
+    // the Eiffel Tower`) carries no window of `" famous for"` and is refused,
+    // while the first carries it.  Terminates by a real argument: the uncovered
+    // material is finite and each taken extension must carry some of it.
+    const producerOwnsShape = voiced.length > 0;
+    if (!producerOwnsShape && uncovered.length > 0) {
+      const W = ctx.space.maxGroup;
+      let progress = false;
+      for (const [a, b] of uncovered) {
+        for (let i = a; i + W <= b && !progress; i++) {
+          if (indexOf(fc, query.subarray(i, i + W), 0) >= 0) progress = true;
+        }
+        if (progress) break;
+      }
+      if (!progress) {
+        // THE BRAKE, MADE VISIBLE.  The reasoner declines a step that carries
+        // none of the material the grounding left uncovered — the drift the
+        // extension tests pin.  A refusal that leaves no trace is the kind of
+        // silent cut AGENTS §6 forbids: the rationale is where a reader learns
+        // that an extension was declined for want of question material, and
+        // where the next person sees why the chain stopped here.  Measured with
+        // the check disabled, test/110 and test/116 fail — so this brake is the
+        // only thing keeping the extension honest until the pivot reports its
+        // own accounted spans and the ladder can judge it instead.
+        const left = uncovered.reduce((n, [a, b]) => n + (b - a), 0);
+        ctx.trace?.step(
+          "pivotRefused",
+          [rItem(cur, "answer"), rItem(query, "query")],
+          uncovered.map(([a, b]) => rItem(query.subarray(a, b), "uncovered")),
+          `the step carries none of the question material the grounding left ` +
+            `uncovered (${left} byte(s) in ${uncovered.length} span(s)) — refused`,
+        );
+        break;
+      }
+    }
+    if (ctx.meter) ctx.meter.pivotSteps++;
     t ??= ctx.trace?.enter("reason", [rItem(startedFrom, "grounded")]);
     ctx.trace?.step(
       "pivotStep",

package/src/mind/recognition.ts

@@ -34,19 +34,20 @@ import type { Leaf, Site } from "./graph-search.js";
  *
  *  Both O(n · maxGroup) bounded O(1) probes — never a scan of the corpus.
  *
- *  ONE READING PER BYTE STREAM, deliberately: there is no "cheap mode" that
- *  skips the edge-trim fallbacks.  A `trimmed` variant was tried and REFUTED
- *  twice over.  Its premise — "the trims only recover misaligned FRAGMENTS, so
- *  a consumer whose gate rejects fragments loses nothing" — is false: the
- *  left/right trim loops below exist precisely to find WHOLE trained forms
- *  embedded at an offset the query's own fold did not cut, and such a form has
- *  no structural parents or containers, so it passes the pivot's fragment gate
- *  and is exactly the candidate a multi-hop chain steps through.  Skipping them
- *  narrows the pivot's evidence silently.  And a per-caller variant has to key
- *  the memo by the variant, which breaks the "computed at most once" property
- *  (§2.11): the pipeline recognises a grounded answer untrimmed for
- *  `preConsumed`, and the pivot then recognises the same bytes again — the
- *  saving inverts into a doubling on the path it was measured for. */
+ * ONE READING PER BYTE STREAM, deliberately: there is no "cheap mode" that
+ * skips
+ * the edge-trim fallbacks. A `trimmed` variant was tried and REFUTED twice
+ * over. Its premise — "the trims only recover misaligned FRAGMENTS, so a
+ * consumer whose gate rejects fragments loses nothing" — is false: the
+ * left/right trim loops below exist precisely to find WHOLE trained forms
+ * embedded at an offset the query's own fold did not cut, and such a form has
+ * no structural parents or containers, so it passes the pivot's fragment gate
+ * and is exactly the candidate a multi-hop chain steps through. Skipping them
+ * narrows the pivot's evidence silently. And a per-caller variant has to key
+ * the memo by the variant, which breaks the "computed at most once" property
+ * (memoization.md): the pipeline recognises a grounded answer untrimmed for
+ * `preConsumed`, and the pivot then recognises the same bytes again — the
+ * saving inverts into a doubling on the path it was measured for. */
 export function recognise(
   ctx: MindContext,
   bytes: Uint8Array,
@@ -180,16 +181,15 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
     // and read the answer from `starts`, which is exactly {0, W, 2W, …}
     // because riverFold groups fixed-arity — arithmetic, not evidence.
     //
-    // Measured on the 17.9M-node store, over the sites of 7 probes (1 good,
-    // 11 junk by hand-labelling, corrected for whole-query forms):
-    //     len >= W        rejects "hi"(2) "of"(2) "is"(2) "di"(2) "the"(3),
-    //                     admits  "Eiffel Tower"(12) and both whole-query forms
-    //     len >= W-1      admits "the" — W-1 is the write side's straddle
-    //                     neighbour for RETRIEVAL, never a claim about units
-    //     §2.7 saturation admits 11/11 junk: edgeAncestors on a site node
-    //                     reaches 1..48 contexts, so dominates(ctx, N) needs
-    //                     ctx > 162805 and never fires; every site reads DISC
-    //     rarity          does not separate: "hi" has 1 container, "the" 572
+    // Measured on the 17.9M-node store, over the sites of 7 probes (1 good, 11
+    // junk by hand-labelling, corrected for whole-query forms): len >= W
+    // rejects "hi"(2) "of"(2) "is"(2) "di"(2) "the"(3), admits "Eiffel
+    // Tower"(12) and both whole-query forms len >= W-1 admits "the" — W-1 is
+    // the write side's straddle neighbour for RETRIEVAL, never a claim about
+    // units commonality.md saturation admits 11/11 junk: edgeAncestors on a
+    // site node reaches 1..48 contexts, so dominates(ctx, N) needs ctx > 162805
+    // and never fires; every site reads DISC rarity does not separate: "hi" has
+    // 1 container, "the" 572
     //
     // A span covering the WHOLE query is exempt: then it is not a fragment of
     // something longer, it is the question ("hi" asked on its own).