@hviana/sema 0.7.1 → 0.7.2

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/jsr.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://jsr.io/schema/config-file.v1.json",
   "name": "@hviana/sema",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "exports": "./src/index.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "repository": {
     "type": "git",

package/src/meter.ts

@@ -176,6 +176,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;
@@ -231,6 +238,25 @@ 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<T>(phase: string, fn: () => T): T {
+    const before = this.snapshot();
+    const t = performance.now();
+    try {
+      return fn();
+    } finally {
+      const ms = performance.now() - t;
+      const after = this.snapshot();
+      const delta: Record<string, number> = {};
+      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/src/mind/junction.ts

@@ -264,7 +264,18 @@ export function junctionContainersFrom(
     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++;
     const f = cachedRead(ctx, cache, x, maxContainer);

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

@@ -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:
 //
@@ -114,7 +122,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 function prefixCompletion(
   ctx: MindContext,
@@ -264,16 +273,25 @@ export const prefixMechanism: PipelineMechanism = {
     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 [{
       bytes: completed.form,

package/src/mind/pipeline.ts

@@ -144,8 +144,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
@@ -190,8 +191,11 @@ export async function think(
   // 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()
@@ -294,12 +298,66 @@ export async function think(
   const worthRunning = (floor: number) =>
     best === null || grade(floor) < grade(best.weight);
 
+  // REGIME PREDICTION (R8) — observational only.  Once the FIRST mechanism has
+  // had its turn (cover, which §2.6 places first and floors at 0), the market's
+  // outcome is already determined by the one cost ladder: the consensus climb
+  // runs exactly when `worthRunning(2 * STEP)` is true — CAST (floor 2·STEP) is
+  // the cheapest mechanism that first-touches it, so an incumbent at or below
+  // grade 2 prunes CAST and, with it, confluence (3·STEP) and extraction
+  // (CONCEPT+STEP) (retrieval); anything above — or no incumbent — runs the
+  // full market and the climb (composition).  The predicate is `worthRunning`,
+  // the same function the loop itself uses — nothing is computed here that the
+  // engine had not already computed, and nothing is read back by inference.
+  //
+  // 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 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 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,
+      } satisfies RegimePredictionData,
+    );
+  };
   // 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`,
@@ -347,52 +405,11 @@ 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,
-      );
-    }
   }
+  // 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.)
@@ -592,7 +609,7 @@ export async function think(
       reasoned,
       pre,
       unclimbed,
-      decided.accounted,
+      primarySpans,
     );
 
   done(

package/src/mind/recognition.ts

@@ -32,16 +32,24 @@ import type { Leaf, Site } from "./graph-search.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. */
+ *  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: 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,
@@ -82,7 +90,7 @@ export function recognise(
   // 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) ctx.meter.recogniseHits++;
@@ -100,18 +108,14 @@ export function recognise(
       );
       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: MindContext,
-  bytes: Uint8Array,
-  trimmed = false,
-): Recognition {
+function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
   if (ctx.meter) {
     ctx.meter.recognitions++;
     ctx.meter.recognisedBytes += bytes.length;
@@ -224,7 +228,7 @@ function recogniseImpl(
       // 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/src/mind/resonance.ts

@@ -365,13 +365,13 @@ export async function pivotInto(
     }
     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));
@@ -399,6 +399,12 @@ export async function pivotInto(
   let pivotId: number | null = 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`