@hviana/sema 0.9.0 → 0.9.1

package/dist/src/mind/pipeline.js

@@ -11,12 +11,12 @@
 import { PASS, STEP } from "./graph-search.js";
 import { gistOf, read, resolve } from "./primitives.js";
 import { recognise } from "./recognition.js";
-import { fuseAttention, reason } from "./reasoning.js";
-import { closed, remainderOf, unaccountedBytes, unexplainedSpans, windowOf, } from "./derivation.js";
+import { fusionLayer, walkLayer } from "./reasoning.js";
+import { closed, closeOver, remainderOf, unaccountedBytes, unexplainedSpans, windowOf, } from "./derivation.js";
 import { rItem } from "./trace.js";
 import { unexplainedLabel } from "./rationale.js";
 import { hubBound } from "./traverse.js";
-import { Precomputed } from "./pipeline-mechanism.js";
+import { Precomputed, } from "./pipeline-mechanism.js";
 import { coverMechanism } from "./mechanisms/cover.js";
 import { castMechanism } from "./mechanisms/cast.js";
 import { confluenceMechanism } from "./mechanisms/confluence.js";
@@ -26,7 +26,7 @@ import { prefixMechanism } from "./mechanisms/prefix-completion.js";
 import { recallMechanism } from "./mechanisms/recall.js";
 // Re-exports: cover's pre-resolution helpers and the ALU adapter kept
 // importable from the pipeline module (their historical home).
