@hviana/sema 0.7.1 → 0.7.3

package/dist/src/store.js

@@ -591,9 +591,6 @@ export class AbstractStore {
             this._recCache.set(id, rec);
         return rec;
     }
-    /** 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
@@ -603,6 +600,25 @@ export class AbstractStore {
      *  nothing is profiling.  Every read below bumps it through `?.`, so an
      *  unprofiled store pays one null check per read and allocates nothing. */
     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) {
         if (this.meter) {
             this.meter.byteReads++;
@@ -619,10 +635,22 @@ export class AbstractStore {
             return hit;
         const stack = [id];
         const cache = this._bytesCache;
+        // The walk's own memo.  Entries are the same shared arrays `_bytesCache`
+        // holds (no extra copy), and it lives exactly as long as this call.
+        const done = new Map();
         while (stack.length > 0) {
             const nid = stack[stack.length - 1]; // peek
-            // Already resolved by an earlier traversal.
-            if (cache.get(nid)) {
+            // Already resolved by this walk — the ONLY authority the readiness test
+            // below trusts, because it cannot be evicted underneath us.
+            if (done.has(nid)) {
+                stack.pop();
+                continue;
+            }
+            // Warm hint: a hit is promoted into `done` in the same step, so from
+            // here on the entry is pinned for the rest of the walk.
+            const warm = cache.get(nid);
+            if (warm !== undefined) {
+                done.set(nid, warm);
                 stack.pop();
                 continue;
             }
@@ -634,21 +662,26 @@ export class AbstractStore {
                 // The cache makes the empty read permanent for the session; the
                 // counter survives as the visible trace.
                 this.danglingReads++;
+                done.set(nid, _ZERO);
                 cache.set(nid, _ZERO);
                 stack.pop();
                 continue;
             }
             if (rec.leaf) {
-                cache.set(nid, new Uint8Array(rec.leaf));
+                // COPY before caching: rec.leaf is the node record's own buffer, and
+                // handing it out would let one mutating caller corrupt the record.
+                const leaf = new Uint8Array(rec.leaf);
+                done.set(nid, leaf);
+                cache.set(nid, leaf);
                 stack.pop();
                 continue;
             }
-            // Branch — push any uncached children (reverse order so they resolve
-            // left-to-right).  If every child is already cached, concatenate now.
+            // Branch — push any unresolved children (reverse order so they resolve
+            // left-to-right).  If every child is resolved, concatenate now.
             const kids = rec.kids ?? [];
             let ready = true;
             for (let i = kids.length - 1; i >= 0; i--) {
-                if (!cache.get(kids[i])) {
+                if (!done.has(kids[i])) {
                     stack.push(kids[i]);
                     ready = false;
                 }
@@ -656,10 +689,11 @@ export class AbstractStore {
             if (!ready)
                 continue;
             stack.pop();
-            const out = concat(kids.map((k) => cache.get(k)));
+            const out = concat(kids.map((k) => done.get(k)));
+            done.set(nid, out);
             cache.set(nid, out);
         }
-        const out = cache.get(id) ?? _ZERO;
+        const out = done.get(id) ?? _ZERO;
         if (this.meter)
             this.meter.bytesRead += out.length;
         return out;
@@ -1189,10 +1223,33 @@ export class AbstractStore {
      *  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. */
     differsByOneWindow(kids, targetId, W) {
-        const a = concat(kids.map((k) => this.bytesPrefix(k, Number.MAX_SAFE_INTEGER)));
-        const b = this.bytesPrefix(targetId, a.length + W + 1);
+        const lens = kids.map((k) => this.contentLen(k));
+        let la = 0;
+        for (const n of lens)
+            la += n;
+        const cap = la + W + 1;
+        // `contentLen` under a cap returns a clamped LOWER BOUND once the partial
+        // sum reaches it, so `>= cap` is exactly "longer than la + W".
+        const lb = this.contentLen(targetId, cap);
+        if (lb >= cap || Math.abs(la - lb) > W)
+            return false;
+        const a = concat(kids.map((k, i) => this.bytesPrefix(k, lens[i] + 1)));
+        const b = this.bytesPrefix(targetId, lb + 1);
         if (Math.abs(a.length - b.length) > W)
             return false;
         const n = Math.min(a.length, b.length);

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.3",
   "exports": "./src/index.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "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`