@hviana/sema 0.7.1 → 0.7.3

package/HOW_IT_WORKS.md

@@ -4434,16 +4434,19 @@ before the conversion. Derived from the existing bars; never tuned.
 ### 21.5 The refusal path — the substitution bridge, before silence
 
 Everything geometric has now failed. One tier remains, making a **structural**
-claim about the query that resonance cannot state. It reads the response's
-**wide candidate list** (`Precomputed.wideResonance`, §14.5) — the ranked hits,
-widened to an exhaustive index scan only when the top hit clears the concept
-threshold. When the query gist has no concept-level match to anything stored, an
-exhaustive scan would only score more vectors below the bar (profiled at 38–40K
-vectors scored per refusing query on a 325K-context store, costing 44% of
-think). Whether the gist ranks _anything_ at concept level is the discriminator
-— corpus size never was. The list is shared response-wide, so whichever
+claim about the query that resonance cannot state. Its proposal source is the
+response's **one top-k read** (`Precomputed.resonance`, §14.5) — the same ranked
+list recall's earlier tiers already consulted, shared response-wide so whichever
 mechanism first-touches it pays once and every later reader is free.
 
+It used to be a **wide** list, widened to an exhaustive index scan whenever the
+top hit cleared the concept threshold. That was removed: the bridge's own
+candidate cap is `2 · recallQueryK`, so the top-k already IS everything it can
+consume, and every proposal is byte-verified downstream (§4.3) — an exhaustive
+scan bought an O(k) need at O(index) cost (profiled: 244K vectors scored per
+refusing query, ~1.5 s, every answer byte-identical to the top-k read). Test/95
+pins its absence.
+
 #### The substitution bridge
 
 **The gap.** A query phrased through a near-synonym of a trained word ("Name the
@@ -5288,16 +5291,14 @@ recallByResonance(query, pre):
             return { bytes: g, accounted: nothing, moves: STEP }
 
     # ── the REFUSAL PATH ─────────────────────────────────────────────
-    # pre.wideResonance() — the response's ONE wide candidate list, shared
-    # by every mechanism that must look past the top-k:
-    #     hits[0].score ≥ CONCEPT_BAR
-    #       ? exhaustive resonate(gistOf(query), hubBound)       # ids only
-    #       : hits                        # the gist ranks nothing at concept
-    #                                     # level, so a wider scan says nothing
+    # pre.resonance() — the response's ONE top-k read, already paid for by
+    # the tiers above.  The bridge caps its own candidates at 2·recallQueryK,
+    # so the top-k is exactly the budget it can consume; there is no wider
+    # list, and every proposal is byte-verified below.
 
     # 3b. substitution / identity bridge
-    bridged ≔ substitutionBridge(query, pre.wideResonance)
-              # anchors: rarest query windows → edgeAncestors, plus wideIds
+    bridged ≔ substitutionBridge(query, ids(pre.resonance))
+              # anchors: rarest query windows → edgeAncestors, plus those ids
               # align byte-for-byte; a mismatch substitutes only under
               # CORROBORATION ∧ GRADED IDENTITY ∧ RAW BALANCE
               # accept when matched+substituted DOMINATES the query, every

package/dist/src/meter.d.ts

@@ -129,6 +129,13 @@ export declare class Meter {
     /** Nodes popped by those ascents, against their √N·W budget — the counter
      *  that shows whether the walks are deciding early or burning the budget. */
     junctionPops: number;
+    /** Ascents that ended by EXHAUSTING the expansion budget rather than by
+     *  deciding — the walk abstained and the caller silently fell through to a
+     *  lower tier of the ladder (§2.13: a degradation nothing else reports).
+     *  It rises the moment a SHARED budget is drained by an earlier walk, which
+     *  is what makes "this tier answered nothing" distinguishable from "this
+     *  tier never got to look". */
+    junctionBudgetExhausted: number;
     /** Arbitrary byte spans whose distributional company was VSA-bundled from
      *  existing episode halos. */
     spanHalos: number;
@@ -156,6 +163,12 @@ export declare class Meter {
     /** Charge `ms`, one call, and a counter delta to a named phase.
      *  Insertion-ordered, so a report reads in execution order. */
     charge(phase: string, ms: number, delta?: Record<string, number>): void;
+    /** Time one SYNCHRONOUS phase.  The sync/async seam (§2.10) is a real
+     *  contract — perception, recognition and the graph search are synchronous —
+     *  so a synchronous layer must not be wrapped in `time`'s promise just to be
+     *  measured: that would make the profiled path await where the unprofiled
+     *  one does not, and a meter never changes what a layer computes. */
+    timeSync<T>(phase: string, fn: () => T): T;
     /** Time one async phase and attribute the work done inside it.  Returns
      *  the awaited value untouched — a meter never changes what a layer
      *  computes, only what is known about it. */

package/dist/src/meter.js

@@ -122,6 +122,13 @@ export class Meter {
     /** Nodes popped by those ascents, against their √N·W budget — the counter
      *  that shows whether the walks are deciding early or burning the budget. */
     junctionPops = 0;
+    /** Ascents that ended by EXHAUSTING the expansion budget rather than by
+     *  deciding — the walk abstained and the caller silently fell through to a
+     *  lower tier of the ladder (§2.13: a degradation nothing else reports).
+     *  It rises the moment a SHARED budget is drained by an earlier walk, which
+     *  is what makes "this tier answered nothing" distinguishable from "this
+     *  tier never got to look". */
+    junctionBudgetExhausted = 0;
     /** Arbitrary byte spans whose distributional company was VSA-bundled from
      *  existing episode halos. */
     spanHalos = 0;
@@ -173,6 +180,26 @@ export class Meter {
             }
         }
     }
+    /** Time one SYNCHRONOUS phase.  The sync/async seam (§2.10) is a real
+     *  contract — perception, recognition and the graph search are synchronous —
+     *  so a synchronous layer must not be wrapped in `time`'s promise just to be
+     *  measured: that would make the profiled path await where the unprofiled
+     *  one does not, and a meter never changes what a layer computes. */
+    timeSync(phase, fn) {
+        const before = this.snapshot();
+        const t = performance.now();
+        try {
+            return fn();
+        }
+        finally {
+            const ms = performance.now() - t;
+            const after = this.snapshot();
+            const delta = {};
+            for (const k of Object.keys(after))
+                delta[k] = after[k] - before[k];
+            this.charge(phase, ms, delta);
+        }
+    }
     /** Time one async phase and attribute the work done inside it.  Returns
      *  the awaited value untouched — a meter never changes what a layer
      *  computes, only what is known about it. */

package/dist/src/mind/junction.js

@@ -185,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/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;
@@ -218,16 +227,25 @@ export const prefixMechanism = {
         return STEP;
     },
     async run(ctx, query, pre) {
-        // 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));
+        // 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/pipeline.d.ts

@@ -52,8 +52,9 @@ export interface RegimePredictionData {
     /** 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). */
+    /** 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

package/dist/src/mind/pipeline.js

@@ -97,8 +97,11 @@ export async function think(ctx, query, mechs) {
     // 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
-        ? await meter.time("recognise", async () => recognise(ctx, query))
+        ? meter.timeSync("recognise", () => recognise(ctx, query))
         : recognise(ctx, query);
     // Phase 1: collect computed spans from mechanisms that implement parse()
     const computed = meter
@@ -163,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.
-    let regimeReported = false;
-    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);
@@ -204,43 +254,11 @@ export async function think(ctx, query, mechs) {
                 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;
-            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 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,
-            });
-        }
     }
+    // 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;
@@ -385,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,13 +10,22 @@ 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. */
-/** 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 declare function recognise(ctx: MindContext, bytes: Uint8Array, trimmed?: boolean): Recognition;
+ *  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
  *  into one segment.  Each segment's gist is perceived from its bytes

package/dist/src/mind/recognition.js

@@ -21,13 +21,22 @@ 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. */
-/** 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, bytes, trimmed = false) {
+ *  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,
     // regardless of tracing — matching perceive()'s own memo, which carries no
@@ -67,7 +76,7 @@ export function recognise(ctx, bytes, trimmed = false) {
     // not silent), so it is emitted here directly rather than only inside
     // recogniseImpl.
     if (ctx.recogniseMemo) {
-        const key = (trimmed ? "t" : "f") + latin1Key(bytes);
+        const key = latin1Key(bytes);
         const hit = ctx.recogniseMemo.get(key);
         if (hit !== undefined) {
             if (ctx.meter)
@@ -79,13 +88,13 @@ export function recognise(ctx, bytes, trimmed = false) {
                 `lead somewhere (over ${hit.leaves.length} perceived leaves) [cached]`);
             return hit;
         }
-        const fresh = recogniseImpl(ctx, bytes, trimmed);
+        const fresh = recogniseImpl(ctx, bytes);
         ctx.recogniseMemo.set(key, fresh);
         return fresh;
     }
-    return recogniseImpl(ctx, bytes, trimmed);
+    return recogniseImpl(ctx, bytes);
 }
-function recogniseImpl(ctx, bytes, trimmed = false) {
+function recogniseImpl(ctx, bytes) {
     if (ctx.meter) {
         ctx.meter.recognitions++;
         ctx.meter.recognisedBytes += bytes.length;
@@ -199,7 +208,7 @@ function recogniseImpl(ctx, bytes, trimmed = false) {
             // n.kids !== null enforces above) rather than degenerate into
             // single-byte-atom territory, which atomIsHub already governs
             // separately.
-            else if (!trimmed && end - start - 1 >= 2) {
+            else if (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

package/dist/src/mind/resonance.js

@@ -288,13 +288,13 @@ export async function pivotInto(ctx, answer, consumed, voiced = []) {
         for (const c of n.kids)
             queue.push(c); // breadth-first: larger regions first
     }
-    // TRIMMED recognition: the pivot's own filter below rejects fragments
-    // (`hasParents || hasContainers → -Infinity`), and recognition's edge-trim
-    // fallbacks exist to find exactly those misaligned FRAGMENTS.  Skipping them
-    // (the structural pass + canonResolve still run) is byte-identical for every
-    // pivot — the fallbacks' output is discarded by the filter — and halves the
-    // O(n·W²) recognition of a long answer (measured: 36KB recognise 4.0s → 2.0s).
-    const rec = recognise(ctx, answer, true);
+    // 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)) {
             scored.set(s.payload, Math.max(scored.get(s.payload) ?? 0, 1));
@@ -322,6 +322,13 @@ export async function pivotInto(ctx, answer, consumed, voiced = []) {
     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`

package/dist/src/store.d.ts

@@ -570,9 +570,6 @@ export declare abstract class AbstractStore implements Store {
     nodeCount(): number;
     size(): Promise<number>;
     get(id: NodeId): NodeRec | null;
-    /** Reconstruct the bytes a node spans by traversing the DAG bottom-up.
-     *  Iterative post-order on an explicit stack — the call stack never sees the
-     *  tree depth, so even an adversarial chain of nodes stays safe. */
     /** How many reads hit a MISSING node record this session (a dangling edge
      *  or kid id).  Zero in a healthy store; a growing count means references
      *  outlive their records — the read degrades safely to empty bytes, this
@@ -582,6 +579,25 @@ export declare abstract class AbstractStore implements Store {
      *  nothing is profiling.  Every read below bumps it through `?.`, so an
      *  unprofiled store pays one null check per read and allocates nothing. */
     meter: Meter | null;
+    /** Reconstruct the bytes a node spans by traversing the DAG bottom-up.
+     *  Iterative post-order on an explicit stack — the call stack never sees the
+     *  tree depth, so even an adversarial chain of nodes stays safe.
+     *
+     *  TERMINATION.  The walk memoizes into a LOCAL map, and `_bytesCache` is
+     *  consulted only as a warm hint whose hit is immediately promoted into that
+     *  map.  It used to use `_bytesCache` itself as the memo, which is not a
+     *  memo at all: it EVICTS, and its `"smallest"` policy prefers precisely the
+     *  freshly-resolved small children that the pending parents on the stack are
+     *  waiting for.  A parent then finds them uncached again, re-pushes them,
+     *  they are re-resolved, re-inserted, re-evicted — the loop makes no
+     *  progress and never exits.  Latent until the cache saturates, then
+     *  unconditional: observed in the wild at 19.9M nodes with the 20 MB cache
+     *  pinned at 19,999,962/20,000,000 bytes, spinning 8h45m on a node whose
+     *  whole content was 124 bytes (5 kids, 2 of them perpetually re-evicted).
+     *  Because the loop is synchronous, no timer could fire — the trainer's stall
+     *  watchdog never got a turn either.  A local map resolves each node at most
+     *  once per call, so the walk terminates by construction and `_bytesCache`
+     *  goes back to being a pure speed hint. */
     bytes(id: NodeId): Uint8Array;
     /** First `maxLen` bytes of a node.  Walks only the leftmost branch,
      *  stopping at `maxLen` — so a 1 MB document root costs the same as a
@@ -665,7 +681,20 @@ export declare abstract class AbstractStore implements Store {
      *  common-prefix / common-suffix trim: whatever remains after both trims is
      *  the single differing span (substitution, insertion or deletion), and both
      *  remainders must fit the budget.  Scattered differences leave a wide
-     *  middle and are rejected. */
+     *  middle and are rejected.
+     *
+     *  Every read here is CAPPED (§2.8).  It used to open with
+     *  `bytesPrefix(k, Number.MAX_SAFE_INTEGER)` — the ALL sentinel, i.e. the
+     *  full materialising `bytes()` read — on the deposit hot path, and only
+     *  then compare lengths.  So a candidate the length test was about to reject
+     *  had already been reconstructed byte for byte.  The LENGTHS decide first
+     *  instead, from the `contentLen` memo the interning order has already built
+     *  bottom-up, and the target's length is itself read under a cap: a target
+     *  longer than `la + W` is rejected without touching one of its bytes.
+     *  Same semantics — the old capped `b` read would have produced
+     *  `a.length + W + 1` here and failed the very same test — strictly fewer
+     *  byte reads.  The `+ 1` on each byte cap keeps `_prefix`'s
+     *  "complete reconstruction" test true, so the results still cache. */
     private differsByOneWindow;
     putLeaf(bytes: Uint8Array, gist: Vec): Promise<NodeId>;
     putBranch(kids: NodeId[], gist: Vec): Promise<NodeId>;