-export { resolveConcepts, resolveConnectors } from "./mechanisms/cover.js";
+export { offerConcepts, offerConnectors } from "./mechanisms/cover.js";
 export { aluToMechanism } from "./mechanisms/alu.js";
 // ── Extension dispatch (pre-loop parse) ─────────────────────────────────────
 async function collectComputed(ctx, mechanisms, query) {
@@ -197,12 +197,14 @@ export async function think(ctx, query, mechs) {
         // below.
         const incumbent = best;
         const incumbentGrade = incumbent === null ? null : grade(incumbent.weight);
-        const regime = worthRunning(2 * STEP)
+        const regime = worthDeclared(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`
+            ? (incumbentGrade !== null && incumbentGrade <= climbFloorGrade
+                ? `retrieval regime — incumbent grade ${incumbentGrade} ≤ climb floor ${climbFloorGrade}, `
+                : `retrieval regime — grade ${bound} already reached by a mechanism run ahead, below climb floor ${climbFloorGrade}, `) +
+                `so no mechanism floored above that grade runs; CAST will not climb`
             : `composition regime — ${incumbentGrade === null
                 ? "no incumbent (nothing grounded)"
                 : `incumbent grade ${incumbentGrade}`} above climb floor ${climbFloorGrade}, so the full market and climb run`, undefined, {
@@ -210,38 +212,147 @@ export async function think(ctx, query, mechs) {
             regime,
             incumbentGrade,
             climbFloorGrade,
+            ...(bound !== Infinity ? { boundGrade: bound } : {}),
         });
     };
     // 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.
-    for (let mi = 0; mi < mechanisms.length; mi++) {
-        const mech = mechanisms[mi];
-        if (mi > 0)
-            reportRegime();
+    //
+    // A CHEAPER BOUND IS LOOKED AT BEFORE A DEARER ONE IS PAID FOR.
+    //
+    // The declared order is the tie-break priority, and the pruning above is
+    // only as strong as the incumbent it has: a mechanism floored LOWER than the
+    // one about to invest, but declared after it, could not prune it.  Measured
+    // on the 31.7M-node store: a lowercased dialogue turn (#97 of the battery)
+    // was won by recall at grade 1 — after CAST (floor grade 2) had paid the
+    // consensus climb and the weave, confluence (3) a reach climb, and extraction
+    // and reference their reads: ~10 s of a 12.6 s response, for candidates that
+    // could not win.
+    //
+    // So before mechanism `m` first-touches anything, every LATER mechanism whose
+    // bound is strictly lower runs AHEAD of it, cheapest bound first, and the
+    // lowest grade any of them reaches becomes `bound`.  A mechanism whose floor
+    // grade exceeds `bound` is then skipped.  THE DECISION IS UNCHANGED — the
+    // same candidate wins as in the declared order:
+    //   • a mechanism `p` run ahead with best grade g bounds the final grade by
+    //     g: in the declared order p either runs (its candidate is weighed) or is
+    //     pruned by an incumbent already at or below p's floor ≤ g;
+    //   • so a mechanism floored above `bound` has only candidates the final
+    //     winner strictly outgrades — and with every candidate above `bound`
+    //     dropped, every mechanism floored at or below it meets the same
+    //     run-or-prune decision (`f < incumbent` iff `f < min(incumbent,
+    //     bound + 1)` for f ≤ bound) and yields the same candidates;
+    //   • and the winner is chosen from the candidates at or below `bound`, in
+    //     declared order — `consider` replays them where they are declared.
+    // Equal-grade floors are NOT skipped (≤, not <): a mechanism declared earlier
+    // keeps the tie it would have won.  Running `p` ahead is never extra work:
+    // what prunes p in the declared order is a candidate at or below p's floor,
+    // which only a mechanism floored at or below it can produce — and every such
+    // mechanism is either already run or run ahead of p.
+    //
+    // The bound is learnt by asking `floor` with a `worthRunning` that refuses:
+    // under the investment discipline (pipeline-mechanism.ts) a floor that cannot
+    // pay returns its bound UNINVESTED, so the question costs no analysis.
+    const refuse = () => false;
+    const probed = new Array(mechanisms.length);
+    const probeGrade = async (i) => {
+        if (probed[i] === undefined) {
+            const f = await mechanisms[i].floor(ctx, query, pre, refuse);
+            probed[i] = f === null ? null : grade(f);
+        }
+        return probed[i];
+    };
+    /** Per mechanism: its floor once computed, and its results once run. */
+    const floors = new Map();
+    const runs = new Map();
+    let bound = Infinity;
+    const worthAhead = (floor) => grade(floor) <
+        Math.min(best === null ? Infinity : grade(best.weight), bound);
+    const worthDeclared = (floor) => worthRunning(floor) && grade(floor) <= bound;
+    const floorOf = async (i, worth) => {
+        if (floors.has(i))
+            return floors.get(i);
+        const mech = mechanisms[i];
         const floor = meter
-            ? await meter.time(`${mech.name}.floor`, () => mech.floor(ctx, query, pre, worthRunning))
-            : await mech.floor(ctx, query, pre, worthRunning);
+            ? await meter.time(`${mech.name}.floor`, () => mech.floor(ctx, query, pre, worth))
+            : await mech.floor(ctx, query, pre, worth);
         if (meter) {
             if (floor === null)
                 meter.mechanismSkips++;
             else
                 meter.mechanismFloors++;
         }
+        floors.set(i, floor);
+        return floor;
+    };
+    const runOf = async (i) => {
+        let results = runs.get(i);
+        if (results === undefined) {
+            const mech = mechanisms[i];
+            if (meter)
+                meter.mechanismRuns++;
+            results = meter
+                ? await meter.time(`${mech.name}.run`, () => mech.run(ctx, query, pre))
+                : await mech.run(ctx, query, pre);
+            runs.set(i, results);
+        }
+        return results;
+    };
+    const runAhead = async (mi) => {
+        const g = await probeGrade(mi);
+        if (g === null)
+            return;
+        const ahead = [];
+        for (let j = mi + 1; j < mechanisms.length; j++) {
+            if (floors.has(j))
+                continue;
+            const gj = await probeGrade(j);
+            if (gj !== null && gj < g)
+                ahead.push([gj, j]);
+        }
+        ahead.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+        for (const [gj, j] of ahead) {
+            // Only what the declared order would also run: a bound that cannot beat
+            // what is already held is not even asked for its real floor.
+            if (!(gj < Math.min(best === null ? Infinity : grade(best.weight), bound))) {
+                continue;
+            }
+            const floor = await floorOf(j, worthAhead);
+            if (floor === null || !worthAhead(floor))
+                continue;
+            ctx.trace?.step("runAhead", [], [], `${mechanisms[j].name} runs ahead of ${mechanisms[mi].name} — its floor (grade ${grade(floor)}) is below ${mechanisms[mi].name}'s (grade ${g}), so its result bounds what ${mechanisms[mi].name} could win`);
+            for (const r of await runOf(j)) {
+                // `consider` drops an empty answer, so it bounds nothing.
+                if (r.bytes.length === 0)
+                    continue;
+                bound = Math.min(bound, grade(weigh(r.accounted, r.moves)));
+            }
+        }
+    };
+    for (let mi = 0; mi < mechanisms.length; mi++) {
+        const mech = mechanisms[mi];
+        if (mi > 0) {
+            await runAhead(mi);
+            reportRegime();
+        }
+        const floor = await floorOf(mi, worthDeclared);
         if (floor === null) {
             ctx.trace?.step("skipMechanism", [], [], `${mech.name} skipped — structural precondition failed`);
             continue;
         }
+        if (grade(floor) > bound) {
+            if (meter)
+                meter.mechanismsBounded++;
+            ctx.trace?.step("skipMechanism", [], [], `${mech.name} skipped — floor ${floor} cannot beat grade ${bound}, already reached by a mechanism run ahead`);
+            continue;
+        }
         if (!worthRunning(floor)) {
             ctx.trace?.step("skipMechanism", [], [], `${mech.name} skipped — floor ${floor} cannot beat incumbent (grade ${grade(best.weight)})`);
             continue;
         }
-        if (meter)
-            meter.mechanismRuns++;
-        const results = meter
-            ? await meter.time(`${mech.name}.run`, () => mech.run(ctx, query, pre))
-            : await mech.run(ctx, query, pre);
+        const results = await runOf(mi);
         for (const r of results) {
             // ONE FORMULA, EVERY CANDIDATE: the chart's derivation reports how many
             // discrete moves it made and which bytes it could not recognise; the
@@ -352,19 +463,18 @@ export async function think(ctx, query, mechs) {
     // without evidence stays owed, and a later transition pays it only by carrying
     // it (the law reads the window; see derivation.ts).  Same reading, one
     // definition — not a second spelling of it here.
-    const explained = [
+    const priced = [
         ...decided.accounted,
         ...pre.computed.map((u) => [u.i, u.j]),
-    ].filter(([a, b]) => windowOf([a, b], answer, query, ctx.space.maxGroup) !== null);
+    ];
+    const explained = priced.filter(([a, b]) => windowOf([a, b], answer, query, ctx.space.maxGroup) !== null);
+    const paid = remainderOf(query.length, explained, ctx.space.maxGroup);
     // WHAT THE CONSTRUCTION WITHHOLDS, at or above one quantum: the difference between
     // the remainder paid in full and the remainder paid by carrying.  Both readings
-    // are the law's, so the floor is applied once and in one place.
-    const paidInFull = remainderOf(query.length, [
-        ...decided.accounted,
-        ...pre.computed.map((u) => [u.i, u.j]),
-    ], ctx.space.maxGroup);
-    const paid = remainderOf(query.length, explained, ctx.space.maxGroup);
+    // are the law's, so the floor is applied once and in one place — and the
+    // paid-in-full reading is computed only when a meter will read it.
     if (ctx.meter) {
+        const paidInFull = remainderOf(query.length, priced, ctx.space.maxGroup);
         ctx.meter.groundingWithheldBytes += unaccountedBytes(paid) -
             unaccountedBytes(paidInFull);
     }
@@ -451,73 +561,51 @@ export async function think(ctx, query, mechs) {
         meter.postGroundingRemainderSpans += uncovered.length;
         meter.postGroundingRemainderBytes += unaccountedBytes(uncovered);
     }
-    // THE WALK THAT DOES NOT RUN, NAMED — the audit's point 1 could not attribute
-    // real questions that stopped with no note anywhere.  They never reached the
-    // offer: `decided.complete` says the grounding supplied a fixed point, so the
-    // walk is skipped BY DESIGN and the state is the grounding's own.  That state
-    // carries `fixed: true` (the trace already reports it), and the law's first
-    // clause refuses any continuation against it — so there is no `null` here to
-    // read as exhaustion, and the `Offer` contract is not in play at all.  The
-    // silent stop is therefore a NAMED state, not a gap.
+    // ── THE CLOSURE ENGINE ───────────────────────────────────────────────
+    //
+    // The grounding's state is CLOSED under the law by two layers, in order: the
+    // multi-hop WALK (`walkLayer`: a forward absorb or a pivot, offered one at a
+    // time) and the multi-topic FUSION (`fusionLayer`: one composed transition).
+    // Every step either layer offers goes through the same `closure` and the same
+    // law; this function no longer sequences them or gates them by hand.
+    //
+    // WHAT USED TO BE TWO HAND-WRITTEN GATES IS NOW THE LAW'S, OR THE LAYER'S:
+    //   • a declared-complete grounding (`fixed`) admits no transition — the
+    //     engine enters no layer for it (the law's first clause), which is the
+    //     walk-skip and the fusion-skip this branch used to spell separately;
+    //   • a CLOSED derivation has nothing left for a second topic to account for,
+    //     so the fusion layer does not ENGAGE — read off the state the walk
+    //     reached, the one fusion is actually offered against.
+    //
+    // What the fusion needs from the grounding — whether its substance is purely
+    // computed (`unclimbed`) and where it stands in the query (`primarySpans`) —
+    // is the grounding's own evidence, resolved here where both readings are in
+    // hand.
     //
-    // THE WALK CONSUMES AND RETURNS A STATE.  It is handed the derivation's own —
-    // the grounding's product, accounting, remainder and cost — and hands back the
-    // state it advanced to, so what follows reads a state rather than bytes plus a
-    // tuple rebuilt here.  A supplied fixed point is the one case where the walk
-    // does not run at all, and then the state is the grounding's own.
-    const extension = decided.complete ? undefined : meter
-        ? await meter.time("reason", () => reason(ctx, query, state, preConsumed, pre, voiced))
-        : await reason(ctx, query, state, preConsumed, pre, voiced);
-    const reasoned = extension ?? state;
-    // Fuse only when the query has a genuine REMAINDER no mechanism's
-    // structural evidence touched at all.  `decided.accounted` alone
-    // undercounts this: it is a COST-LADDER quantity (cover.ts prices its
-    // masked/computed spans at near-zero and deliberately leaves them out of
-    // `accounted` so PASS-bridged bytes are still charged), not a coverage
-    // one — a query fully explained by one computed span plus bridged
-    // connectors can report `accounted: []` while nothing is actually left
-    // unexplained.  The genuine remainder is what NEITHER the winning
-    // candidate's accounted spans NOR any recognised extension's computed
-    // span (`pre.computed` — every mechanism's parse() output, ALU included)
-    // ever touched.  A remainder under one river-fold quantum (W, the same
-    // floor cover.ts's restatedSpan and the honesty-density bar above both
-    // use) is bridging punctuation/whitespace, never a second topic —
-    // observed: a single space between two fully-computed arithmetic spans
-    // ("2+2 3+3") registered as "unaccounted" and pulled in an unrelated
-    // corpus fact, corrupting "4 6" into "4 63".
-    // THE GATE ASKS THE LAW, and that is an OPTIMISATION, not a tidy-up: the state
-    // above ALREADY carries the remainder (`remainderOf`, per-span, with the W
-    // floor applied), so asking it costs nothing, while the total this line used to
-    // compute (`unaccounted(explained)`) was one more sum over the spans on every
-    // response.  The two readings are the same condition, not two: the ACCOUNTING
-    // applies the same W floor the gate does, so a gap below one quantum never
-    // survives into `explained` and the total cannot reach W without some single
-    // gap reaching it.  Measured over twelve constructions at W = 4 (test/136.3,
-    // which pins the equivalence and both sides of it).
-    // Whether the winning candidate's entire recognised substance is
-    // COMPUTED — every accounted span exactly a pre.computed span, nothing
-    // from a genuinely recognised/climbed site.  fuseAttention's lone-root
-    // shortcut assumes a single point of attention already IS primary's own
-    // source; that assumption is exactly backwards for a pure computation
-    // (an ALU result has no anchor of its own) — see fuseAttention's
-    // `unclimbed` parameter, gated there by Attention.breadth so a
-    // coincidental echo (which this flag alone cannot distinguish) is still
-    // rejected.
+    // Whether the winning candidate's entire recognised substance is COMPUTED —
+    // every accounted span exactly a pre.computed span, nothing from a genuinely
+    // recognised/climbed site.  fuseAttention's lone-root shortcut assumes a
+    // single point of attention already IS primary's own source; that assumption
+    // is exactly backwards for a pure computation (an ALU result has no anchor of
+    // its own) — gated there by Attention.breadth so a coincidental echo (which
+    // this flag alone cannot distinguish) is still rejected.
     const unclimbed = state.accounted.length > 0 &&
         state.accounted.every(([i, j]) => pre.computed.some((u) => u.i === i && u.j === j));
-    // Where the winning grounding stands in the query — fusion places primary
-    // by it (see fuseAttention's `primarySpans`).  `accounted` is the
-    // cost-ladder read and is authoritative when non-empty; when it is empty
-    // the grounding is a pure COMPUTATION, whose evidence is its computed span.
-    // Exactly the cost-ladder-vs-coverage distinction `explained` above draws,
-    // read here for POSITION instead of for coverage — and resolved here, where
-    // both readings are in hand, rather than inside fuseAttention.
+    // Where the winning grounding stands in the query — fusion places primary by
+    // it.  `accounted` is the cost-ladder read and is authoritative when
+    // non-empty; when it is empty the grounding is a pure COMPUTATION, whose
+    // evidence is its computed span — the cost-ladder-vs-coverage distinction
+    // `explained` above draws, read here for POSITION instead of coverage.
     const primarySpans = state.accounted.length > 0
         ? state.accounted
         : pre.computed.map((u) => [u.i, u.j]);
-    const fused = closed(state) ? reasoned : meter
-        ? await meter.time("fuse", () => fuseAttention(ctx, query, reasoned, pre, unclimbed, primarySpans))
-        : await fuseAttention(ctx, query, reasoned, pre, unclimbed, primarySpans);
+    const fused = await closeOver(state, query, ctx.space.maxGroup, [
+        walkLayer(ctx, query, preConsumed, pre, voiced),
+        {
+            ...fusionLayer(ctx, query, pre, unclimbed, primarySpans),
+            engages: (d) => !closed(d),
+        },
+    ], meter ? (name, walk) => meter.time(name, walk) : undefined);
     done(fused.product, 
     // NO CLAIM ABOUT FUSION HERE.  `fuseAttention` is entered whenever a
     // remainder ≥ W exists and returns early when there is nothing to bridge, so

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

@@ -1,11 +1,6 @@
 import { Vec } from "../vec.js";
 import { Sema } from "../sema.js";
 import type { Input, MindContext } from "./types.js";
-/** The content key of a byte span — one latin1 char per byte, an exact,
- *  collision-free encoding.  Spans on the perception path are query-scale
- *  (windows, regions, candidate spans), so key construction is far cheaper
- *  than the river fold it deduplicates. */
-export declare function latin1Key(bytes: Uint8Array): string;
 /** The {@link perceive} memo key: the span's content PLUS the boundary set it
  *  was folded under.  The tree is a function of BOTH — the same bytes fold
  *  plainly with no boundaries and into a left-nested stable-prefix shape with
@@ -59,6 +54,31 @@ export declare function foldTree(ctx: MindContext, n: Sema, start: number, visit
     end: number;
     node: number | null;
 };
+/** The EXACT content-addressed node of a byte stream — `foldTree(perceive)`,
+ *  read for identity alone.
+ *
+ *  A fold names a branch only when every child is named, so identity needs the
+ *  fold's SHAPE and the store's answer per node, never its vectors:
+ *  {@link contentIdentity} walks the same shape (geometry.ts — one grouping
+ *  rule, two algebras) and asks the store bottom-up, building no D-dimensional
+ *  gist and leaving nothing in the perception memo.  Each node is named the
+ *  way the store's write side names it ({@link branchNaming}).  `test/148` pins
+ *  the agreement with the full fold over random and corpus spans. */
+export declare function exactNode(ctx: MindContext, bytes: Uint8Array): number | null;
+/** {@link exactNode}, with whether the span's own name was found only through
+ *  its BYTES — its children named no branch, and the flat node over the same
+ *  bytes did ({@link branchNaming}).  That is where the exact lookup used to
+ *  MISS, so it is where {@link resolve} still asks the canonical class: the
+ *  class may hold the learnt member that leads somewhere, which a flat index
+ *  entry need not (measured: `tonight` named an edge-less window and
+ *  pre-empted the case-folded `Tonight` whose edge a composition stood on).
+ *  Recognition's probes reach it through `resolve`; asking it again for the
+ *  perceived tree's own byte-named groups changed none of 116 real queries and
+ *  no test, so it is not asked there. */
+export declare function exactNaming(ctx: MindContext, bytes: Uint8Array): {
+    id: number | null;
+    byBytes: boolean;
+};
 /** The canonical node id of a byte span: perceive it in isolation — the way
  *  training did — and recover its root bottom-up.  Returns null if any part is
  *  unknown. */

package/dist/src/mind/primitives.js

@@ -2,25 +2,11 @@
 //
 //   Address  — bytes → node   (perceive, foldTree, resolve)
 //   Read     — node → bytes   (read)
-import { bytesToTree, contentFoldIncremental, gridToTree, hilbertBytes, stackGrids, } from "../geometry.js";
+import { bytesToTree, contentFoldIncremental, contentIdentity, gridToTree, hilbertBytes, stackGrids, } from "../geometry.js";
 import { canonHash } from "../canon.js";
-import { bytesEqual } from "../bytes.js";
+import { bytesEqual, concatBytes, latin1 } from "../bytes.js";
 import { ALL } from "./types.js";
 // ── Address: bytes → node ──────────────────────────────────────────────
-/** The content key of a byte span — one latin1 char per byte, an exact,
- *  collision-free encoding.  Spans on the perception path are query-scale
- *  (windows, regions, candidate spans), so key construction is far cheaper
- *  than the river fold it deduplicates. */
-export function latin1Key(bytes) {
-    // Batched String.fromCharCode — avoids the O(n²) cost of repeated += on
-    // potentially-large query spans, and stays well under the ~65536 arg limit.
-    const n = bytes.length;
-    let s = "";
-    for (let i = 0; i < n; i += 4096) {
-        s += String.fromCharCode(...bytes.subarray(i, Math.min(i + 4096, n)));
-    }
-    return s;
-}
 /** The {@link perceive} memo key: the span's content PLUS the boundary set it
  *  was folded under.  The tree is a function of BOTH — the same bytes fold
  *  plainly with no boundaries and into a left-nested stable-prefix shape with
@@ -32,7 +18,7 @@ export function latin1Key(bytes) {
  *  the boundary rendering is digits and commas, so no content byte can forge
  *  the split. */
 export function perceiveKey(bytes, boundaries) {
-    const k = latin1Key(bytes);
+    const k = latin1(bytes);
     return boundaries === undefined || boundaries.length === 0
         ? k
         : k + "\u0000" + boundaries.join(",");
@@ -111,7 +97,7 @@ export function perceiveDeposit(ctx, bytes, conversational = false) {
         .filter((L) => L >= 2 && L < bytes.length)
         .sort((a, b) => b - a);
     for (const L of lens) {
-        const hit = ctx._depositTrees.get(latin1Key(bytes.subarray(0, L)));
+        const hit = ctx._depositTrees.get(latin1(bytes.subarray(0, L)));
         if (hit !== undefined) {
             prev = hit.content;
             break;
@@ -130,7 +116,7 @@ export function perceiveDeposit(ctx, bytes, conversational = false) {
             ctx._depositLens.clear();
             ctx._depositTrees.clear();
         }
-        ctx._depositTrees.set(latin1Key(bytes), { content: folded.fold });
+        ctx._depositTrees.set(latin1(bytes), { content: folded.fold });
         ctx._depositLens.add(bytes.length);
     }
     return folded.tree;
@@ -203,14 +189,10 @@ export function foldTree(ctx, n, start, visit) {
         return { end, node };
     }
     let pos = start;
-    let known = true;
     const kids = [];
     for (const k of n.kids) {
         const r = foldTree(ctx, k, pos, visit);
-        if (r.node === null)
-            known = false;
-        else if (known)
-            kids.push(r.node);
+        kids.push(r.node);
         pos = r.end;
     }
     // Same store-probe elision as the leaf case: a cached entry already names
@@ -218,17 +200,103 @@ export function foldTree(ctx, n, start, visit) {
     // id need not be re-derived.  Using it also keeps a warm walk's ids
     // bit-identical to a cold walk's rather than re-deriving them from children
     // that may themselves have come from cache.
-    const node = cached !== undefined
-        ? cached.id
-        : known
-            ? ctx.store.findBranch(kids)
-            : null;
+    const named = cached !== undefined
+        ? { id: cached.id, byBytes: false }
+        : branchNaming(ctx, kids, treeBytes(n));
+    const node = named.id;
     visit?.(n, start, pos, node);
     if (node !== null && ctx._resolvedSubtrees) {
         ctx._resolvedSubtrees.set(n, { id: node, len: pos - start });
     }
     return { end: pos, node };
 }
+/** A perceived subtree's bytes, its leaves in order. */
+function treeBytes(n) {
+    const parts = [];
+    const walk = (x) => {
+        if (x.kids === null)
+            parts.push(x.leaf ?? new Uint8Array(0));
+        else
+            for (const k of x.kids)
+                walk(k);
+    };
+    walk(n);
+    return concatBytes(parts);
+}
+/** The EXACT content-addressed node of a byte stream — `foldTree(perceive)`,
+ *  read for identity alone.
+ *
+ *  A fold names a branch only when every child is named, so identity needs the
+ *  fold's SHAPE and the store's answer per node, never its vectors:
+ *  {@link contentIdentity} walks the same shape (geometry.ts — one grouping
+ *  rule, two algebras) and asks the store bottom-up, building no D-dimensional
+ *  gist and leaving nothing in the perception memo.  Each node is named the
+ *  way the store's write side names it ({@link branchNaming}).  `test/148` pins
+ *  the agreement with the full fold over random and corpus spans. */
+export function exactNode(ctx, bytes) {
+    return exactNaming(ctx, bytes).id;
+}
+/** {@link exactNode}, with whether the span's own name was found only through
+ *  its BYTES — its children named no branch, and the flat node over the same
+ *  bytes did ({@link branchNaming}).  That is where the exact lookup used to
+ *  MISS, so it is where {@link resolve} still asks the canonical class: the
+ *  class may hold the learnt member that leads somewhere, which a flat index
+ *  entry need not (measured: `tonight` named an edge-less window and
+ *  pre-empted the case-folded `Tonight` whose edge a composition stood on).
+ *  Recognition's probes reach it through `resolve`; asking it again for the
+ *  perceived tree's own byte-named groups changed none of 116 real queries and
+ *  no test, so it is not asked there. */
+export function exactNaming(ctx, bytes) {
+    if (bytes.length === 0) {
+        return { id: foldTree(ctx, perceive(ctx, bytes), 0).node, byBytes: false };
+    }
+    if (ctx.meter)
+        ctx.meter.identityBytes += bytes.length;
+    let byBytes = false;
+    const id = contentIdentity(ctx.space, ctx.alphabet, bytes, (from, to) => to - from === 1
+        ? ctx.store.findLeaf(bytes.subarray(from, to))
+        : flatNode(ctx, bytes.subarray(from, to)), (kids, from, to) => {
+        const named = branchNaming(ctx, kids, bytes.subarray(from, to));
+        if (from === 0 && to === bytes.length)
+            byBytes = named.byBytes;
+        return named.id;
+    });
+    return { id, byBytes };
+}
+/** The flat node over a span's single-byte atoms — the node every deposit
+ *  interns for its whole input and for each canonical window (learning.ts
+ *  `deposit`, `indexSubSpans`).  The store's negative filter refuses most
+ *  misses without a lookup. */
+function flatNode(ctx, span) {
+    const store = ctx.store;
+    return store.findFlatBranch
+        ? store.findFlatBranch(span)
+        : store.findBranch(Array.from(span, (b) => -(b + 1)));
+}
+/** THE READ SIDE NAMES A BRANCH EXACTLY AS THE WRITE SIDE DID.  `intern`
+ *  (store.ts) names a branch by its children; when they name none, it looks up
+ *  the flat node over the same bytes and REUSES it (step 1b, "same bytes, same
+ *  node") — so a deposit whose fold grouped `ver` + `!` was stored with the
+ *  window `ver!` as that child.  Reading by the children alone could never
+ *  name such a deposit again: measured on the 31.7M-node store, 8 of 80 stored
+ *  dialogue turns asked verbatim resolved to nothing (a 25-byte turn, a final
+ *  `?` or `!`, …) and fell to the composition path.  Same order as the write
+ *  side: the children first, the bytes when they name nothing — and an unnamed
+ *  child does not settle it, since the write side minted that child and still
+ *  reached step 1b. */
+function branchNaming(ctx, kids, span) {
+    if (kids.every((k) => k !== null)) {
+        const id = ctx.store.findBranch(kids);
+        if (id !== null)
+            return { id, byBytes: false };
+    }
+    if (kids.length < 2)
+        return { id: null, byBytes: false };
+    const id = flatNode(ctx, span);
+    if (id !== null && ctx.meter)
+        ctx.meter.flatBranchNames++;
+    return { id, byBytes: id !== null };
+}
 /** The canonical node id of a byte span: perceive it in isolation — the way
  *  training did — and recover its root bottom-up.  Returns null if any part is
  *  unknown. */
@@ -237,10 +305,10 @@ export function resolve(ctx, bytes) {
         return null;
     if (ctx.meter)
         ctx.meter.resolves++;
-    const exact = foldTree(ctx, perceive(ctx, bytes), 0).node;
-    if (exact !== null)
+    const { id: exact, byBytes } = exactNaming(ctx, bytes);
+    if (exact !== null && !byBytes)
         return exact;
-    return canonResolve(ctx, bytes);
+    return canonResolve(ctx, bytes) ?? exact;
 }
 /** Equivalence-class resolution: when the exact content-addressed lookup
  *  misses, find a stored node whose CANONICAL key equals the span's — the
@@ -258,7 +326,7 @@ export function canonResolve(ctx, bytes) {
     if (bytes.length < 2)
         return null;
     const memo = ctx.canonMemo;
-    const memoKey = memo ? latin1Key(bytes) : "";
+    const memoKey = memo ? latin1(bytes) : "";
     if (memo) {
         const hit = memo.get(memoKey);
         if (hit !== undefined)
@@ -275,7 +343,7 @@ export function canonResolve(ctx, bytes) {
     // skips identity rows) — the exact content-addressed lookup of the
     // canonical bytes finds it directly.
     if (key.length !== bytes.length || !bytesEqual(key, bytes)) {
-        const direct = foldTree(ctx, perceive(ctx, key), 0).node;
+        const direct = exactNode(ctx, key);
         if (direct !== null)
             return set(direct);
     }
@@ -295,17 +363,12 @@ export function canonResolve(ctx, bytes) {
         // resolved for these bytes is their FOLD — the deposit-shaped node that
         // carries the edges and halos.  Re-folding the candidate's bytes lands
         // on exactly the node the canonical-case query would have found.
-        const folded = foldTree(ctx, perceive(ctx, bytesOf), 0).node;
+        const folded = exactNode(ctx, bytesOf);
         const use = folded ?? id;
-        // THE ADMISSION PREDICATE, by its own pair of probes: `traverse.ts`'s
-        // `leadsSomewhere` is edge-or-halo, and `hasHalo` is the one that carries
-        // the mass bar (`mass >= minHaloMass`).  Asking `haloMass(use) > 0` instead
-        // is the same answer only while `minHaloMass <= 1` (its default): raise the
-        // bar and this site would rank a node as leading on evidence the law
-        // refuses.  Calling `leadsSomewhere` here is not possible — `traverse.ts`
-        // imports THIS file, so it would be a cycle — which is why the pair is
-        // spelled out rather than named.
-        const leads = store.hasNext(use) || store.hasHalo(use);
+        // THE ADMISSION PREDICATE, asked of the store that owns it (edge or halo,
+        // the halo tier carrying the mass bar).  Asking `haloMass(use) > 0` instead
+        // would agree only while `minHaloMass <= 1`.
+        const leads = store.leadsSomewhere(use);
         if (best === null || (leads && !bestLeads) ||
             (leads === bestLeads && use < best)) {
             best = use;