@hviana/sema 0.3.0 → 0.4.0

package/dist/src/mind/pipeline.js

@@ -25,11 +25,16 @@ import { recallMechanism } from "./mechanisms/recall.js";
 export { resolveConcepts, resolveConnectors } from "./mechanisms/cover.js";
 export { aluToMechanism } from "./mechanisms/alu.js";
 // ── Extension dispatch (pre-loop parse) ─────────────────────────────────────
-async function collectComputed(mechanisms, query) {
+async function collectComputed(ctx, mechanisms, query) {
     const out = [];
+    const meter = ctx.meter;
     for (const m of mechanisms) {
-        if (m.parse)
-            out.push(...await m.parse(query));
+        if (!m.parse)
+            continue;
+        const spans = meter
+            ? await meter.time(`${m.name}.parse`, () => m.parse(query))
+            : await m.parse(query);
+        out.push(...spans);
     }
     return out;
 }
@@ -76,7 +81,7 @@ export async function think(ctx, query, mechs) {
     const mechanisms = mechs ?? defaultMechanisms;
     const rec = recognise(ctx, query);
     // Phase 1: collect computed spans from mechanisms that implement parse()
-    const computed = await collectComputed(mechanisms, query);
+    const computed = await collectComputed(ctx, mechanisms, query);
     if (computed.length > 0) {
         ctx.trace?.step("computeExtensions", [rItem(query, "query")], computed.map((u) => rItem(query.subarray(u.i, u.j), "operand", undefined, [u.i, u.j])), `extensions recognised and evaluated ${computed.length} computation(s)`);
         for (const u of computed) {
@@ -99,14 +104,28 @@ export async function think(ctx, query, mechs) {
     const consider = (c) => {
         if (c.bytes.length === 0)
             return;
+        if (ctx.meter)
+            ctx.meter.candidates++;
         candidates.push(c);
         if (best === null || grade(c.weight) < grade(best.weight))
             best = c;
     };
     const worthRunning = (floor) => best === null || grade(floor) < grade(best.weight);
     // 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.
+    const meter = ctx.meter;
     for (const mech of mechanisms) {
-        const floor = await mech.floor(ctx, query, pre, worthRunning);
+        const floor = meter
+            ? await meter.time(`${mech.name}.floor`, () => mech.floor(ctx, query, pre, worthRunning))
+            : await mech.floor(ctx, query, pre, worthRunning);
+        if (meter) {
+            if (floor === null)
+                meter.mechanismSkips++;
+            else
+                meter.mechanismFloors++;
+        }
         if (floor === null) {
             ctx.trace?.step("skipMechanism", [], [], `${mech.name} skipped — structural precondition failed`);
             continue;
@@ -115,7 +134,11 @@ export async function think(ctx, query, mechs) {
             ctx.trace?.step("skipMechanism", [], [], `${mech.name} skipped — floor ${floor} cannot beat incumbent (grade ${grade(best.weight)})`);
             continue;
         }
-        const results = await mech.run(ctx, query, pre);
+        if (meter)
+            meter.mechanismRuns++;
+        const results = meter
+            ? await meter.time(`${mech.name}.run`, () => mech.run(ctx, query, pre))
+            : await mech.run(ctx, query, pre);
         for (const r of results) {
             const weight = r.weight ?? weigh(r.accounted, r.moves);
             consider({
@@ -125,6 +148,7 @@ export async function think(ctx, query, mechs) {
                 used: r.used,
                 accounted: r.accounted,
                 unexplained: r.unexplained,
+                complete: r.complete,
             });
         }
     }
@@ -192,7 +216,13 @@ export async function think(ctx, query, mechs) {
         : provenance === "recall" || provenance === "recall-echo"
             ? new Set()
             : new Set(recognise(ctx, answer).sites.map((s) => s.payload));
-    const reasoned = await reason(ctx, query, answer, preConsumed, pre);
+    // A grounding that DECLARED itself complete is not extended: the answer is
+    // already a trained form's own continuation, reached through an identity
+    // claim about the query, so a multi-hop pivot could only chain past the
+    // fact that produced it (see MechanismResult.complete).
+    const reasoned = decided.complete ? answer : meter
+        ? await meter.time("reason", () => reason(ctx, query, answer, preConsumed, pre))
+        : await reason(ctx, query, answer, preConsumed, pre);
     // 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
@@ -225,9 +255,21 @@ export async function think(ctx, query, mechs) {
     // rejected.
     const unclimbed = decided.accounted.length > 0 &&
         decided.accounted.every(([i, j]) => pre.computed.some((u) => u.i === i && u.j === j));
-    const fused = remainder >= ctx.space.maxGroup
-        ? await fuseAttention(ctx, query, reasoned, pre, unclimbed)
-        : reasoned;
+    // 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.
+    const primarySpans = decided.accounted.length > 0
+        ? decided.accounted
+        : pre.computed.map((u) => [u.i, u.j]);
+    const fused = remainder < ctx.space.maxGroup
+        ? reasoned
+        : meter
+            ? await meter.time("fuse", () => fuseAttention(ctx, query, reasoned, pre, unclimbed, primarySpans))
+            : await fuseAttention(ctx, query, reasoned, pre, unclimbed, decided.accounted);
     done(fused, "grounded, reasoned forward, fused across points of attention");
     return { bytes: fused, provenance };
 }

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

@@ -15,21 +15,17 @@ export declare function latin1Key(bytes: Uint8Array): string;
  *  CALLER — who assembled the multi-turn context — knows where those
  *  boundaries are; the geometry never guesses them from the bytes. */
 export declare function perceive(ctx: MindContext, input: Input, leafAt?: (i: number) => number | null, lookup?: (ids: number[]) => number | null, boundaries?: readonly number[]): Sema;
-/** The DEPOSIT-shaped perceive.  A FIRST-SEEN input takes the PLAIN fold
- *  (bit-identical to inference perception of a standalone query — that
- *  structural train/inference agreement is load-bearing for exact recall),
- *  computed incrementally via the fold's level pyramid
- *  ({@link bytesToTreePyramid}).  An input that EXTENDS a previously
- *  deposited one is a conversation context grown by one turn — the cached
- *  prefix length IS the turn boundary (derived from the deposit sequence
- *  itself, never from content conventions) — and takes the STABLE-PREFIX
- *  fold over the accumulated boundaries, bit-identical to the boundary
- *  fold query-time conversation perception uses, so the trained context
- *  node and the query's context subtree are the SAME node.  Segment folds
- *  reuse across deposits ({@link stablePrefixFoldIncremental}) — O(turn)
- *  instead of O(context) per turn.  The fold state is purely a cache; the
- *  boundary accumulation is what an evicted chain loses (falling back to
- *  the plain fold, the pre-boundary shape — a warm replay restores it). */
+/** The DEPOSIT-shaped perceive.  Folds over the stream's own content cuts —
+ *  bit-identical to what inference computes for the same bytes, and that
+ *  train/inference agreement is load-bearing for exact recall.  An input that
+ *  EXTENDS a previously deposited one is a conversation context grown by one
+ *  turn; the cached prefix length IS the turn boundary (derived from the deposit
+ *  sequence itself, never from a content convention) and joins the cut set, so
+ *  the trained context node and the query's context subtree are the SAME node.
+ *  Segment folds reuse across deposits ({@link stablePrefixFoldIncremental}) —
+ *  O(turn) instead of O(context) per turn.  All of it is purely a cache: an
+ *  evicted chain loses only the turn boundaries, and since the content cuts do
+ *  not depend on the cache, the segments themselves are unchanged. */
 export declare function perceiveDeposit(ctx: MindContext, bytes: Uint8Array, conversational?: boolean): Sema;
 /** The raw bytes of an input — modality-neutral conversion. */
 export declare function inputBytes(ctx: MindContext, input: Input): Uint8Array;

package/dist/src/mind/primitives.js

@@ -2,7 +2,7 @@
 //
 //   Address  — bytes → node   (perceive, foldTree, resolve)
 //   Read     — node → bytes   (read)
-import { bytesToTree, bytesToTreePyramid, gridToTree, hilbertBytes, stablePrefixFoldIncremental, stackGrids, } from "../geometry.js";
+import { bytesToTree, gridToTree, hilbertBytes, stablePrefixFoldIncremental, stackGrids, } from "../geometry.js";
 import { canonHash } from "../canon.js";
 import { bytesEqual } from "../bytes.js";
 import { ALL } from "./types.js";
@@ -43,12 +43,23 @@ export function perceive(ctx, input, leafAt, lookup, boundaries) {
             if (memo) {
                 const key = latin1Key(bytes);
                 const hit = memo.get(key);
-                if (hit !== undefined)
+                if (hit !== undefined) {
+                    if (ctx.meter)
+                        ctx.meter.perceiveHits++;
                     return hit;
+                }
+                if (ctx.meter) {
+                    ctx.meter.perceptions++;
+                    ctx.meter.perceivedBytes += bytes.length;
+                }
                 const tree = bytesToTree(ctx.space, ctx.alphabet, bytes, undefined, undefined, boundaries);
                 memo.set(key, tree);
                 return tree;
             }
+            if (ctx.meter) {
+                ctx.meter.perceptions++;
+                ctx.meter.perceivedBytes += bytes.length;
+            }
             return bytesToTree(ctx.space, ctx.alphabet, bytes, undefined, undefined, boundaries);
         }
         return bytesToTree(ctx.space, ctx.alphabet, bytes, leafAt, lookup);
@@ -58,21 +69,17 @@ export function perceive(ctx, input, leafAt, lookup, boundaries) {
     }
     return gridToTree(ctx.space, ctx.alphabet, input);
 }
-/** The DEPOSIT-shaped perceive.  A FIRST-SEEN input takes the PLAIN fold
- *  (bit-identical to inference perception of a standalone query — that
- *  structural train/inference agreement is load-bearing for exact recall),
- *  computed incrementally via the fold's level pyramid
- *  ({@link bytesToTreePyramid}).  An input that EXTENDS a previously
- *  deposited one is a conversation context grown by one turn — the cached
- *  prefix length IS the turn boundary (derived from the deposit sequence
- *  itself, never from content conventions) — and takes the STABLE-PREFIX
- *  fold over the accumulated boundaries, bit-identical to the boundary
- *  fold query-time conversation perception uses, so the trained context
- *  node and the query's context subtree are the SAME node.  Segment folds
- *  reuse across deposits ({@link stablePrefixFoldIncremental}) — O(turn)
- *  instead of O(context) per turn.  The fold state is purely a cache; the
- *  boundary accumulation is what an evicted chain loses (falling back to
- *  the plain fold, the pre-boundary shape — a warm replay restores it). */
+/** The DEPOSIT-shaped perceive.  Folds over the stream's own content cuts —
+ *  bit-identical to what inference computes for the same bytes, and that
+ *  train/inference agreement is load-bearing for exact recall.  An input that
+ *  EXTENDS a previously deposited one is a conversation context grown by one
+ *  turn; the cached prefix length IS the turn boundary (derived from the deposit
+ *  sequence itself, never from a content convention) and joins the cut set, so
+ *  the trained context node and the query's context subtree are the SAME node.
+ *  Segment folds reuse across deposits ({@link stablePrefixFoldIncremental}) —
+ *  O(turn) instead of O(context) per turn.  All of it is purely a cache: an
+ *  evicted chain loses only the turn boundaries, and since the content cuts do
+ *  not depend on the cache, the segments themselves are unchanged. */
 export function perceiveDeposit(ctx, bytes, conversational = false) {
     let prev;
     let prefixLen = 0;
@@ -99,19 +106,27 @@ export function perceiveDeposit(ctx, bytes, conversational = false) {
             }
         }
     }
-    let tree;
-    let entry;
+    // ONLY turn boundaries belong here.  The stream's own content cuts are NOT
+    // passed in: `bytesToTree` and `stablePrefixFoldIncremental` both derive them
+    // per span, at every level, and handing the level-0 cuts in as stable-prefix
+    // boundaries instead produces a LEFT-NESTED join of flat segments — a
+    // different tree from the one inference builds for the same bytes.  When that
+    // happened, a deposit's context root and `resolve(question)` were different
+    // nodes, so the trained edge hung off a node inference never reached and
+    // recall went silent (test/44 caught it as a site that could not be emitted
+    // because the resolved node led nowhere).  Train and infer must fold
+    // identically; the way to guarantee that is to give this function nothing
+    // extra to say.
+    const cuts = new Set();
     if (prev !== undefined) {
-        const boundaries = [...prev.boundaries, prefixLen];
-        const folded = stablePrefixFoldIncremental(ctx.space, ctx.alphabet, bytes, boundaries, prev.stable);
-        tree = folded.tree;
-        entry = { boundaries, stable: folded.fold };
-    }
-    else {
-        const plain = bytesToTreePyramid(ctx.space, ctx.alphabet, bytes);
-        tree = plain.tree;
-        entry = { boundaries: [], pyramid: plain.pyramid };
+        for (const b of prev.boundaries)
+            cuts.add(b);
+        cuts.add(prefixLen);
     }
+    const boundaries = [...cuts].sort((a, b) => a - b);
+    const folded = stablePrefixFoldIncremental(ctx.space, ctx.alphabet, bytes, boundaries, prev?.stable);
+    const tree = folded.tree;
+    const entry = { boundaries, stable: folded.fold };
     // Only a conversational deposit writes the cache too — otherwise a bare
     // fact's plain fold could later be misread as a conversation's turn-zero
     // boundary by an unrelated conversational deposit that happens to extend
@@ -193,6 +208,8 @@ export function foldTree(ctx, n, start, visit) {
 export function resolve(ctx, bytes) {
     if (bytes.length === 0)
         return null;
+    if (ctx.meter)
+        ctx.meter.resolves++;
     const exact = foldTree(ctx, perceive(ctx, bytes), 0).node;
     if (exact !== null)
         return exact;
@@ -235,6 +252,8 @@ export function canonResolve(ctx, bytes) {
         if (direct !== null)
             return set(direct);
     }
+    if (ctx.meter)
+        ctx.meter.canonLookups++;
     const candidates = store.canonFind(canonHash(key));
     if (candidates.length === 0)
         return set(null);

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

@@ -31,4 +31,10 @@ export declare function fuseAttention(ctx: MindContext, query: Uint8Array, prima
  *  primary's own source; that assumption is exactly backwards when
  *  primary is unclimbed.  Absent or false preserves the original
  *  behaviour exactly. */
-unclimbed?: boolean): Promise<Uint8Array>;
+unclimbed?: boolean, 
+/** The query spans `primary`'s own grounding stands on — used ONLY to place
+ *  primary in the fused reading order (see below).  Resolved by the caller,
+ *  which is the layer that knows how a given grounding records its evidence;
+ *  fuseAttention just reads a position from it.  Empty or absent preserves
+ *  the original behaviour exactly. */
+primarySpans?: ReadonlyArray<readonly [number, number]>): Promise<Uint8Array>;

package/dist/src/mind/reasoning.js

@@ -5,7 +5,7 @@
 import { rItem, rNode } from "./trace.js";
 import { bytesEqual, indexOf } from "../bytes.js";
 import { resolve } from "./primitives.js";
-import { corpusN } from "./traverse.js";
+import { hubBound } from "./traverse.js";
 import { follow, haloSiblings, project } from "./match.js";
 import { joinWithBridge, pivotInto } from "./resonance.js";
 /** Whether `bytes` is a proper byte-subspan of `query` — already present in
@@ -45,19 +45,19 @@ export async function reason(ctx, query, answer, preConsumed, pre) {
     // convention every fan-out decision uses (first √N in the relation's own
     // read order); a pivot suppressed only by a beyond-cap neighbour may now
     // fire — the same visibility trade chooseNext documents.
-    const hubBound = Math.ceil(Math.sqrt(corpusN(ctx)));
+    const bound = hubBound(ctx);
     const consumeNode = (id) => {
         if (id === null)
             return;
         consumed.add(id);
-        for (const p of ctx.store.prevFirst(id, hubBound))
+        for (const p of ctx.store.prevFirst(id, bound))
             consumed.add(p);
     };
     const consumeAll = (id) => {
         if (id === null)
             return;
         consumeNode(id);
-        for (const n of ctx.store.nextFirst(id, hubBound))
+        for (const n of ctx.store.nextFirst(id, bound))
             consumed.add(n);
     };
     // Pre-consume whatever the grounding stage already spoke for.  The halo
@@ -90,7 +90,7 @@ export async function reason(ctx, query, answer, preConsumed, pre) {
         // absorbing it would repeat content the grounding stage already spoke
         // for, so a consumed fixpoint falls through to the pivot step instead.
         if (curId !== null &&
-            ctx.store.nextFirst(curId, hubBound).some((n) => !consumed.has(n))) {
+            ctx.store.nextFirst(curId, bound).some((n) => !consumed.has(n))) {
             const fwd = await follow(ctx, curId, qv);
             const fwdId = fwd !== null ? resolve(ctx, fwd) : null;
             if (fwd !== null && !bytesEqual(fwd, cur) &&
@@ -133,7 +133,13 @@ export async function fuseAttention(ctx, query, primary, pre,
  *  primary's own source; that assumption is exactly backwards when
  *  primary is unclimbed.  Absent or false preserves the original
  *  behaviour exactly. */
-unclimbed = false) {
+unclimbed = false, 
+/** The query spans `primary`'s own grounding stands on — used ONLY to place
+ *  primary in the fused reading order (see below).  Resolved by the caller,
+ *  which is the layer that knows how a given grounding records its evidence;
+ *  fuseAttention just reads a position from it.  Empty or absent preserves
+ *  the original behaviour exactly. */
+primarySpans = []) {
     // When the answer is structurally drawn from the query itself
     // (extraction), it already spans all the query's pieces — fusion
     // would only add noise from unrelated stored contexts.  The gate is
@@ -162,8 +168,34 @@ unclimbed = false) {
     if (forest.length === 0 || (forest.length <= 1 && !lonePromotes)) {
         return primary;
     }
+    // WHERE THE QUERY ASKED FOR IT.  The sort below orders the fused pieces by
+    // query position, which is the whole point of the `start` field: a
+    // multi-topic answer should read in the order the question posed its
+    // topics.  Every ROOT carries its own start.  `primary` did not — it was
+    // given forest[0].start, the FIRST attention root's position, which is
+    // primary's own source only when primary happens to come from that root.
+    // When it does not, primary is sorted to a position it never occupied.
+    //
+    // Observed live: "What is the capital of France? And what is 2 + 2?"
+    // answered "4The capital city of France is Paris." — the ALU result, whose
+    // evidence is the "2 + 2" span near the END of the query, inherited the
+    // France root's start of 0 and sorted ahead of the France answer.  Both
+    // pieces were right; only the order was.
+    //
+    // primary's own position is the earliest query byte its grounding stands
+    // on.  `accounted` is the cost-ladder read of that and is authoritative
+    // when non-empty; when it is empty the grounding is a pure COMPUTATION,
+    // whose evidence is its computed span — the same cost-ladder-vs-coverage
+    // distinction think() already draws for the fusion remainder ("`accounted`
+    // alone undercounts this ... cover prices its computed spans at near-zero
+    // and deliberately leaves them out"), read here for position instead of
+    // for coverage.  With neither, nothing is known and the old behaviour
+    // (forest[0].start) stands.
+    const primaryStart = primarySpans.length > 0
+        ? primarySpans.reduce((m, [s]) => Math.min(m, s), Infinity)
+        : forest[0].start;
     const pieces = [
-        { start: forest[0].start, bytes: primary },
+        { start: primaryStart, bytes: primary },
     ];
     const qv = pre.guide; // once, not per root
     const rest = lonePromotes ? forest : forest.slice(1);
@@ -237,4 +269,4 @@ unclimbed = false) {
 }
 // (resonance.js is already a static dependency above — `bridge` — so the old
 // dynamic import of pivotInto guarded against a cycle that does not exist.)
-import { containsSpan } from "./mechanisms/extraction.js";
+import { containsSpan } from "./match.js";

package/dist/src/mind/recognition.js

@@ -47,6 +47,8 @@ export function recognise(ctx, bytes) {
         const key = latin1Key(bytes);
         const hit = ctx.recogniseMemo.get(key);
         if (hit !== undefined) {
+            if (ctx.meter)
+                ctx.meter.recogniseHits++;
             ctx.trace?.step("recognise", [rItem(bytes, "query")], hit.sites.map((s) => rItem(bytes.subarray(s.start, s.end), "form", s.payload, [
                 s.start,
                 s.end,
@@ -61,11 +63,20 @@ export function recognise(ctx, bytes) {
     return recogniseImpl(ctx, bytes);
 }
 function recogniseImpl(ctx, bytes) {
+    if (ctx.meter) {
+        ctx.meter.recognitions++;
+        ctx.meter.recognisedBytes += bytes.length;
+    }
     const store = ctx.store;
     const sites = [];
     const leaves = [];
     const splits = new Set();
     const starts = new Set();
+    // The same cuts in ASCENDING order.  The post-order walk below visits
+    // leaf-parents left to right, so appending as they are added keeps this
+    // sorted with no comparison — which is what lets the composite search find
+    // its candidates by binary search instead of rescanning the whole set.
+    const startList = [];
     if (bytes.length === 0)
         return { sites, leaves, splits, starts };
     // Span-resolve memo for THIS call: the structural pass (sub-runs inside
@@ -105,6 +116,33 @@ function recogniseImpl(ctx, bytes) {
     const emit = (start, end, id) => {
         if (id < 0 && atomsAreHubs)
             return;
+        // A SITE MUST SPAN ONE RIVER WINDOW.  Below W, byte overlap is chance,
+        // not evidence — the principle identityBar already states ("below one
+        // river window, byte overlap is chance") and the bridge's attestedQ
+        // already applies ("spans shorter than W carry no window of their own").
+        // No new constant.
+        //
+        // This REPLACES the false premise it used to share with fuse() and
+        // tryChain: those gates asked "does this offset sit on a fold boundary?"
+        // and read the answer from `starts`, which is exactly {0, W, 2W, …}
+        // because riverFold groups fixed-arity — arithmetic, not evidence.
+        //
+        // Measured on the 17.9M-node store, over the sites of 7 probes (1 good,
+        // 11 junk by hand-labelling, corrected for whole-query forms):
+        //     len >= W        rejects "hi"(2) "of"(2) "is"(2) "di"(2) "the"(3),
+        //                     admits  "Eiffel Tower"(12) and both whole-query forms
+        //     len >= W-1      admits "the" — W-1 is the write side's straddle
+        //                     neighbour for RETRIEVAL, never a claim about units
+        //     §2.7 saturation admits 11/11 junk: edgeAncestors on a site node
+        //                     reaches 1..48 contexts, so dominates(ctx, N) needs
+        //                     ctx > 162805 and never fires; every site reads DISC
+        //     rarity          does not separate: "hi" has 1 container, "the" 572
+        //
+        // A span covering the WHOLE query is exempt: then it is not a fragment of
+        // something longer, it is the question ("hi" asked on its own).
+        if (atomsAreHubs && end - start < ctx.space.maxGroup &&
+            !(start === 0 && end === bytes.length))
+            return;
         const key = start + "," + end + "," + id;
         if (seen.has(key))
             return;
@@ -115,6 +153,7 @@ function recogniseImpl(ctx, bytes) {
     };
     // ── structural: the query's own perceived tree ──────────────────────
     starts.add(0);
+    startList.push(0);
     foldTree(ctx, perceive(ctx, bytes), 0, (n, start, end, node) => {
         if (n.kids === null) {
             leaves.push({ start, end, bytes: n.leaf ?? new Uint8Array(0), node });
@@ -190,26 +229,50 @@ function recogniseImpl(ctx, bytes) {
                 // "And " prepended to a follow-up turn — not boundary noise, actual
                 // content the injected canonicalizer has no equivalence for) shows
                 // up as a canon-miss too big for the chunk-scale search above: the
-                // turn is its OWN segment (stable-prefix folded independently — see
-                // mind.ts's _growContext), so it can be turn/segment-scale, not
-                // chunk-scale.  Widening the size bound itself reopens the root-
-                // scale false-positive this module already fixed once (test/46);
-                // widening the SEARCH instead — trying every position up to W
-                // chunk-widths from the left edge that the query's OWN fold treats
-                // as a chunk boundary (`starts`, the same set the canonical pass
-                // privileges with full chain reach) — does not: `starts.has(p)` is
-                // fold EVIDENCE the query produced on its own (a leaf-parent chunk
-                // like "And " is visited, and its start added to `starts`, before
-                // this composite ever runs — foldTree is post-order), never a blind
-                // guess.  Bounded to W candidates, each an O(1) set lookup before
-                // paying for the real canonResolve fold — canonResolve, not
-                // resolve()/findBranch, because the gap here is often exactly the
-                // kind of equivalence (case, in the live trace) canon exists for,
-                // not just an exact-content coincidence.
-                for (let k = 1; k <= W; k++) {
-                    const p = start + k * W;
-                    if (p >= end - 1 || !starts.has(p))
-                        continue;
+                // turn is its OWN segment, so it can be turn/segment-scale, not
+                // chunk-scale.  Widening the size bound itself reopens the root-scale
+                // false-positive this module already fixed once (test/46); widening the
+                // SEARCH instead does not, because every candidate is a cut the query's
+                // OWN fold drew (`starts`, the same set the canonical pass privileges
+                // with full chain reach) — fold EVIDENCE, never a blind guess.
+                //
+                // The candidates are the fold's own segment starts inside this span, in
+                // order.  They used to be probed at `start + k*W`, which assumed cuts
+                // land on multiples of W; content-defined cuts do not, so that stride
+                // tested offsets no segment ever began at and this search silently
+                // never fired (test/44 pins it).  Still bounded to W candidates, each
+                // one O(1) from the sorted cut list before paying for a real
+                // canonResolve fold — canonResolve, not resolve()/findBranch, because
+                // the gap here is often exactly the kind of equivalence (case, in the
+                // live trace) canon exists for, not an exact-content coincidence.
+                // A deposit's ROOT is a whole-stream node, and a stream's ends are not
+                // content cuts — so an embedded occurrence of a trained form reproduces
+                // its SEGMENTS (which are offset-free) but never its root.  What is
+                // being looked for is therefore a suffix of this span that happens to be
+                // a whole trained form, and its left edge can only be a cut the fold
+                // itself drew.  Candidates are taken from the RIGHT, nearest the end
+                // first: the form ends where this node ends, so its start is near it.
+                // Left-to-right was wrong — in test/44 the target's start is the 6th cut
+                // from the end but the 12th from the beginning.
+                //
+                // `starts` is still filling (this runs inside the post-order walk), but
+                // post-order guarantees every chunk BELOW this span is already in it —
+                // exactly the set wanted.  Bounded to chainReach(W) candidates, the same
+                // reach the canonical pass trusts, so cost stays O(reach · span).
+                let hi = startList.length; // first index past the last usable cut
+                let lo = 0;
+                while (lo < hi) {
+                    const mid = (lo + hi) >> 1;
+                    if (startList[mid] < end - 1)
+                        lo = mid + 1;
+                    else
+                        hi = mid;
+                }
+                const reach = chainReach(W);
+                for (let k = 0; k < reach; k++) {
+                    const p = startList[lo - 1 - k];
+                    if (p === undefined || p <= start)
+                        break;
                     const cid = canonResolve(ctx, bytes.subarray(p, end));
                     if (cid !== null)
                         emit(p, end, cid);
@@ -218,6 +281,8 @@ function recogniseImpl(ctx, bytes) {
         }
         if (isChunk(n)) {
             starts.add(start);
+            if (startList[startList.length - 1] !== start)
+                startList.push(start);
             // Try every sub-span within this leaf-parent.
             const leafOffsets = [];
             let off = start;
@@ -290,6 +355,14 @@ function recogniseImpl(ctx, bytes) {
     // hub-scale atoms, chained at an offset nothing in the query's own fold
     // selected).  Chains that start ON a boundary carry the fold's own
     // evidence instead and are exempt.
+    //
+    // NOTE (2026-07-24): that last sentence is FALSE — `starts` is exactly
+    // {0, W, 2W, …} (riverFold groups fixed-arity), so the exemption is
+    // arithmetic, not evidence.  Removing it wholesale was measured and
+    // REVERTED: it also drops legitimate multi-byte chains (the 12-byte
+    // "Eiffel Tower" site vanished with it).  The premise is wrong but the
+    // trust it stood in for is real; a replacement signal is still open work.
+    // See bench/README.md.
     const tryChain = (p, maxIds, boundary) => {
         const first = leafFrom(p);
         if (!first)

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

@@ -1,5 +1,16 @@
 import { Vec } from "../vec.js";
 import type { AncestorReach, MindContext } from "./types.js";
+/** The reach memo this response should use — see the note above.
+ *
+ *  A TRACED response always gets a fresh, empty one.  `AncestorReach`'s
+ *  `visited`/`maxDepth`/`saturation` fields are populated only when a trace
+ *  is attached, so an entry deposited by an untraced earlier turn would
+ *  silently black out the reach detail of a later traced one; and the trace's
+ *  reach payload is serialised by ITERATING this map, which must therefore
+ *  hold what THIS climb consulted, not the whole conversation's history.
+ *  Consistent with AGENTS §2.11: a traced response is a different machine —
+ *  never benchmark with a trace attached. */
+export declare function sharedReachMemo(ctx: MindContext): Map<number, AncestorReach>;
 /** Climb the structural DAG from a node to its edge-bearing ancestor contexts.
  *  Ascent stops at hub nodes (parents > √N) — their reach is non-discriminative.
  *  When the start node has no structural parents, climbs from containment parents