@hviana/sema 0.6.0 → 0.7.1

package/src/mind/graph-search.ts

@@ -108,6 +108,13 @@ export type GItem =
      *  because subtraction is more "the point" of its query).  See
      *  {@link liftAnswer}. */
     computed?: boolean;
+    /** Set on the out emitted at a chain's GENUINE FIXPOINT — the one span kind a
+     *  recursive re-cover ({@link GraphSearch.recompleteNode}) may deepen.  The
+     *  re-cover does NOT run here: this marks the span as eligible, and
+     *  {@link GraphSearch.deepen} runs it afterwards on the spans the lightest
+     *  derivation actually CHOSE.  Part of {@link key}, because it decides
+     *  whether the span's final bytes may still change. */
+    fix?: boolean;
   };
 type OutItem = Extract<GItem, { kind: "out" }>;
 
@@ -153,6 +160,10 @@ export interface Seg {
   /** See the `computed` field of the "out" {@link GItem} — set only for an
    *  extension's derived value, never a genuinely recognised learned form. */
   computed?: boolean;
+  /** See the `fix` field of the "out" {@link GItem} — this span ended a chain at
+   *  a genuine fixpoint, so it is the one span kind a recursive re-cover may
+   *  still deepen.  Consumed by {@link GraphSearch.deepen}. */
+  fix?: boolean;
 }
 
 /** Read the chosen spans back off a derivation: the goal is a chain of bridge
@@ -171,6 +182,7 @@ function readCover(derivation: Derivation<GItem>): Seg[] {
         rec: out.rec,
         node: out.node,
         computed: out.computed,
+        fix: out.fix,
       });
     }
     node = node.premises[0];
@@ -472,10 +484,32 @@ export class GraphSearch {
       onDerivation(readDerivation(derivation, substitutions !== undefined));
     }
     return derivation
-      ? { segs: readCover(derivation), cost: derivation.cost }
+      ? { segs: this.deepen(readCover(derivation)), cost: derivation.cost }
       : null;
   }
 
+  /** Re-cover the CHOSEN fixpoint spans, in place.
+   *
+   *  Completion is still "cover, recursively" — it just runs on the answer
+   *  instead of on the exploration.  A cover chooses O(segs) spans, so a level
+   *  pays O(answer) re-covers however densely the corpus interconnects the forms
+   *  the search passed through on the way.  That is the bound
+   *  {@link recompleteNode}'s contract always claimed and, running per fixpoint
+   *  REACHED, never had.
+   *
+   *  Deepening cannot change which cover won: the derivation is already final
+   *  and every span keeps its i..j and its cost.  It only replaces a chosen
+   *  span's bytes with the deeper learnt form they rewrite to — what the
+   *  recursion was always for. */
+  private deepen(segs: Seg[]): Seg[] {
+    for (const s of segs) {
+      if (!s.fix || s.node === undefined) continue;
+      const deeper = this.recompleteNode(s.node);
+      if (deeper !== null) s.bytes = deeper;
+    }
+    return segs;
+  }
+
   /** The weighted deduction system the graph exploration solves (the four
    *  reductions of adapted A*LD live in {@link lightestDerivation}; this only states the
    *  items, axioms, goal, and rules — see {@link GItem} for the item kinds).
@@ -541,8 +575,8 @@ export class GraphSearch {
           }`;
         }
         return `o${it.i}.${it.j}.${it.cover ? 1 : 0}.${it.rec ? 1 : 0}.${
-          it.node ?? -1
-        }.${latin1(it.bytes)}`;
+          it.fix ? 1 : 0
+        }.${it.node ?? -1}.${latin1(it.bytes)}`;
       },
       *axioms() {
         yield { item: { kind: "cover", p: 0 }, cost: 0 };
@@ -855,17 +889,29 @@ export class GraphSearch {
       // actual end, never per intermediate stop — so its cost tracks the
       // ANSWER's own structure, not how densely the corpus interconnects
       // the nodes passed through on the way there.
-      const deeper = this.recompleteNode(it.node);
+      // MARK the fixpoint; do not re-cover it here.  Re-covering at this point
+      // pays a full {@link recompleteNode} — a recognition of the node's whole
+      // bytes — for every fixpoint the exploration REACHES, and how many it
+      // reaches is set by how densely the corpus interconnects the forms passed
+      // through.  Measured on an 18.9M-node store, a 2-byte query: 12,000
+      // re-covers inside ONE cover, folding 95,258 distinct spans, ~2.4 GB and
+      // climbing to a V8 fatal.  The answer needs a handful.
+      //
+      // {@link deepen} runs it instead on the spans the lightest derivation
+      // CHOSE.  The ladder is untouched — this out still costs 0, so a genuine
+      // fixpoint still beats any premature stop at the same depth, exactly as
+      // the ordering above states.
       yield {
         premises: [it],
         conclusion: {
           kind: "out",
           i: it.i,
           j: it.j,
-          bytes: deeper ?? nodeBytes(it.node),
+          bytes: nodeBytes(it.node),
           cover: true,
           rec: true,
           node: it.node,
+          fix: true,
         },
         cost: 0,
       };
@@ -936,18 +982,45 @@ export class GraphSearch {
    *  ({@link resolve}) — the graph itself gates against re-expanding a contained
    *  form ("ice is cold" ⊅→ "ice is cold is cold").
    *
-   *  Termination is INTRINSIC, not a depth limit: a node already on the
-   *  completion stack ({@link recompleteOpen}) is not re-entered — a self-
-   *  referential recomposition is a cycle that can yield nothing new, so it
-   *  stops there, exactly as {@link completeForward} stops on a revisited edge.
-   *  Distinct node ids are finite and each finished completion is memoised, so a
-   *  legitimate chain runs as deep as the graph licenses and no further. */
+   *  Termination is STRUCTURAL: a produced node is re-covered once, never inside
+   *  another re-cover (see the guard below), so one cover pays at most one
+   *  nested {@link solve} per distinct produced node it actually reaches, and
+   *  {@link recompleteMemo} collapses a repeat to nothing.
+   *
+   *  This comment used to argue termination from "distinct node ids are finite
+   *  and each finished completion is memoised".  That is a bound of N — the one
+   *  AGENTS §2.8 forbids — and it was load-bearing, not pedantic: nested, the
+   *  recursion reached depth 331 and 9.1 GB on an 18.9M-node store for a 2-byte
+   *  query and did not terminate, which is what killed a 5 h training run at its
+   *  checkpoint recall.  Guard: test/89-completion-recursion.test.mjs. */
   private recompleteNode(node: number): Uint8Array | null {
     if (!this.host.recogniseSpan) return null;
     const memo = this.recompleteMemo;
     if (memo.has(node)) return memo.get(node) ?? null;
-    // Cycle guard: a node being completed must not recurse back into itself.
-    if (this.recompleteOpen.has(node)) return null;
+    // ONE re-cover per produced node — never a re-cover inside a re-cover.
+    //
+    // Re-covering is how a PRODUCED node's bytes enter the search at all: the
+    // cover machinery otherwise only ever sees the QUERY's spans.  That is
+    // needed once.  The alternation of decomposition and recomposition that
+    // follows — parts rewriting several times, siblings fusing, a recomposition
+    // feeding another — is the main search's own fuse/`rcmp` work, not this
+    // recursion's: 15-decomposition-gap §9–§12 all pass with this method
+    // disabled outright, and only §6 (the produced composite "p1 p2", whose
+    // bytes nothing else brings in) needs it.
+    //
+    // Nesting it was the defect.  Each level is a full {@link solve} with its
+    // own agenda and chart, exploring from a node the answer never asked about,
+    // so per-query cost tracked how densely the corpus interconnects the forms
+    // passed through — the growth AGENTS §2.8 forbids.  Measured on an
+    // 18.9M-node store: depth 331 and 9.1 GB for a 2-byte query, not
+    // terminating; and on the guard corpus every one of 125 nested re-covers
+    // was REJECTED by the resolve() gate below, expanding a 70-byte node into a
+    // 374-byte concatenation that names nothing.  All of it was waste.
+    //
+    // `recompleteOpen` is that stack, so a non-empty stack means we are already
+    // inside one.  This subsumes the old cycle guard: a node cannot recurse
+    // back into itself when nothing recurses at all.
+    if (this.recompleteOpen.size > 0) return null;
 
     // A leaf or single-child node has no parts to recompose; skip before the
     // costly recognition so a plain terminal answer pays nothing.
@@ -985,9 +1058,13 @@ export class GraphSearch {
    *  outs of a long query re-cover each distinct node at most once); reset at the
    *  top of {@link cover}. */
   private recompleteMemo = new Map<number, Uint8Array | null>();
-  /** The nodes currently being re-completed — the recursion stack.  A node in
-   *  this set is not re-entered, so a cyclic recomposition terminates naturally
-   *  (the same cycle guard {@link completeForward} uses), with no depth cap. */
+  /** The node currently being re-completed — the recursion stack, and so also
+   *  the nesting depth.  {@link recompleteNode} refuses to start while it is
+   *  non-empty (one re-cover per produced node, never one inside another), which
+   *  is what keeps a query's cost proportional to its answer rather than to the
+   *  corpus; it therefore holds at most one id.  A Set, not a flag, because it
+   *  states WHICH node is open — the invariant a reader needs to check the
+   *  guard, and what makes the old cycle-guard reading still hold. */
   private recompleteOpen = new Set<number>();
 
   /** out(i,j,bytes,…): index it for the binary rules, then offer splicing a

package/src/mind/junction.ts

@@ -207,6 +207,19 @@ function cachedContainers(
  *     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/src/mind/mechanisms/cover.ts

@@ -59,7 +59,9 @@ export async function resolveConnectors(
   // 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)
@@ -72,9 +74,26 @@ export async function resolveConnectors(
       if (span && span[0] <= s.start && s.end <= span[1]) return false;
       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: number, r: number) => {
     if (l === r || links.has(l + "," + r)) return;

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

@@ -251,9 +251,9 @@ export const prefixMechanism: PipelineMechanism = {
   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
     // cap cannot clear guard 2, so it is not worth a single read.
@@ -264,14 +264,16 @@ export const prefixMechanism: PipelineMechanism = {
     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));
+    // The write side's window index proposes FIRST: a proper prefix's gist
+    // cannot rank its own continuation (cos falls below reachThreshold at a
+    // few bytes of truncation), so the content-addressed window walk is the
+    // correct measure for this question (§2.3), and it is a bounded √N walk —
+    // cheaper than an exhaustive ANN.  The top-k resonance list is the SECOND
+    // supply, for prefixes long enough that the gist still ranks the form.  A
+    // second SUPPLY, not a second mechanism — the same three guards decide
+    // either way.
+    const completed = prefixCompletion(ctx, query, formsOpenedBy(ctx, query)) ??
+      prefixCompletion(ctx, query, (await pre.resonance()).map((h) => h.id));
     if (completed === null) return [];
     return [{
       bytes: completed.form,

package/src/mind/mechanisms/recall.ts

@@ -412,10 +412,14 @@ export async function recallByResonance(
     }
   }
   // 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

package/src/mind/pipeline-mechanism.ts

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

package/src/mind/pipeline.ts

@@ -129,6 +129,30 @@ 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. */
+export interface RegimePredictionData {
+  version: 1;
+  /** retrieval | composition — the two regimes R1 measured as a ~100× cost
+   *  step. */
+  regime: "retrieval" | "composition";
+  /** The incumbent's grade right after the first mechanism ran, or null when
+   *  it grounded nothing (best === null — 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:
@@ -161,10 +185,22 @@ export async function think(
 
   // ── 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.
+  const rec = meter
+    ? await meter.time("recognise", async () => 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(
@@ -191,6 +227,9 @@ export async function think(
   // 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);
 
   // ── Grounding: ONE lightest-derivation choice among the mechanisms ────
@@ -259,7 +298,7 @@ export async function think(
   // 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;
+  let regimeReported = false;
   for (const mech of mechanisms) {
     const floor = meter
       ? await meter.time(
@@ -308,6 +347,51 @@ export async function think(
         scaffolding: r.scaffolding,
       });
     }
+    // REGIME PREDICTION (R8) — observational only.  After the FIRST mechanism
+    // runs (cover, which §2.6 places first and floors at 0), the market's
+    // outcome is already determined: 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 just used — nothing is
+    // computed here that the engine had not already computed, and nothing is
+    // read back by inference.
+    if (!regimeReported) {
+      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 as Candidate | null;
+      const incumbentGrade = incumbent === null
+        ? null
+        : grade(incumbent.weight);
+      const regime: "retrieval" | "composition" = worthRunning(2 * STEP)
+        ? "composition"
+        : "retrieval";
+      ctx.trace?.step(
+        "regimePrediction",
+        [rItem(query, "query")],
+        [],
+        regime === "retrieval"
+          ? `retrieval regime — incumbent grade ${incumbentGrade} ≤ climb floor ${climbFloorGrade}, so no composition mechanism 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,
+        } satisfies RegimePredictionData,
+      );
+    }
   }
 
   // (TS cannot see the closure assignments into `best` and narrows it to its

package/src/mind/recognition.ts

@@ -33,7 +33,16 @@ import type { Leaf, Site } from "./graph-search.js";
  *     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. */
-export function recognise(ctx: MindContext, bytes: Uint8Array): Recognition {
+/** Decompose `bytes` into the learnt forms it contains.  `trimmed` skips the
+ *  edge-trim fallbacks (which recover misaligned FRAGMENTS) — for callers whose
+ *  own gate rejects fragments anyway (the pivot), so the O(n·W²) trim search is
+ *  paid only where its output can be used.  Byte-identical for every caller
+ *  that keeps only top-level forms. */
+export function recognise(
+  ctx: MindContext,
+  bytes: Uint8Array,
+  trimmed = false,
+): Recognition {
   // Content-keyed memo — works for both single-turn respond() and multi-turn
   // respondTurn() (where the map persists across calls).  ALWAYS consulted,
   // regardless of tracing — matching perceive()'s own memo, which carries no
@@ -73,7 +82,7 @@ export function recognise(ctx: MindContext, bytes: Uint8Array): Recognition {
   // not silent), so it is emitted here directly rather than only inside
   // recogniseImpl.
   if (ctx.recogniseMemo) {
-    const key = latin1Key(bytes);
+    const key = (trimmed ? "t" : "f") + latin1Key(bytes);
     const hit = ctx.recogniseMemo.get(key);
     if (hit !== undefined) {
       if (ctx.meter) ctx.meter.recogniseHits++;
@@ -91,14 +100,18 @@ export function recognise(ctx: MindContext, bytes: Uint8Array): Recognition {
       );
       return hit;
     }
-    const fresh = recogniseImpl(ctx, bytes);
+    const fresh = recogniseImpl(ctx, bytes, trimmed);
     ctx.recogniseMemo.set(key, fresh);
     return fresh;
   }
-  return recogniseImpl(ctx, bytes);
+  return recogniseImpl(ctx, bytes, trimmed);
 }
 
-function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
+function recogniseImpl(
+  ctx: MindContext,
+  bytes: Uint8Array,
+  trimmed = false,
+): Recognition {
   if (ctx.meter) {
     ctx.meter.recognitions++;
     ctx.meter.recognisedBytes += bytes.length;
@@ -211,7 +224,7 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
       // n.kids !== null enforces above) rather than degenerate into
       // single-byte-atom territory, which atomIsHub already governs
       // separately.
-      else if (end - start - 1 >= 2) {
+      else if (!trimmed && end - start - 1 >= 2) {
         // The chunk's own boundary is drawn by content geometry, not by
         // any notion of "form" — it can include one edge byte the query's
         // fold happened to attach here that the trained span never had