@hviana/sema 0.6.0 → 0.7.2

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

@@ -96,6 +96,19 @@ export declare function cachedRead(ctx: MindContext, cache: WalkCache | null, id
  *     edgeAncestors' question and wrong for this one: a junction container
  *     is legitimately reached across many containing structures.  Half the
  *     successful junctions would be lost.
+ *
+ *     REFUTED EARLY-STOP (side-cone exhaustion, §2.17's "real saturation"):
+ *     stopping the walk the moment ONE side's upward cone is emptied is wrong,
+ *     in both a hub-guarded form and a hub-flagged form.  The junction test is
+ *     a BYTE containment over the UNION of the two cones, and a junction can be
+ *     structurally reachable from only ONE side — the side whose seed is a
+ *     FOLD sub-node of the container (test/16: "cold or hot" is reached from
+ *     the window "cold", but the 3-byte answer "hot" is not a 4-byte window of
+ *     it, so "hot"'s cone is empty while the junction still lies ahead in
+ *     "cold"'s cone; test/34's n-ary binding fails the hub-guarded form the
+ *     same way).  "One cone exhausted" therefore never proves "no junction
+ *     left", and the walk must keep the √N·W budget as its NET after the
+ *     per-node saturations below.
  *   • per-node hub guards — parent fan-outs beyond √N are hubs (not
  *     expanded); each node contributes at most one √N page of containers;
  *     √N collected candidates decide. */

package/dist/src/mind/junction.js

@@ -134,6 +134,19 @@ function cachedContainers(ctx, cache, id, limit) {
  *     edgeAncestors' question and wrong for this one: a junction container
  *     is legitimately reached across many containing structures.  Half the
  *     successful junctions would be lost.
+ *
+ *     REFUTED EARLY-STOP (side-cone exhaustion, §2.17's "real saturation"):
+ *     stopping the walk the moment ONE side's upward cone is emptied is wrong,
+ *     in both a hub-guarded form and a hub-flagged form.  The junction test is
+ *     a BYTE containment over the UNION of the two cones, and a junction can be
+ *     structurally reachable from only ONE side — the side whose seed is a
+ *     FOLD sub-node of the container (test/16: "cold or hot" is reached from
+ *     the window "cold", but the 3-byte answer "hot" is not a 4-byte window of
+ *     it, so "hot"'s cone is empty while the junction still lies ahead in
+ *     "cold"'s cone; test/34's n-ary binding fails the hub-guarded form the
+ *     same way).  "One cone exhausted" therefore never proves "no junction
+ *     left", and the walk must keep the √N·W budget as its NET after the
+ *     per-node saturations below.
  *   • per-node hub guards — parent fan-outs beyond √N are hubs (not
  *     expanded); each node contributes at most one √N page of containers;
  *     √N collected candidates decide. */
@@ -172,7 +185,19 @@ unordered = false) {
         id,
         d: 0,
     }));
-    while (stack.length > 0 && out.length < bound && b.n-- > 0) {
+    while (stack.length > 0 && out.length < bound) {
+        // BUDGET EXHAUSTION IS AN ABSTENTION, AND IT MUST BE VISIBLE (§2.13).  The
+        // walk stops with work still on the stack, the caller reads "no container"
+        // and falls through to a lower ladder rung — indistinguishable, from the
+        // outside, from a walk that looked everywhere and found nothing.  With a
+        // SHARED budget (cross-region's one k·W allowance per tier) an EARLIER
+        // pair can drain it, so a later pair's exact tier may never run at all;
+        // this counter is the only thing that says so.
+        if (b.n-- <= 0) {
+            if (ctx.meter)
+                ctx.meter.junctionBudgetExhausted++;
+            break;
+        }
         const { id: x, d } = stack.pop();
         if (ctx.meter)
             ctx.meter.junctionPops++;

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

@@ -42,7 +42,9 @@ export async function resolveConnectors(ctx, sites, query) {
     // transcript evidence: cover still needs the site for structural context,
     // but liftAnswer will trim that continuation as already answered. Building
     // pairwise/n-ary bridges for it can only create connectors that are later
-    // discarded, and on cumulative dialogue that dominated the whole search.
+    // discarded — a semantically neutral gate (it removes work whose product
+    // liftAnswer throws away), and a cumulative (multi-turn) query is exactly
+    // where such already-answered continuations recur.
     let answered = 0;
     const ordered = [...sites]
         .sort((a, b) => a.start - b.start)
@@ -56,7 +58,26 @@ export async function resolveConnectors(ctx, sites, query) {
         if (query === undefined || ctx.answeredSpans.length === 0)
             return true;
         const continuations = ctx.store.nextFirst(s.payload, hubBound(ctx));
-        return !continuations.some((answer) => indexOf(query, read(ctx, answer), 0) >= 0);
+        return !continuations.some((answer) => {
+            // PREFIX-CAPPED (AGENTS §2.8): a candidate longer than the query cannot
+            // occur INSIDE it, so read one byte past the query's length — enough to
+            // detect the overflow — and reject without reconstructing the rest.
+            // The `+ 1` is what makes the test exact rather than a truncation: a
+            // result of exactly `query.length + 1` bytes is known to be too long,
+            // and anything shorter is the candidate's COMPLETE content, so the
+            // substring test below is the same test as before.  (The same overflow
+            // probe bridge.ts:256 already uses.)
+            //
+            // This loop runs up to hubBound(ctx) = √N reads PER SITE, and only on a
+            // multi-turn response — `answeredSpans` is empty for a plain respond(),
+            // so the probe does not execute there.  The cap cannot reduce the read
+            // COUNT — only a semantic change to the "already answered" test could —
+            // but it bounds each read by the query instead of by the corpus, which
+            // is what §2.8 asks for and what rescues a SHORT query: at 3 bytes this
+            // reads 4 bytes per candidate instead of the ~231 it averaged before.
+            const bytes = read(ctx, answer, query.length + 1);
+            return bytes.length <= query.length && indexOf(query, bytes, 0) >= 0;
+        });
     });
     const bridgePair = async (l, r) => {
         if (l === r || links.has(l + "," + r))

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

@@ -16,7 +16,8 @@ export interface PrefixCompletion {
  *  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
+ *  `ranked` must be a list the caller has ALREADY fetched (the write side's
+ *  window index, or the response's memoised top-k); 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

@@ -45,15 +45,23 @@
 //      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 no k recovers it.
 //
-// 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.
+// So this is a RETRIEVABILITY gap, not a semantic one, and the ANN is the wrong
+// instrument for it: a proper prefix's gist cannot rank its own continuation.
+// The repair is CONTENT-ADDRESSED (§2.3) — `formsOpenedBy` (traverse.ts) reads
+// the leaf-id WINDOW index the write side already maintains and answers "which
+// trained forms does this byte run open?" in a bounded √N walk.  That is this
+// mechanism's first supply.  The response's memoised top-k `resonance()` is the
+// second, for prefixes long enough that the gist still ranks the form; it is
+// read, never re-issued.
+//
+// AN EXHAUSTIVE ANN LIST IS NOT A SUPPLY HERE, AND WAS REMOVED.  This tier once
+// read `Precomputed.wideResonance()` — a full-index `resonate(guide, √N,
+// exhaustive)` — on the argument that the target "ranks 8 with `exhaustive`".
+// It bought an O(k) need at O(index) cost (measured: 244K annVectorReads per
+// refusing query, ~1.5 s) for candidates the window index proposes directly.
+// See pipeline-mechanism.ts's REMOVED note; test/95 pins its absence.
 //
 // THREE GUARDS, each falsified into existence by measurement — do not drop any:
 //
@@ -97,7 +105,8 @@ import { STEP } from "../graph-search.js";
  *  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
+ *  `ranked` must be a list the caller has ALREADY fetched (the write side's
+ *  window index, or the response's memoised top-k); this mechanism never
  *  resonates on its own (see the header's cost note). */
 export function prefixCompletion(ctx, query, ranked) {
     const W = ctx.space.maxGroup;
@@ -204,9 +213,9 @@ export const prefixMechanism = {
     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.
+        // INVESTMENT DISCIPLINE — the supplies below are a bounded √N window walk
+        // and the response's memoised top-k resonance read, 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
@@ -218,14 +227,25 @@ export const prefixMechanism = {
         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));
+        // ONE SUPPLY PASS, not a two-tier `??`.  The window index (exact,
+        // content-addressed) and the response's memoised top-k (approximate) are
+        // concatenated and the three guards decide ONCE over the union.  A
+        // first-then-fallback chain would let the APPROXIMATE tier override the
+        // EXACT one (§2.3): when formsOpenedBy finds two continuations, guard 3
+        // returns null and the fallback re-runs the guards on resonance's top-k
+        // alone — which, seeing only one of the two forms, would voice it.  That is
+        // precisely the disagreement-suppression guard 3 exists to prevent, and it
+        // is the exact tier's ambiguity being washed away by the approximate tier.
+        // Evaluating the union means a disagreement the window index saw can never
+        // be hidden by what the ANN happens to rank.  The ANN read is the
+        // response's ONE memoised top-k (§2.11), already paid by recall's refusal
+        // path on the queries where this mechanism fires, so reading it here is not
+        // a second index scan.
+        const ids = [
+            ...formsOpenedBy(ctx, query),
+            ...(await pre.resonance()).map((h) => h.id),
+        ];
+        const completed = prefixCompletion(ctx, query, ids);
         if (completed === null)
             return [];
         return [{

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

@@ -306,10 +306,14 @@ export async function recallByResonance(ctx, query, pre) {
         }
     }
     // 3b. Corroborated-substitution bridge — refusal-path only (bridge.ts).
-    // The WIDE candidate list every past-the-top-k mechanism reads lives on
-    // Precomputed (see wideResonance): shared across the whole response, so the
-    // exhaustive branch runs at most once whoever first-touches it.
-    const wideIds = () => pre.wideResonance();
+    // 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.
+    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
     // anchor, accepting mismatches only as corpus-attested, concept-bar

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

@@ -63,30 +63,6 @@ export declare class Precomputed {
      *  duplication a profile shows as doubled `annVectorReads` with nothing to
      *  account for it.  Cached BY PROMISE, so a second caller awaits the first. */
     resonance(): Promise<ReadonlyArray<Hit>>;
-    private _wide?;
-    /** The response's WIDE candidate list — the top-k when the query's gist has
-     *  no concept-level match anywhere, and an exhaustive √N read when it does.
-     *
-     *  Every mechanism that has to look PAST the top-k reads this one list: the
-     *  substitution bridge, prefix completion and the frame filler all did, and
-     *  it was memoised inside recall for exactly that reason (measured: 490 ms
-     *  median re-issued against 13 ms non-exhaustive, 36x).  A memo inside one
-     *  mechanism only serves that mechanism's own tiers, so it lives here now —
-     *  the same move `resonance` made for the top-k.
-     *
-     *  THE CONDITION IS THE TOP HIT'S SCORE, NOT THE CORPUS SIZE.  When nothing
-     *  ranks at concept level, an exhaustive ANN only scores more vectors below
-     *  the bar (profiled at 38K–40K annVectorReads per refusing query on a 325K-
-     *  context store); the structural channels — junction walks, anchor climbs,
-     *  the write side's window index — are the correct proposal source there,
-     *  because the ANN cannot propose what the gist cannot rank.  This was once
-     *  spelled `corpusN(ctx) <= (k · W)³`, which asks a different question and
-     *  answers it wrongly at exactly the scale it was written from: at N =
-     *  325,608 with k = 24 and W = 4 the cube is 884,736, so that store took the
-     *  exhaustive branch — the very branch measured above.  Measured cost of the
-     *  mismatch: substitutionBridge 8,544 ms of a 19,548 ms think (44%), against
-     *  1,248 ms and 14,218 ms without it, every answer byte-identical. */
-    wideResonance(): Promise<ReadonlyArray<number>>;
     private _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

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

@@ -13,12 +13,12 @@
 //   4. TRAVELING EVIDENCE — run() returns MechanismResult with accounted, moves,
 //      and unexplained.  The pipeline computes the weight.
 import { indexOf } from "../bytes.js";
-import { conceptThreshold, dominates } from "../geometry.js";
+import { dominates } from "../geometry.js";
 import { windowIds } from "./canonical.js";
 import { read, resolve } from "./primitives.js";
 import { alignGraded, frameSlots, skillExemplar, } from "./match.js";
 import { climbAttentionAll } from "./attention.js";
-import { hubBound, sharedReachMemo } from "./traverse.js";
+import { sharedReachMemo } from "./traverse.js";
 // ── Precomputed ──────────────────────────────────────────────────────────────
 //
 // Precomputed is a LAZY container for structural analyses of the query — the
@@ -128,40 +128,17 @@ export class Precomputed {
     resonance() {
         return this._resonance ??= this.shared("resonance", () => this.ctx.store.resonate(this.guide, this.k));
     }
-    _wide;
-    /** The response's WIDE candidate list — the top-k when the query's gist has
-     *  no concept-level match anywhere, and an exhaustive √N read when it does.
-     *
-     *  Every mechanism that has to look PAST the top-k reads this one list: the
-     *  substitution bridge, prefix completion and the frame filler all did, and
-     *  it was memoised inside recall for exactly that reason (measured: 490 ms
-     *  median re-issued against 13 ms non-exhaustive, 36x).  A memo inside one
-     *  mechanism only serves that mechanism's own tiers, so it lives here now —
-     *  the same move `resonance` made for the top-k.
-     *
-     *  THE CONDITION IS THE TOP HIT'S SCORE, NOT THE CORPUS SIZE.  When nothing
-     *  ranks at concept level, an exhaustive ANN only scores more vectors below
-     *  the bar (profiled at 38K–40K annVectorReads per refusing query on a 325K-
-     *  context store); the structural channels — junction walks, anchor climbs,
-     *  the write side's window index — are the correct proposal source there,
-     *  because the ANN cannot propose what the gist cannot rank.  This was once
-     *  spelled `corpusN(ctx) <= (k · W)³`, which asks a different question and
-     *  answers it wrongly at exactly the scale it was written from: at N =
-     *  325,608 with k = 24 and W = 4 the cube is 884,736, so that store took the
-     *  exhaustive branch — the very branch measured above.  Measured cost of the
-     *  mismatch: substitutionBridge 8,544 ms of a 19,548 ms think (44%), against
-     *  1,248 ms and 14,218 ms without it, every answer byte-identical. */
-    wideResonance() {
-        return this._wide ??= this.shared("wideResonance", async () => {
-            const hits = await this.resonance();
-            if (hits.length > 0 &&
-                hits[0].score >= conceptThreshold(this.ctx.store.D)) {
-                const exhaustive = await this.ctx.store.resonate(this.guide, hubBound(this.ctx), true);
-                return exhaustive.map((h) => h.id);
-            }
-            return hits.map((h) => h.id);
-        });
-    }
+    // 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
+    // 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.
     _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

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

@@ -37,6 +37,30 @@ export interface NarrowDecisionData {
     version: 1;
     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. */
+export interface RegimePredictionData {
+    version: 1;
+    /** retrieval | composition — the two regimes R1 measured as a ~100× cost
+     *  step. */
+    regime: "retrieval" | "composition";
+    /** The incumbent's grade once the first mechanism's turn is over (it ran, or
+     *  it was skipped), or null when nothing has grounded — `best === null`,
+     *  which is composition with no incumbent. */
+    incumbentGrade: number | null;
+    /** The cheapest composition floor in grade units (`grade(2 * STEP)` = 2,
+     *  CAST's floor) — the bar the incumbent must sit at or below for the
+     *  consensus climb to be skipped. */
+    climbFloorGrade: number;
+}
 /** Think: a single lightest-derivation exploration of the Sema graph.
  *
  *  Every answer travels the same path:

package/dist/src/mind/pipeline.js

@@ -92,9 +92,21 @@ export async function think(ctx, query, mechs) {
     };
     // ── Pre-computation ──────────────────────────────────────────────────
     const mechanisms = mechs ?? defaultMechanisms;
-    const rec = recognise(ctx, query);
+    const meter = ctx.meter;
+    // recognition is a shared analysis (§2.14 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.
+    const rec = meter
+        ? meter.timeSync("recognise", () => recognise(ctx, query))
+        : recognise(ctx, query);
     // Phase 1: collect computed spans from mechanisms that implement parse()
-    const computed = await collectComputed(ctx, mechanisms, query);
+    const computed = meter
+        ? await meter.time("collectComputed", () => collectComputed(ctx, mechanisms, query))
+        : await collectComputed(ctx, mechanisms, query);
     if (computed.length > 0) {
         ctx.trace?.step("computeExtensions", [rItem(query, "query")], computed.map((u) => rItem(query.subarray(u.i, u.j), "operand", undefined, [u.i, u.j])), `extensions recognised and evaluated ${computed.length} computation(s)`);
         for (const u of computed) {
@@ -107,6 +119,9 @@ export async function think(ctx, query, mechs) {
     // 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.
     const pre = new Precomputed(ctx, query, rec, computed, ctx._edgeGuide);
     const grade = (w) => Math.floor(w / STEP);
     const unaccounted = (spans) => unexplainedSpans(query.length, spans)
@@ -151,12 +166,59 @@ export async function think(ctx, query, mechs) {
             best = c;
     };
     const worthRunning = (floor) => 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.
+    //
+    // EMITTED BEFORE THE SECOND MECHANISM'S FLOOR, never after some mechanism's
+    // run: a "prediction" published after the fact could assert "the climb will
+    // not run" about a climb that already ran — which is what happens whenever
+    // the first mechanism is SKIPPED (null floor or pruned) and the block sits at
+    // the end of the first mechanism that actually ran.  Emitting on entry to
+    // iteration 1 makes the claim true by construction, whatever the first
+    // mechanism did, and keeps the payload identical on the ordinary path (the
+    // incumbent cannot change between the two positions).
+    let regimeReported = false;
+    const reportRegime = () => {
+        if (regimeReported)
+            return;
+        regimeReported = true;
+        const climbFloorGrade = grade(2 * STEP);
+        // TS narrows `best` to null in the outer flow (it cannot see the closure
+        // assignments in `consider`) — cast back, the same read-back as `decided`
+        // below.
+        const incumbent = best;
+        const incumbentGrade = incumbent === null ? null : grade(incumbent.weight);
+        const regime = worthRunning(2 * STEP)
+            ? "composition"
+            : "retrieval";
+        ctx.trace?.step("regimePrediction", [rItem(query, "query")], [], regime === "retrieval"
+            ? `retrieval regime — incumbent grade ${incumbentGrade} ≤ climb floor ${climbFloorGrade}, ` +
+                `so no mechanism floored above that grade runs; the consensus climb will not run`
+            : `composition regime — ${incumbentGrade === null
+                ? "no incumbent (nothing grounded)"
+                : `incumbent grade ${incumbentGrade}`} above climb floor ${climbFloorGrade}, so the full market and climb run`, undefined, {
+            version: 1,
+            regime,
+            incumbentGrade,
+            climbFloorGrade,
+        });
+    };
     // Phase 3: grounding loop
     // Per-mechanism accounting (src/meter.ts).  The market's whole premise is
     // that mechanisms compete on one cost scale — so the profiling read-out is
     // also per-mechanism, uniformly: the loop never asks which one it holds.
-    const meter = ctx.meter;
-    for (const mech of mechanisms) {
+    for (let mi = 0; mi < mechanisms.length; mi++) {
+        const mech = mechanisms[mi];
+        if (mi > 0)
+            reportRegime();
         const floor = meter
             ? await meter.time(`${mech.name}.floor`, () => mech.floor(ctx, query, pre, worthRunning))
             : await mech.floor(ctx, query, pre, worthRunning);
@@ -193,6 +255,10 @@ export async function think(ctx, query, mechs) {
             });
         }
     }
+    // A market of ONE mechanism never reaches iteration 1; the step is still
+    // emitted exactly once per think(), so a consumer never has to ask whether
+    // the list was long enough for the prediction to exist.
+    reportRegime();
     // (TS cannot see the closure assignments into `best` and narrows it to its
     // initial null, so the read-back needs the assertion.)
     const decided = best;
@@ -337,7 +403,7 @@ export async function think(ctx, query, mechs) {
         ? reasoned
         : meter
             ? await meter.time("fuse", () => fuseAttention(ctx, query, reasoned, pre, unclimbed, primarySpans))
-            : await fuseAttention(ctx, query, reasoned, pre, unclimbed, decided.accounted);
+            : await fuseAttention(ctx, query, reasoned, pre, unclimbed, primarySpans);
     done(fused, "grounded, reasoned forward, fused across points of attention");
     return { bytes: fused, provenance };
 }

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

@@ -10,7 +10,21 @@ import type { MindContext, Recognition, Segment } from "./types.js";
  *     the longest known leaf, chained into flat branches.  Names forms the
  *     query's own cut cannot, and records sub-leaf boundaries as `splits`.
  *
- *  Both O(n · maxGroup) bounded O(1) probes — never a scan of the corpus. */
+ *  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. */
 export declare function recognise(ctx: MindContext, bytes: Uint8Array): Recognition;
 /** Segment bytes using the geometry's own groupings — leaf-parent
  *  nodes from the perceived tree, with consecutive bare leaves merged

package/dist/src/mind/recognition.js

@@ -21,7 +21,21 @@ import { isChunk } from "../sema.js";
  *     the longest known leaf, chained into flat branches.  Names forms the
  *     query's own cut cannot, and records sub-leaf boundaries as `splits`.
  *
- *  Both O(n · maxGroup) bounded O(1) probes — never a scan of the corpus. */
+ *  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. */
 export function recognise(ctx, bytes) {
     // Content-keyed memo — works for both single-turn respond() and multi-turn
     // respondTurn() (where the map persists across calls).  ALWAYS consulted,

package/dist/src/mind/resonance.js

@@ -9,7 +9,7 @@ import { mergeThreshold } from "../geometry.js";
 import { concat2, concatBytes, indexOf } from "../bytes.js";
 import { gistOf, read, resolve, walkTree } from "./primitives.js";
 import { perceive } from "./primitives.js";
-import { argmaxBy, argmaxCosine, candidateGist, hubBound } from "./traverse.js";
+import { argmaxCosine, candidateGist, hubBound } from "./traverse.js";
 import { cachedRead, junctionContainers, junctionSynonyms, walkCache, } from "./junction.js";
 import { recognise } from "./recognition.js";
 // ── The bridge — the junction between two adjacent results ──────────────────
@@ -288,6 +288,12 @@ export async function pivotInto(ctx, answer, consumed, voiced = []) {
         for (const c of n.kids)
             queue.push(c); // breadth-first: larger regions first
     }
+    // THE FULL recognition, memo-shared with every other reader of these bytes.
+    // A "skip the edge trims here" variant was refuted (see recognise's own
+    // note): those trims are what find a WHOLE trained form embedded at an
+    // offset the answer's fold did not cut, and such a form is parentless,
+    // container-free and edge-bearing — i.e. exactly what the filter below
+    // ADMITS as a pivot, not what it rejects.
     const rec = recognise(ctx, answer);
     for (const s of rec.sites) {
         if (!consumed.has(s.payload) && ctx.store.hasNext(s.payload)) {
@@ -296,7 +302,33 @@ export async function pivotInto(ctx, answer, consumed, voiced = []) {
     }
     // Byte containment, longest wins — the answer literally contains the
     // pivot's bytes, and the biggest well-evidenced span is the real pivot.
-    const found = argmaxBy(scored.keys(), (id) => {
+    //
+    // REAL SATURATION, not a hard cap: the score IS the candidate's byte
+    // length, so the scan is DECIDED the moment the first candidate that passes
+    // every filter is found in DESCENDING length order — a shorter candidate can
+    // never outscore it.  `contentLen` (the prefix-capped length read, §2.8) is
+    // the cheap ordering key, and the first-inserted tie-break is made explicit
+    // (`a.index - b.index`) so equal lengths keep `scored`'s insertion order —
+    // exactly the tie argmaxBy(strict) used to keep.  The bytes of at most ONE
+    // winning candidate are read; every shorter candidate the probes proposed is
+    // skipped without reconstruction, where the old argmax read them all.
+    const ranked = [...scored.keys()]
+        .map((id, index) => ({
+        id,
+        index,
+        len: ctx.store.contentLen(id, answer.length + 1),
+    }))
+        .sort((a, b) => b.len - a.len || a.index - b.index);
+    let pivotId = null;
+    for (const c of ranked) {
+        const id = c.id;
+        // A ZERO-LENGTH candidate is not a pivot.  `argmaxBy(…, 0, strict)` used to
+        // carry this floor in its threshold argument, and dropping it here would
+        // admit an empty node: `indexOf(answer, <empty>)` returns 0, so every
+        // filter below passes and the chain would hop through nothing (§2.13 —
+        // empty bytes are truthy).
+        if (c.len === 0)
+            continue;
         // A PIVOT MUST BE A THING THE CORPUS DEPOSITED, NOT A PIECE OF ONE.
         // "Longest wins" ranks candidates but never asks whether the winner is
         // an entity at all, and by the time a chain reaches here `consumeAll`
@@ -330,18 +362,28 @@ export async function pivotInto(ctx, answer, consumed, voiced = []) {
         // what `parents`/`containers` record.  Reasoning steps THROUGH a fact;
         // a span that was never a fact on its own is not one to step through.
         // No constant enters — it is a structural predicate, not a threshold.
-        if (ctx.store.hasParents(id) || ctx.store.hasContainers(id)) {
-            return -Infinity;
-        }
+        if (ctx.store.hasParents(id) || ctx.store.hasContainers(id))
+            continue;
+        // A candidate whose bytes are LONGER than the answer cannot be a
+        // substring of it — `indexOf` would return −1 regardless.  Prune by
+        // length BEFORE reconstructing the bytes: `read` is an UNCAPPED read
+        // (AGENTS §2.8), and a resonated context far longer than the answer is
+        // exactly the candidate that makes it cost a whole deposit's worth of
+        // reconstruction for a containment test that must fail.  `contentLen`
+        // with the `answer.length + 1` cap is the prefix-capped length read the
+        // same contract prescribes; the prune is byte-identical to the old
+        // `indexOf` miss (it returns −1 for a needle longer than the haystack).
+        if (c.len > answer.length)
+            continue;
         const bytes = read(ctx, id);
         if (indexOf(answer, bytes, 0) < 0)
-            return -Infinity;
-        for (const v of voiced)
-            if (indexOf(v, bytes, 0) >= 0)
-                return -Infinity;
-        return bytes.length;
-    }, 0, true);
-    return found?.item ?? null;
+            continue;
+        if (voiced.some((v) => indexOf(v, bytes, 0) >= 0))
+            continue;
+        pivotId = id;
+        break;
+    }
+    return pivotId;
 }
 /** Which of the given labelled forms a span MEANS — generic resonance over
  *  perceived gists.  Each anchor form's gist is memoised; the span's gist