@hviana/sema 0.5.0 → 0.5.2

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

@@ -273,16 +273,21 @@ interface ClimbConsensusCfg {
 export declare function climbAttention(ctx: MindContext, query: Uint8Array, k: number, mode?: DFMode): Promise<Attention[]>;
 /** Full read-out of one consensus climb: both the roots (dominant points of
  *  attention) and the entire ranked list.  Cached via ctx.climbMemo, ALWAYS —
- *  see {@link recognise} for why this memo (and recognise()'s own) must
- *  never be skipped while tracing: computeAttention's collectRegions walks
- *  the query's perceived tree via the same foldTree whose subtree-resolution
- *  fast path makes a second call on identical bytes non-idempotent once
- *  ctx._resolvedSubtrees is warm (which a multi-turn conversation's shared
- *  prefix subtrees guarantee by the second turn).  A cache hit still emits
- *  a trace step — abbreviated, since the full per-sub-region voting detail
- *  {@link traceAttention} builds isn't preserved by the cached read-out —
- *  so a traced response is never silently blacked out for a repeated
- *  query. */
+ *  see {@link recognise} for why this memo (and recognise()'s own) is never
+ *  gated on tracing.  The short of it: computeAttention's collectRegions
+ *  votes over what walking the query's perceived tree EMITS, and foldTree's
+ *  subtree-resolution fast path used to skip that walk on a warm cache, so a
+ *  second climb over identical bytes saw less evidence than the first — which
+ *  a conversation's shared prefix subtrees guaranteed by the second turn.
+ *  foldTree now takes that fast path only when nothing is watching the walk
+ *  (see primitives.ts), so the climb is idempotent on its own and this memo
+ *  is an accelerator again.  It stays unconditional anyway: attaching a trace
+ *  must not change which regions attention weighs.
+ *
+ *  A cache hit still emits a trace step — abbreviated, since the full
+ *  per-sub-region voting detail {@link traceAttention} builds isn't preserved
+ *  by the cached read-out — so a traced response is never silently blacked
+ *  out for a repeated query. */
 export declare function climbAttentionAll(ctx: MindContext, query: Uint8Array, k: number, mode?: DFMode): Promise<AttentionRead>;
 export declare function computeAttention(ctx: MindContext, query: Uint8Array, k: number, mode: DFMode): Promise<AttentionRead>;
 export declare function collectRegions(ctx: MindContext, query: Uint8Array): Region[];

package/dist/src/mind/attention.js

@@ -54,16 +54,21 @@ export async function climbAttention(ctx, query, k, mode = "inverse") {
 }
 /** Full read-out of one consensus climb: both the roots (dominant points of
  *  attention) and the entire ranked list.  Cached via ctx.climbMemo, ALWAYS —
- *  see {@link recognise} for why this memo (and recognise()'s own) must
- *  never be skipped while tracing: computeAttention's collectRegions walks
- *  the query's perceived tree via the same foldTree whose subtree-resolution
- *  fast path makes a second call on identical bytes non-idempotent once
- *  ctx._resolvedSubtrees is warm (which a multi-turn conversation's shared
- *  prefix subtrees guarantee by the second turn).  A cache hit still emits
- *  a trace step — abbreviated, since the full per-sub-region voting detail
- *  {@link traceAttention} builds isn't preserved by the cached read-out —
- *  so a traced response is never silently blacked out for a repeated
- *  query. */
+ *  see {@link recognise} for why this memo (and recognise()'s own) is never
+ *  gated on tracing.  The short of it: computeAttention's collectRegions
+ *  votes over what walking the query's perceived tree EMITS, and foldTree's
+ *  subtree-resolution fast path used to skip that walk on a warm cache, so a
+ *  second climb over identical bytes saw less evidence than the first — which
+ *  a conversation's shared prefix subtrees guaranteed by the second turn.
+ *  foldTree now takes that fast path only when nothing is watching the walk
+ *  (see primitives.ts), so the climb is idempotent on its own and this memo
+ *  is an accelerator again.  It stays unconditional anyway: attaching a trace
+ *  must not change which regions attention weighs.
+ *
+ *  A cache hit still emits a trace step — abbreviated, since the full
+ *  per-sub-region voting detail {@link traceAttention} builds isn't preserved
+ *  by the cached read-out — so a traced response is never silently blacked
+ *  out for a repeated query. */
 export async function climbAttentionAll(ctx, query, k, mode = "inverse") {
     // Content-keyed memo — works for both single-turn respond() and multi-turn
     // respondTurn().

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

@@ -181,8 +181,9 @@ export declare class Mind implements MindContext {
      *  serves BOTH entry points: `respond` takes fresh per-response memos,
      *  `respondTurn` passes its conversation, whose memos persist across turns
      *  (content-keyed, so the previous turn's results are found by this turn's
-     *  sub-span calls) and whose `resolvedSubtrees` makes foldTree O(suffix)
-     *  instead of O(context).  respondTurn used to inline its own copy of this
+     *  sub-span calls) and whose `resolvedSubtrees` spares foldTree the store
+     *  probes for every prefix subtree — and, for walks that pass no visitor,
+     *  the descent as well.  respondTurn used to inline its own copy of this
      *  and of {@link endResponse}; the two drifted (a memo added to one was
      *  silently absent from the other), so there is exactly one pair now. */
     private beginResponse;

package/dist/src/mind/mind.js

@@ -206,8 +206,9 @@ export class Mind {
      *  serves BOTH entry points: `respond` takes fresh per-response memos,
      *  `respondTurn` passes its conversation, whose memos persist across turns
      *  (content-keyed, so the previous turn's results are found by this turn's
-     *  sub-span calls) and whose `resolvedSubtrees` makes foldTree O(suffix)
-     *  instead of O(context).  respondTurn used to inline its own copy of this
+     *  sub-span calls) and whose `resolvedSubtrees` spares foldTree the store
+     *  probes for every prefix subtree — and, for walks that pass no visitor,
+     *  the descent as well.  respondTurn used to inline its own copy of this
      *  and of {@link endResponse}; the two drifted (a memo added to one was
      *  silently absent from the other), so there is exactly one pair now. */
     beginResponse(inspectRationale, canon, conv) {

package/dist/src/mind/primitives.js

@@ -155,20 +155,47 @@ export function gistOf(ctx, bytes) {
  *  node with its byte span and resolved id.  Returns the node's byte end and
  *  resolved id. */
 export function foldTree(ctx, n, start, visit) {
-    // Fast path: subtree already resolved (from a previous conversation turn
-    // or an earlier recognition pass).  The pyramid reuses prefix subtrees as
-    // identical Sema objects, so this cache turns foldTree into O(suffix)
-    // instead of O(context) for multi-turn recognition.
+    // Subtree already resolved (from a previous conversation turn or an earlier
+    // recognition pass).  The pyramid reuses prefix subtrees as identical Sema
+    // objects, so a conversation's prefix is warm from its second turn on.
+    // Without a visitor that makes foldTree O(suffix) instead of O(context);
+    // with one it stays O(context) and saves the per-node store probes instead
+    // (see below for why the distinction is not negotiable).
+    //
+    // WHAT THE CACHE KNOWS, AND WHAT IT DOES NOT.  An entry records this
+    // subtree's id and byte length — nothing about its DESCENDANTS' spans.
+    // Returning here therefore emits ONE visit() where a cold walk emits one per
+    // node, and `visit` is not instrumentation: recognise() emits its sites from
+    // it (recognition.ts) and attention's collectRegions votes over what it
+    // yields (attention.ts).  Skipping the descent silently shrinks the evidence
+    // those mechanisms see, purely because the cache happened to be warm.
+    //
+    // That is not hypothetical and not an edge case — it is every conversation
+    // turn after the first.  `contentFoldIncremental` deliberately shares prefix
+    // segment OBJECTS across turns (~99% reuse), so by turn 2 the prefix is
+    // warm; meanwhile recogniseMemo/climbMemo are keyed on exact query BYTES,
+    // which a growing context never repeats.  Warm subtrees + missed memos is
+    // the unprotected quadrant.  Measured over real trained conversations,
+    // recognising the same context with a warm prefix lost 67-92% of its leaves
+    // (772->204, 589->47, 872->291, 377->37) with `sites` unchanged, so the loss
+    // is invisible to the coarse counts; a direct foldTree probe on identical
+    // bytes and an identical tree object fired visit() 661 times cold and 37
+    // warm.  respond() is immune only because it never sets _resolvedSubtrees
+    // (mind.ts) — the degradation was unique to the multi-turn API.
+    //
+    // So the fast path is taken only when NOBODY IS WATCHING.  With a visitor
+    // present we still walk, and the cache degrades to the thing it soundly is:
+    // an elision of the store probes (findLeaf/findBranch) at each node, not an
+    // elision of the traversal.  Ids still come from the cache, so a warm walk
+    // is cheaper than a cold one; it is no longer *different* from one.
     const cached = ctx._resolvedSubtrees?.get(n);
-    if (cached !== undefined) {
-        const end = start + cached.len;
-        visit?.(n, start, end, cached.id);
-        return { end, node: cached.id };
+    if (cached !== undefined && visit === undefined) {
+        return { end: start + cached.len, node: cached.id };
     }
     if (n.kids === null) {
         const b = n.leaf ?? new Uint8Array(0);
         const end = start + b.length;
-        const node = ctx.store.findLeaf(b);
+        const node = cached !== undefined ? cached.id : ctx.store.findLeaf(b);
         visit?.(n, start, end, node);
         if (node !== null && ctx._resolvedSubtrees) {
             ctx._resolvedSubtrees.set(n, { id: node, len: b.length });
@@ -186,7 +213,16 @@ export function foldTree(ctx, n, start, visit) {
             kids.push(r.node);
         pos = r.end;
     }
-    const node = known ? ctx.store.findBranch(kids) : null;
+    // Same store-probe elision as the leaf case: a cached entry already names
+    // this subtree, so the descent above was for `visit`'s benefit alone and the
+    // 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;
     visit?.(n, start, pos, node);
     if (node !== null && ctx._resolvedSubtrees) {
         ctx._resolvedSubtrees.set(n, { id: node, len: pos - start });

package/dist/src/mind/recognition.js

@@ -26,23 +26,40 @@ export function recognise(ctx, bytes) {
     // Content-keyed memo — works for both single-turn respond() and multi-turn
     // respondTurn() (where the map persists across calls).  ALWAYS consulted,
     // regardless of tracing — matching perceive()'s own memo, which carries no
-    // trace gate at all.  This memo is NOT an optional accelerator: recogniseImpl
-    // walks the query's perceived tree via foldTree, whose subtree-resolution
-    // fast path (see primitives.ts) skips invoking `visit` — and therefore
-    // skips EMITTING SITES — for any subtree already cached in
-    // ctx._resolvedSubtrees.  A multi-turn conversation's stable-prefix fold
-    // deliberately shares node OBJECTS across turns, so by the second call on
-    // the exact same bytes, large swaths of the tree are already cached and
-    // foldTree stops short of recursing into them — a second recogniseImpl
-    // call on the SAME bytes is not idempotent; it silently finds FEWER sites
-    // than the first (observed live: 31 sites → 5 on an immediate repeat
-    // call).  Skipping this memo "only while tracing" used to mean every
-    // traced turn re-ran recogniseImpl from scratch at every one of the many
-    // call sites that recognise the same query (cover, reason, articulate...),
-    // each subsequent call silently more incomplete than the last — measurably
-    // changing which mechanism grounds the answer, not just costing time.  The
-    // trace step must still fire on every call regardless (a cache hit is not
-    // silent), so it is emitted here directly instead of only inside
+    // trace gate at all.
+    //
+    // This memo is an accelerator, and that is now the whole of it: repeated
+    // recognition of the same query is ordinary within one response (cover,
+    // reason and articulate all recognise it) and recogniseImpl is O(n ·
+    // maxGroup) probes each time.
+    //
+    // IT USED TO BE LOAD-BEARING FOR CORRECTNESS, and the history is worth
+    // keeping because it explains why there is no trace gate here.  foldTree's
+    // subtree-resolution fast path (primitives.ts) once returned on a cache hit
+    // WITHOUT recursing, so it skipped invoking `visit` — and therefore skipped
+    // EMITTING SITES — for any subtree already in ctx._resolvedSubtrees.  A
+    // conversation's incremental fold deliberately shares node OBJECTS across
+    // turns, so by the second call on the same bytes large swaths of the tree
+    // were already cached and recogniseImpl silently found FEWER sites than the
+    // first call (observed live: 31 → 5).  Skipping this memo "only while
+    // tracing" therefore meant every traced turn re-ran recogniseImpl at each of
+    // those call sites, each result more incomplete than the last — changing
+    // which mechanism grounded the answer, not merely costing time.
+    //
+    // foldTree no longer does that: it takes the fast path only when no `visit`
+    // is supplied, so a walk that emits sites always walks in full and the id
+    // cache is reduced to eliding store probes (see primitives.ts).  recognise()
+    // is idempotent on its own now — verified with the memo bypassed, the
+    // subtree cache warm and the tree object shared: three consecutive calls on
+    // the same 544-byte context returned sites=2 leaves=544 splits=0 starts=88,
+    // identical every time.
+    //
+    // The unconditional consult STAYS regardless.  A memo whose absence can only
+    // cost time is still not something to gate on whether an audit happens to be
+    // attached: tracing must not change what the pipeline computes, and the
+    // cheapest way to guarantee that is for the trace flag to touch nothing but
+    // the trace.  The trace step must still fire on every call (a cache hit is
+    // not silent), so it is emitted here directly rather than only inside
     // recogniseImpl.
     if (ctx.recogniseMemo) {
         const key = latin1Key(bytes);

package/dist/src/mind/traverse.js

@@ -8,6 +8,13 @@
 import { cosine } from "../vec.js";
 import { gistOf, read } from "./primitives.js";
 import { leafIdRun } from "./canonical.js";
+//
+// Budgeted on the same terms as the reach memo below (AGENTS §2.12): these
+// three maps are cleared on every write, but a long read-only session over a
+// large store converges on one entry per node per map with nothing to bound
+// it.  Past the cap all three are dropped together and re-derived, costing
+// cold structural probes and never a wrong answer.
+const STRUCT_MEMO_MAX = 100_000;
 const structCaches = new WeakMap();
 // ── The shared ancestor-reach memo ──────────────────────────────────────
 //
@@ -59,6 +66,13 @@ function getStructCache(ctx) {
             hasParents: new Map(),
         });
     }
+    else if (c.hasNext.size >= STRUCT_MEMO_MAX ||
+        c.prevCount.size >= STRUCT_MEMO_MAX ||
+        c.hasParents.size >= STRUCT_MEMO_MAX) {
+        c.hasNext.clear();
+        c.prevCount.clear();
+        c.hasParents.clear();
+    }
     return c;
 }
 /** Invalidate every session-lifetime structural read after a write. */

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

@@ -284,9 +284,13 @@ export interface MindContext extends GraphSearchHost {
     /** Subtree-resolution cache: Sema node → its store id and byte length.
      *  Populated by {@link foldTree} during inference; checked before
      *  walking children.  When a conversation's pyramid reuses prefix
-     *  subtrees, this cache lets {@link recognise} skip them entirely —
-     *  O(suffix) instead of O(context).  Mind-lifetime (WeakMap keys are
-     *  the Sema objects the pyramid keeps alive).
+     *  subtrees, this cache names them without a store probe.  It does NOT let
+     *  {@link recognise} skip them: recognise walks with a `visit` callback and
+     *  emits its sites from it, so a skipped descent would mean fewer sites on
+     *  a warm cache than a cold one.  foldTree short-circuits only for
+     *  visitor-less walks (O(suffix) there); a visiting walk stays O(context)
+     *  and banks the elided probes.  Mind-lifetime (WeakMap keys are the Sema
+     *  objects the pyramid keeps alive).
      *
      *  THAT REUSE IS A PRECONDITION, NOT A GIVEN: the keys are node IDENTITIES,
      *  so it hits only while the conversation's fold hands back the SAME Sema

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "type": "module",
   "main": "dist/src/index.js",

package/src/mind/attention.ts

@@ -460,16 +460,21 @@ export async function climbAttention(
 
 /** Full read-out of one consensus climb: both the roots (dominant points of
  *  attention) and the entire ranked list.  Cached via ctx.climbMemo, ALWAYS —
- *  see {@link recognise} for why this memo (and recognise()'s own) must
- *  never be skipped while tracing: computeAttention's collectRegions walks
- *  the query's perceived tree via the same foldTree whose subtree-resolution
- *  fast path makes a second call on identical bytes non-idempotent once
- *  ctx._resolvedSubtrees is warm (which a multi-turn conversation's shared
- *  prefix subtrees guarantee by the second turn).  A cache hit still emits
- *  a trace step — abbreviated, since the full per-sub-region voting detail
- *  {@link traceAttention} builds isn't preserved by the cached read-out —
- *  so a traced response is never silently blacked out for a repeated
- *  query. */
+ *  see {@link recognise} for why this memo (and recognise()'s own) is never
+ *  gated on tracing.  The short of it: computeAttention's collectRegions
+ *  votes over what walking the query's perceived tree EMITS, and foldTree's
+ *  subtree-resolution fast path used to skip that walk on a warm cache, so a
+ *  second climb over identical bytes saw less evidence than the first — which
+ *  a conversation's shared prefix subtrees guaranteed by the second turn.
+ *  foldTree now takes that fast path only when nothing is watching the walk
+ *  (see primitives.ts), so the climb is idempotent on its own and this memo
+ *  is an accelerator again.  It stays unconditional anyway: attaching a trace
+ *  must not change which regions attention weighs.
+ *
+ *  A cache hit still emits a trace step — abbreviated, since the full
+ *  per-sub-region voting detail {@link traceAttention} builds isn't preserved
+ *  by the cached read-out — so a traced response is never silently blacked
+ *  out for a repeated query. */
 export async function climbAttentionAll(
   ctx: MindContext,
   query: Uint8Array,

package/src/mind/mind.ts

@@ -110,8 +110,12 @@ export interface Conversation {
  *
  *  {@link resolvedSubtrees} caches foldTree resolutions at the Sema-node
  *  level.  When the pyramid reuses prefix subtrees (identical objects),
- *  foldTree returns their ids immediately — O(suffix) instead of
- *  O(context) for every tree walk. */
+ *  foldTree recovers their ids without touching the store.  A walk that
+ *  passes no `visit` callback can stop at a cached subtree outright and is
+ *  O(suffix); a walk that DOES pass one — recognition and attention both do —
+ *  still descends in full and spends O(context), banking the elided store
+ *  probes rather than an elided traversal.  That asymmetry is deliberate and
+ *  load-bearing: see foldTree in primitives.ts. */
 interface ConversationData {
   tree: Sema;
   bytes: Uint8Array;
@@ -120,8 +124,11 @@ interface ConversationData {
    *  grown context reuses every content segment it already folded and folds
    *  only the new turn — O(turn) instead of O(context) — and, because the
    *  reused segments are the SAME Sema objects, `resolvedSubtrees` (keyed by
-   *  node identity) hits across turns, which is what makes recognition
-   *  O(suffix).  Undefined until the first grow.
+   *  node identity) hits across turns, so recognition recovers the prefix's
+   *  ids without re-probing the store for any of them.  It still WALKS the
+   *  prefix — it must, or it would emit fewer sites on a warm cache than a
+   *  cold one (see foldTree) — so the saving is in probes, not in traversal.
+   *  Undefined until the first grow.
    *
    *  No turn boundaries are involved: reuse comes from content cuts being
    *  stable under append, and imposing boundaries would only change the tree
@@ -480,8 +487,9 @@ export class Mind implements MindContext {
    *  serves BOTH entry points: `respond` takes fresh per-response memos,
    *  `respondTurn` passes its conversation, whose memos persist across turns
    *  (content-keyed, so the previous turn's results are found by this turn's
-   *  sub-span calls) and whose `resolvedSubtrees` makes foldTree O(suffix)
-   *  instead of O(context).  respondTurn used to inline its own copy of this
+   *  sub-span calls) and whose `resolvedSubtrees` spares foldTree the store
+   *  probes for every prefix subtree — and, for walks that pass no visitor,
+   *  the descent as well.  respondTurn used to inline its own copy of this
    *  and of {@link endResponse}; the two drifted (a memo added to one was
    *  silently absent from the other), so there is exactly one pair now. */
   private beginResponse(

package/src/mind/primitives.ts

@@ -203,21 +203,48 @@ export function foldTree(
   start: number,
   visit?: (n: Sema, start: number, end: number, node: number | null) => void,
 ): { end: number; node: number | null } {
-  // Fast path: subtree already resolved (from a previous conversation turn
-  // or an earlier recognition pass).  The pyramid reuses prefix subtrees as
-  // identical Sema objects, so this cache turns foldTree into O(suffix)
-  // instead of O(context) for multi-turn recognition.
+  // Subtree already resolved (from a previous conversation turn or an earlier
+  // recognition pass).  The pyramid reuses prefix subtrees as identical Sema
+  // objects, so a conversation's prefix is warm from its second turn on.
+  // Without a visitor that makes foldTree O(suffix) instead of O(context);
+  // with one it stays O(context) and saves the per-node store probes instead
+  // (see below for why the distinction is not negotiable).
+  //
+  // WHAT THE CACHE KNOWS, AND WHAT IT DOES NOT.  An entry records this
+  // subtree's id and byte length — nothing about its DESCENDANTS' spans.
+  // Returning here therefore emits ONE visit() where a cold walk emits one per
+  // node, and `visit` is not instrumentation: recognise() emits its sites from
+  // it (recognition.ts) and attention's collectRegions votes over what it
+  // yields (attention.ts).  Skipping the descent silently shrinks the evidence
+  // those mechanisms see, purely because the cache happened to be warm.
+  //
+  // That is not hypothetical and not an edge case — it is every conversation
+  // turn after the first.  `contentFoldIncremental` deliberately shares prefix
+  // segment OBJECTS across turns (~99% reuse), so by turn 2 the prefix is
+  // warm; meanwhile recogniseMemo/climbMemo are keyed on exact query BYTES,
+  // which a growing context never repeats.  Warm subtrees + missed memos is
+  // the unprotected quadrant.  Measured over real trained conversations,
+  // recognising the same context with a warm prefix lost 67-92% of its leaves
+  // (772->204, 589->47, 872->291, 377->37) with `sites` unchanged, so the loss
+  // is invisible to the coarse counts; a direct foldTree probe on identical
+  // bytes and an identical tree object fired visit() 661 times cold and 37
+  // warm.  respond() is immune only because it never sets _resolvedSubtrees
+  // (mind.ts) — the degradation was unique to the multi-turn API.
+  //
+  // So the fast path is taken only when NOBODY IS WATCHING.  With a visitor
+  // present we still walk, and the cache degrades to the thing it soundly is:
+  // an elision of the store probes (findLeaf/findBranch) at each node, not an
+  // elision of the traversal.  Ids still come from the cache, so a warm walk
+  // is cheaper than a cold one; it is no longer *different* from one.
   const cached = ctx._resolvedSubtrees?.get(n);
-  if (cached !== undefined) {
-    const end = start + cached.len;
-    visit?.(n, start, end, cached.id);
-    return { end, node: cached.id };
+  if (cached !== undefined && visit === undefined) {
+    return { end: start + cached.len, node: cached.id };
   }
 
   if (n.kids === null) {
     const b = n.leaf ?? new Uint8Array(0);
     const end = start + b.length;
-    const node = ctx.store.findLeaf(b);
+    const node = cached !== undefined ? cached.id : ctx.store.findLeaf(b);
     visit?.(n, start, end, node);
     if (node !== null && ctx._resolvedSubtrees) {
       ctx._resolvedSubtrees.set(n, { id: node, len: b.length });
@@ -233,7 +260,16 @@ export function foldTree(
     else if (known) kids.push(r.node);
     pos = r.end;
   }
-  const node = known ? ctx.store.findBranch(kids) : null;
+  // Same store-probe elision as the leaf case: a cached entry already names
+  // this subtree, so the descent above was for `visit`'s benefit alone and the
+  // 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;
   visit?.(n, start, pos, node);
   if (node !== null && ctx._resolvedSubtrees) {
     ctx._resolvedSubtrees.set(n, { id: node, len: pos - start });

package/src/mind/recognition.ts

@@ -37,23 +37,40 @@ export function recognise(ctx: MindContext, bytes: Uint8Array): Recognition {
   // Content-keyed memo — works for both single-turn respond() and multi-turn
   // respondTurn() (where the map persists across calls).  ALWAYS consulted,
   // regardless of tracing — matching perceive()'s own memo, which carries no
-  // trace gate at all.  This memo is NOT an optional accelerator: recogniseImpl
-  // walks the query's perceived tree via foldTree, whose subtree-resolution
-  // fast path (see primitives.ts) skips invoking `visit` — and therefore
-  // skips EMITTING SITES — for any subtree already cached in
-  // ctx._resolvedSubtrees.  A multi-turn conversation's stable-prefix fold
-  // deliberately shares node OBJECTS across turns, so by the second call on
-  // the exact same bytes, large swaths of the tree are already cached and
-  // foldTree stops short of recursing into them — a second recogniseImpl
-  // call on the SAME bytes is not idempotent; it silently finds FEWER sites
-  // than the first (observed live: 31 sites → 5 on an immediate repeat
-  // call).  Skipping this memo "only while tracing" used to mean every
-  // traced turn re-ran recogniseImpl from scratch at every one of the many
-  // call sites that recognise the same query (cover, reason, articulate...),
-  // each subsequent call silently more incomplete than the last — measurably
-  // changing which mechanism grounds the answer, not just costing time.  The
-  // trace step must still fire on every call regardless (a cache hit is not
-  // silent), so it is emitted here directly instead of only inside
+  // trace gate at all.
+  //
+  // This memo is an accelerator, and that is now the whole of it: repeated
+  // recognition of the same query is ordinary within one response (cover,
+  // reason and articulate all recognise it) and recogniseImpl is O(n ·
+  // maxGroup) probes each time.
+  //
+  // IT USED TO BE LOAD-BEARING FOR CORRECTNESS, and the history is worth
+  // keeping because it explains why there is no trace gate here.  foldTree's
+  // subtree-resolution fast path (primitives.ts) once returned on a cache hit
+  // WITHOUT recursing, so it skipped invoking `visit` — and therefore skipped
+  // EMITTING SITES — for any subtree already in ctx._resolvedSubtrees.  A
+  // conversation's incremental fold deliberately shares node OBJECTS across
+  // turns, so by the second call on the same bytes large swaths of the tree
+  // were already cached and recogniseImpl silently found FEWER sites than the
+  // first call (observed live: 31 → 5).  Skipping this memo "only while
+  // tracing" therefore meant every traced turn re-ran recogniseImpl at each of
+  // those call sites, each result more incomplete than the last — changing
+  // which mechanism grounded the answer, not merely costing time.
+  //
+  // foldTree no longer does that: it takes the fast path only when no `visit`
+  // is supplied, so a walk that emits sites always walks in full and the id
+  // cache is reduced to eliding store probes (see primitives.ts).  recognise()
+  // is idempotent on its own now — verified with the memo bypassed, the
+  // subtree cache warm and the tree object shared: three consecutive calls on
+  // the same 544-byte context returned sites=2 leaves=544 splits=0 starts=88,
+  // identical every time.
+  //
+  // The unconditional consult STAYS regardless.  A memo whose absence can only
+  // cost time is still not something to gate on whether an audit happens to be
+  // attached: tracing must not change what the pipeline computes, and the
+  // cheapest way to guarantee that is for the trace flag to touch nothing but
+  // the trace.  The trace step must still fire on every call (a cache hit is
+  // not silent), so it is emitted here directly rather than only inside
   // recogniseImpl.
   if (ctx.recogniseMemo) {
     const key = latin1Key(bytes);

package/src/mind/traverse.ts

@@ -31,6 +31,13 @@ interface StructCache {
   prevCount: Map<number, number>;
   hasParents: Map<number, boolean>;
 }
+//
+// Budgeted on the same terms as the reach memo below (AGENTS §2.12): these
+// three maps are cleared on every write, but a long read-only session over a
+// large store converges on one entry per node per map with nothing to bound
+// it.  Past the cap all three are dropped together and re-derived, costing
+// cold structural probes and never a wrong answer.
+const STRUCT_MEMO_MAX = 100_000;
 const structCaches = new WeakMap<object, StructCache>();
 
 // ── The shared ancestor-reach memo ──────────────────────────────────────
@@ -85,6 +92,14 @@ function getStructCache(ctx: MindContext): StructCache | null {
         hasParents: new Map(),
       },
     );
+  } else if (
+    c.hasNext.size >= STRUCT_MEMO_MAX ||
+    c.prevCount.size >= STRUCT_MEMO_MAX ||
+    c.hasParents.size >= STRUCT_MEMO_MAX
+  ) {
+    c.hasNext.clear();
+    c.prevCount.clear();
+    c.hasParents.clear();
   }
   return c;
 }

package/src/mind/types.ts

@@ -331,9 +331,13 @@ export interface MindContext extends GraphSearchHost {
   /** Subtree-resolution cache: Sema node → its store id and byte length.
    *  Populated by {@link foldTree} during inference; checked before
    *  walking children.  When a conversation's pyramid reuses prefix
-   *  subtrees, this cache lets {@link recognise} skip them entirely —
-   *  O(suffix) instead of O(context).  Mind-lifetime (WeakMap keys are
-   *  the Sema objects the pyramid keeps alive).
+   *  subtrees, this cache names them without a store probe.  It does NOT let
+   *  {@link recognise} skip them: recognise walks with a `visit` callback and
+   *  emits its sites from it, so a skipped descent would mean fewer sites on
+   *  a warm cache than a cold one.  foldTree short-circuits only for
+   *  visitor-less walks (O(suffix) there); a visiting walk stays O(context)
+   *  and banks the elided probes.  Mind-lifetime (WeakMap keys are the Sema
+   *  objects the pyramid keeps alive).
    *
    *  THAT REUSE IS A PRECONDITION, NOT A GIVEN: the keys are node IDENTITIES,
    *  so it hits only while the conversation's fold hands back the SAME Sema

package/test/75-multiturn-context-optimisation.test.mjs

@@ -59,7 +59,10 @@ import {
 // White-box: the memo key is internal, but its soundness is exactly what
 // section C is about, so it is imported directly rather than inferred from
 // downstream accuracy.
-import { perceiveKey } from "../dist/src/mind/primitives.js";
+import { foldTree, perceiveKey } from "../dist/src/mind/primitives.js";
+// White-box for section G: the visit-completeness invariant is a property of
+// these two functions directly, not of any number they eventually move.
+import { recognise } from "../dist/src/mind/recognition.js";
 
 const enc = (s) => new TextEncoder().encode(s);
 const newMind = (opts = {}) => new Mind({ seed: 7, ...opts });
@@ -1080,3 +1083,252 @@ test("F3: the conversation API is never WORSE than respond() on the same bytes",
     `respondTurn should answer every trained turn`,
   );
 });
+
+// ═══════════════════════════════════════════════════════════════════════
+// G. A CACHE MAY ELIDE WORK, NEVER OBSERVATION
+//
+// THE FIFTH BUG THIS FILE EXISTS TO PREVENT RECURRING.  `_resolvedSubtrees`
+// records a subtree's {id, len} and NOTHING about its descendants' spans.
+// foldTree's fast path returned on a hit without recursing, so it fired
+// `visit` ONCE for the subtree root where a cold walk fires once per node.
+//
+// `visit` is not instrumentation.  recognise() emits its SITES from it and
+// attention's collectRegions votes over what it yields, so a warm cache
+// silently shrank the evidence those mechanisms saw — the answer could change
+// because of what had been computed BEFORE, which is unreproducible by
+// construction and is the same hazard as bug 4, one level up.
+//
+// It was not an edge case.  The incremental fold deliberately shares prefix
+// segment OBJECTS across turns (~99% reuse, section B), so a conversation's
+// prefix is warm from its second turn on; meanwhile recogniseMemo/climbMemo
+// are keyed on exact query BYTES, which a GROWING context never repeats.
+// Warm subtrees + missed memos is the unprotected quadrant, and it is where
+// every real conversation lives.  Measured before the fix: recognising an
+// identical context with a warm prefix lost 67-92% of its leaves (772->204,
+// 589->47, 872->291, 377->37) while `sites` stayed EQUAL — invisible to any
+// coarse count, and invisible to F1/F3, which passed throughout.
+//
+// The fix: take the fast path only when NOBODY IS WATCHING.  With a visitor
+// present foldTree still walks, and the cache degrades to what it soundly is —
+// an elision of the store probes, not of the traversal.  G1-G3 pin the
+// observation; G4 pins that the elision itself survives, so a future
+// optimisation cannot "fix" the cost by quietly deleting the cache, and G5
+// pins the behaviour the whole machine exists for.
+// ═══════════════════════════════════════════════════════════════════════
+
+/** Every node reachable from a root that carries a subtree-cache entry AND has
+ *  children — a branch entry is exactly what the old fast path skipped INTO,
+ *  so a test with none of these proves nothing. */
+const cachedBranches = (mind, n) => {
+  let c = 0;
+  const go = (x) => {
+    if (x.kids !== null) {
+      if (mind._resolvedSubtrees.get(x) !== undefined) c++;
+      for (const k of x.kids) go(k);
+    }
+  };
+  go(n);
+  return c;
+};
+
+/** The full observation a foldTree walk makes: one record per visit, in order.
+ *  Spans AND ids — a walk that reports the same ids over fewer spans is still
+ *  a different observation. */
+const observe = (mind, tree) => {
+  const seen = [];
+  foldTree(mind, tree, 0, (n, s, e, id) => seen.push(`${s}:${e}:${id}`));
+  return seen;
+};
+
+const CONV = [
+  "who painted guernica",
+  "pablo picasso painted guernica",
+  "what year was it made",
+  "it was made in nineteen thirty seven",
+  "where is it kept now",
+  "it hangs in madrid",
+];
+
+test("G1: foldTree's visit set is identical warm and cold", async () => {
+  const mind = newMind();
+  await teach(mind, CONV, "");
+  const bytes = enc(CONV.join(""));
+  // ONE tree object, reused across both walks — this is precisely what a
+  // conversation hands its next turn, and the only thing an identity-keyed
+  // cache can hit on.  Rebuild it per walk and the test goes vacuous.
+  const tree = contentFoldIncremental(mind.space, mind.alphabet, bytes).tree;
+
+  mind._resolvedSubtrees = new WeakMap();
+  const cold = observe(mind, tree);
+
+  // NON-VACUITY, asserted rather than assumed: the cold walk must have left
+  // the cache genuinely warm, with entries on BRANCH nodes.  Without this the
+  // comparison below could pass on an empty cache and guard nothing.
+  const branches = cachedBranches(mind, tree);
+  assert.ok(
+    branches >= 5,
+    `only ${branches} cached branch entries — the warm walk would skip nothing ` +
+      `and this test would prove nothing`,
+  );
+
+  const warm = observe(mind, tree);
+  assert.deepEqual(
+    warm,
+    cold,
+    "a warm subtree cache changed what foldTree reported to its visitor",
+  );
+  // And stays stable — the old failure got progressively worse per call.
+  assert.deepEqual(observe(mind, tree), cold, "third walk diverged");
+});
+
+test("G2: a warm PREFIX cannot change recognition of a GROWN context", async () => {
+  // The unprotected quadrant, stated exactly: the query BYTES differ between
+  // turns (so recogniseMemo misses) while the prefix SUBTREES are shared (so
+  // the identity-keyed cache hits).  This is the real multi-turn shape.
+  const mind = newMind();
+  await teach(mind, CONV, "");
+  const prefix = enc(CONV.slice(0, 3).join(""));
+  const full = enc(CONV.join(""));
+  const f1 = contentFoldIncremental(mind.space, mind.alphabet, prefix);
+  // grown from f1 — prefix segments are the SAME objects in both trees
+  const f2 = contentFoldIncremental(mind.space, mind.alphabet, full, f1.fold);
+
+  const shape = (r) => ({
+    sites: r.sites.map((s) => `${s.start}:${s.end}`),
+    leaves: r.leaves.length,
+    splits: r.splits.size,
+    starts: r.starts.size,
+  });
+
+  // COLD: nothing seen before.
+  mind._resolvedSubtrees = new WeakMap();
+  mind.recogniseMemo = new Map();
+  mind.perceiveMemo = new Map([[perceiveKey(full), f2.tree]]);
+  const cold = shape(recognise(mind, full));
+
+  // WARM: an earlier turn already recognised the prefix.
+  mind._resolvedSubtrees = new WeakMap();
+  mind.recogniseMemo = new Map();
+  mind.perceiveMemo = new Map([[perceiveKey(prefix), f1.tree]]);
+  recognise(mind, prefix);
+  const warmedBranches = cachedBranches(mind, f2.tree);
+  assert.ok(
+    warmedBranches >= 3,
+    `recognising the prefix warmed only ${warmedBranches} branches of the grown ` +
+      `tree — the two folds are not sharing objects and this test is vacuous`,
+  );
+  mind.recogniseMemo = new Map(); // the query GREW: the byte-keyed memo misses
+  mind.perceiveMemo.set(perceiveKey(full), f2.tree);
+  const warm = shape(recognise(mind, full));
+
+  assert.deepEqual(
+    warm,
+    cold,
+    "recognition of the same context depended on whether its prefix was seen first",
+  );
+});
+
+test("G3: recognise() is idempotent under a warm cache, memo bypassed", async () => {
+  // The memo used to be load-bearing for CORRECTNESS: with it bypassed, a
+  // second call on the SAME bytes found fewer sites than the first (observed
+  // live: 31 -> 5).  The memo is an accelerator again only while this holds.
+  const mind = newMind();
+  await teach(mind, CONV, "");
+  const bytes = enc(CONV.join(""));
+  const tree = contentFoldIncremental(mind.space, mind.alphabet, bytes).tree;
+  mind._resolvedSubtrees = new WeakMap();
+  mind.recogniseMemo = null; // bypassed: nothing is hiding the walk
+  mind.perceiveMemo = new Map([[perceiveKey(bytes), tree]]);
+
+  const shape = (r) =>
+    `${r.sites.map((s) => `${s.start}:${s.end}`).join(",")}|${r.leaves.length}`;
+  const first = shape(recognise(mind, bytes));
+  assert.ok(
+    cachedBranches(mind, tree) >= 5,
+    "the first call left no branch entries — nothing would be skipped",
+  );
+  assert.equal(shape(recognise(mind, bytes)), first, "second call diverged");
+  assert.equal(shape(recognise(mind, bytes)), first, "third call diverged");
+});
+
+test("G4: the cache still ELIDES STORE PROBES — completeness is not a rollback", async () => {
+  // The other half of the contract.  Making the walk complete must not be
+  // achieved by neutering the cache: a warm visiting walk must still cost
+  // strictly fewer findLeaf/findBranch probes than a cold one.  Without this,
+  // deleting `_resolvedSubtrees` outright would pass G1-G3.
+  const mind = newMind();
+  await teach(mind, CONV, "");
+  const bytes = enc(CONV.join(""));
+  const tree = contentFoldIncremental(mind.space, mind.alphabet, bytes).tree;
+  const store = mind.store;
+  const realLeaf = store.findLeaf.bind(store);
+  const realBranch = store.findBranch.bind(store);
+  let probes = 0;
+  store.findLeaf = (b) => {
+    probes++;
+    return realLeaf(b);
+  };
+  store.findBranch = (k) => {
+    probes++;
+    return realBranch(k);
+  };
+  try {
+    mind._resolvedSubtrees = new WeakMap();
+    probes = 0;
+    observe(mind, tree);
+    const cold = probes;
+    probes = 0;
+    observe(mind, tree);
+    const warm = probes;
+    assert.ok(cold > 0, "cold walk made no probes — nothing to elide");
+    // Not zero: a node that resolves to null is never cached (foldTree stores
+    // only non-null ids), so the unresolved few are re-probed on every walk.
+    // The property is ELISION, and it must stay overwhelming — a rollback to
+    // "no cache" would put warm back at cold.
+    assert.ok(
+      warm * 10 <= cold,
+      `warm visiting walk made ${warm} store probes against the cold walk's ` +
+        `${cold} — the cache has stopped eliding probes`,
+    );
+  } finally {
+    store.findLeaf = realLeaf;
+    store.findBranch = realBranch;
+  }
+});
+
+test("G5: accumulated context is load-bearing, not decorative", async () => {
+  // What the whole multi-turn machine is FOR, as a property.  Measured on the
+  // real 15.7M-node store: 19/20 from full context, 0/20 from the last turn
+  // alone, 0/20 with a genuinely foreign prefix.  A regression that quietly
+  // began answering from the latest turn only would keep every accuracy test
+  // in this file green.
+  const mind = newMind();
+  await teach(mind, CONV, "");
+  const other = [
+    "who wrote hamlet",
+    "william shakespeare wrote hamlet",
+    "what century was that",
+    "it was the sixteenth century",
+  ];
+  await teach(mind, other, "");
+
+  const ctx = CONV.slice(0, 5).join("");
+  const want = CONV[5];
+  const last = CONV[4];
+
+  assert.equal(
+    (await mind.respondText(ctx)).trim(),
+    want,
+    "the trained cumulative context must answer",
+  );
+  assert.notEqual(
+    (await mind.respondText(last)).trim(),
+    want,
+    `"${last}" alone reached "${want}" — the answer is not using the history`,
+  );
+  assert.notEqual(
+    (await mind.respondText(other.join("") + last)).trim(),
+    want,
+    "a foreign history still produced this conversation's answer",
+  );
+});