@hviana/sema 0.3.0 → 0.4.1

package/src/mind/pipeline.ts

@@ -32,12 +32,18 @@ export { aluToMechanism } from "./mechanisms/alu.js";
 // ── Extension dispatch (pre-loop parse) ─────────────────────────────────────
 
 async function collectComputed(
+  ctx: MindContext,
   mechanisms: readonly PipelineMechanism[],
   query: Uint8Array,
 ): Promise<ComputedSpan[]> {
   const out: ComputedSpan[] = [];
+  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;
 }
@@ -143,7 +149,7 @@ export async function think(
   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(
@@ -181,6 +187,7 @@ export async function think(
     used?: ReadonlySet<number>;
     accounted: ReadonlyArray<[number, number]>;
     unexplained: string;
+    complete?: boolean;
   }
   const grade = (w: number) => Math.floor(w / STEP);
   const unaccounted = (spans: ReadonlyArray<[number, number]>): number =>
@@ -195,6 +202,7 @@ export async function think(
   let best: Candidate | null = null;
   const consider = (c: Candidate) => {
     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;
   };
@@ -202,8 +210,21 @@ export async function think(
     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",
@@ -224,7 +245,10 @@ export async function think(
       );
       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({
@@ -234,6 +258,7 @@ export async function think(
         used: r.used,
         accounted: r.accounted,
         unexplained: r.unexplained,
+        complete: r.complete,
       });
     }
   }
@@ -338,7 +363,16 @@ export async function think(
     : provenance === "recall" || provenance === "recall-echo"
     ? new Set<number>()
     : 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
@@ -374,9 +408,32 @@ export async function think(
     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: ReadonlyArray<[number, number]> =
+    decided.accounted.length > 0
+      ? decided.accounted
+      : pre.computed.map((u): [number, number] => [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,

package/src/mind/primitives.ts

@@ -7,7 +7,6 @@ import { Vec } from "../vec.js";
 import { Sema } from "../sema.js";
 import {
   bytesToTree,
-  bytesToTreePyramid,
   Grid,
   gridToTree,
   hilbertBytes,
@@ -64,7 +63,14 @@ export function perceive(
       if (memo) {
         const key = latin1Key(bytes);
         const hit = memo.get(key);
-        if (hit !== undefined) return hit;
+        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,
@@ -76,6 +82,10 @@ export function perceive(
         memo.set(key, tree);
         return tree;
       }
+      if (ctx.meter) {
+        ctx.meter.perceptions++;
+        ctx.meter.perceivedBytes += bytes.length;
+      }
       return bytesToTree(
         ctx.space,
         ctx.alphabet,
@@ -93,21 +103,17 @@ export function perceive(
   return gridToTree(ctx.space, ctx.alphabet, input as Grid);
 }
 
-/** 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: MindContext,
   bytes: Uint8Array,
@@ -140,24 +146,32 @@ export function perceiveDeposit(
       }
     }
   }
-  let tree: Sema;
-  let entry: DepositCacheEntry;
+  // 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<number>();
   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: DepositCacheEntry = { 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
@@ -243,6 +257,7 @@ export function foldTree(
  *  unknown. */
 export function resolve(ctx: MindContext, bytes: Uint8Array): number | null {
   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;
   return canonResolve(ctx, bytes);
@@ -283,6 +298,7 @@ export function canonResolve(
     const direct = foldTree(ctx, perceive(ctx, key), 0).node;
     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);
   let best: number | null = null;

package/src/mind/reasoning.ts

@@ -7,7 +7,7 @@ import { rItem, rNode } from "./trace.js";
 import { bytesEqual, indexOf } from "../bytes.js";
 import type { MindContext } from "./types.js";
 import { resolve } from "./primitives.js";
-import { corpusN } from "./traverse.js";
+import { corpusN, hubBound } from "./traverse.js";
 import { follow, haloSiblings, project } from "./match.js";
 import { joinWithBridge, pivotInto } from "./resonance.js";
 import type { Precomputed } from "./pipeline-mechanism.js";
@@ -57,16 +57,16 @@ export async function reason(
   // 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: number | null) => {
     if (id === null) return;
     consumed.add(id);
-    for (const p of ctx.store.prevFirst(id, hubBound)) consumed.add(p);
+    for (const p of ctx.store.prevFirst(id, bound)) consumed.add(p);
   };
   const consumeAll = (id: number | null) => {
     if (id === null) return;
     consumeNode(id);
-    for (const n of ctx.store.nextFirst(id, hubBound)) consumed.add(n);
+    for (const n of ctx.store.nextFirst(id, bound)) consumed.add(n);
   };
 
   // Pre-consume whatever the grounding stage already spoke for.  The halo
@@ -99,7 +99,7 @@ export async function reason(
     // 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;
@@ -164,6 +164,12 @@ export async function fuseAttention(
    *  primary is unclimbed.  Absent or false preserves the original
    *  behaviour exactly. */
   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: ReadonlyArray<readonly [number, number]> = [],
 ): Promise<Uint8Array> {
   // When the answer is structurally drawn from the query itself
   // (extraction), it already spans all the query's pieces — fusion
@@ -194,8 +200,34 @@ export async function fuseAttention(
     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: Array<{ start: number; bytes: Uint8Array }> = [
-    { 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);
@@ -287,4 +319,4 @@ export async function fuseAttention(
 
 // (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/src/mind/recognition.ts

@@ -58,6 +58,7 @@ export function recognise(ctx: MindContext, bytes: Uint8Array): Recognition {
     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")],
@@ -80,11 +81,20 @@ export function recognise(ctx: MindContext, bytes: Uint8Array): Recognition {
 }
 
 function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
+  if (ctx.meter) {
+    ctx.meter.recognitions++;
+    ctx.meter.recognisedBytes += bytes.length;
+  }
   const store = ctx.store;
   const sites: Site[] = [];
   const leaves: Leaf[] = [];
   const splits = new Set<number>();
   const starts = new Set<number>();
+  // 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: number[] = [];
   if (bytes.length === 0) return { sites, leaves, splits, starts };
 
   // Span-resolve memo for THIS call: the structural pass (sub-runs inside
@@ -124,6 +134,34 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
   const seen = new Set<string>();
   const emit = (start: number, end: number, id: number) => {
     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;
     seen.add(key);
@@ -134,6 +172,7 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
 
   // ── 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 });
@@ -207,25 +246,47 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
         // "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);
         }
@@ -233,6 +294,7 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
     }
     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: number[] = [];
       let off = start;
@@ -304,6 +366,14 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
   // 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: number,
     maxIds: number,

package/src/mind/traverse.ts

@@ -32,6 +32,50 @@ interface StructCache {
 }
 const structCaches = new WeakMap<object, StructCache>();
 
+// ── The shared ancestor-reach memo ──────────────────────────────────────
+//
+// `edgeAncestors` is a pure function of (node, N) over a read-only store —
+// asking never writes — so its result is reusable for as long as the store
+// is not written to.  There used to be TWO memos and they never met: the
+// climb built a private one per call (computeAttention), while
+// `Precomputed.reachMemo` — documented as "one response-scoped memo serves
+// every mechanism that prices commonality" — was reached only by confluence.
+// The climb is by far the biggest consumer.
+//
+// Keyed off `ctx.climbMemo`'s OBJECT IDENTITY, exactly like the struct cache
+// above, which buys the right lifetime for free: a plain respond() has a
+// fresh climbMemo, so the memo is response-scoped; a conversation turn has
+// the conversation's persistent one, so it is conversation-scoped.  That
+// matters — the stable-prefix fold makes each turn's subtree independent of
+// what follows, so 59–70% of a later turn's climb regions are byte-identical
+// repeats of an earlier turn's (measured on a 4-turn session), and every one
+// of them used to re-climb from cold.
+//
+// Budgeted, not unbounded (AGENTS §2.12): past the cap the whole map is
+// dropped and re-derived, costing a cold climb and never a wrong answer.
+const REACH_MEMO_MAX = 100_000;
+const reachCaches = new WeakMap<object, Map<number, AncestorReach>>();
+
+/** 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 function sharedReachMemo(
+  ctx: MindContext,
+): Map<number, AncestorReach> {
+  if (ctx.trace !== null || ctx.climbMemo === null) return new Map();
+  let m = reachCaches.get(ctx.climbMemo);
+  if (m === undefined) reachCaches.set(ctx.climbMemo, m = new Map());
+  else if (m.size >= REACH_MEMO_MAX) m.clear();
+  return m;
+}
+
 function getStructCache(ctx: MindContext): StructCache | null {
   if (ctx.climbMemo === null) return null;
   let c = structCaches.get(ctx.climbMemo);
@@ -134,7 +178,7 @@ export function edgeAncestors(
   // is withdrawn.  On a small store the floor stays ≤ √N and the atom
   // climbs exactly as before, so single-letter facts keep working.
   if (id < 0 && atomIsHub(ctx, contextCount)) {
-    const bound0 = Math.ceil(Math.sqrt(Math.max(2, contextCount)));
+    const bound0 = boundFor(contextCount);
     const reach: AncestorReach = {
       roots: [],
       contextsReached: 0,
@@ -156,7 +200,7 @@ export function edgeAncestors(
     return reach;
   }
 
-  const bound = Math.ceil(Math.sqrt(contextCount));
+  const bound = boundFor(contextCount);
   const roots: number[] = [];
   const seen = new Set<number>([id]);
   const ctxSeen = new Set<number>();
@@ -213,6 +257,7 @@ export function edgeAncestors(
   let maxDepth = 0;
 
   const visit = (x: number): boolean => {
+    if (ctx.meter) ctx.meter.ancestorVisits++;
     if (depths) {
       visitedCount++;
       if (curDepth > maxDepth) maxDepth = curDepth;
@@ -395,8 +440,7 @@ export function atomReach(ctx: MindContext, contextCount: number): number {
  *  atom votes and is recognised exactly as any stored form; above it the
  *  alphabet is scaffolding everywhere and abstains. */
 export function atomIsHub(ctx: MindContext, contextCount: number): boolean {
-  return atomReach(ctx, contextCount) >
-    Math.ceil(Math.sqrt(Math.max(2, contextCount)));
+  return atomReach(ctx, contextCount) > boundFor(contextCount);
 }
 
 /** Whether a node LEADS SOMEWHERE — it bears a continuation edge or a halo.
@@ -444,7 +488,17 @@ export function corpusN(ctx: MindContext): number {
  *  materialised list.  {@link hubCap} is the list-side reading of the same
  *  convention. */
 export function hubBound(ctx: MindContext): number {
-  return Math.ceil(Math.sqrt(corpusN(ctx)));
+  return boundFor(corpusN(ctx));
+}
+
+/** √N for an EXPLICIT context count — the ctx-free reading of {@link
+ *  hubBound}, for the callers inside this module that are handed a count
+ *  rather than a context ({@link edgeAncestors}, {@link atomIsHub}).  The
+ *  floor at 2 matches {@link corpusN}'s, so both readings agree for every
+ *  input: the two used to be spelled out inline, once WITH the floor and
+ *  once without, in the same function. */
+function boundFor(contextCount: number): number {
+  return Math.ceil(Math.sqrt(Math.max(2, contextCount)));
 }
 
 /** Cap a candidate list at the hub bound √N (insertion order) — the ONE