@hviana/sema 0.4.7 → 0.5.1

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

@@ -7,22 +7,17 @@ import type { MindConfig } from "../config.js";
 import type { Meter } from "../meter.js";
 import type { GraphSearch, Leaf, Seg, Site } from "./graph-search.js";
 import type { Rationale } from "./rationale.js";
-import type { Grid, StableFold } from "../geometry.js";
-/** One {@link MindContext._depositTrees} entry — see that field's doc. */
+import type { ContentFold, Grid } from "../geometry.js";
+/** One {@link MindContext._depositTrees} entry — see that field's doc.
+ *
+ *  A PURE WORK CACHE.  It carries the already-folded content segments of a
+ *  deposited stream so a longer stream sharing its byte prefix can skip
+ *  refolding them.  It holds no turn boundaries and no continuation proof
+ *  because the deposit fold imposes nothing: reuse is bit-identical to a cold
+ *  fold, so a hit can only save time, never change a tree. */
 export interface DepositCacheEntry {
-    /** Turn boundaries accumulated over this content's deposit chain —
-     *  strictly increasing proper offsets, each a previously-deposited
-     *  whole-context length.  Empty for a first-seen (single-turn) input. */
-    boundaries: number[];
-    /** Stable-prefix segment folds (grown-context inputs only). */
-    stable?: StableFold;
-    /** The continuation bytes this ctxInput was paired with in ingestPair, if
-     *  any — the ONLY thing that makes a later, longer ctxInput a genuine next
-     *  TURN of the same conversation rather than an unrelated fact that
-     *  happens to share this one's byte prefix (e.g. "2+2" vs. "2+2=5").  A
-     *  later deposit only takes this entry as its stable-prefix `prev` when
-     *  its own suffix bytes-equal this exactly. */
-    nextBytes?: Uint8Array;
+    /** The plain content fold's reusable segment state. */
+    content: ContentFold;
 }
 export type Input = string | Uint8Array | Grid | Grid[];
 /** The host capabilities GraphSearch consults during a cover.  MindContext
@@ -289,9 +284,23 @@ 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
+     *  objects for the unchanged prefix.  `_growContext` rebuilt the whole tree
+     *  with `bytesToTree` on every turn, so every key was fresh and this cache
+     *  could not hit even once — the O(suffix) claim above described an
+     *  intention rather than the code.  It now grows the context through
+     *  {@link stablePrefixFoldIncremental}, which reuses each already-folded
+     *  segment: measured over four turns, turn 4 shared 69 of its 95 nodes with
+     *  turn 3 (26 new ≈ the new turn's own size). */
     _resolvedSubtrees: WeakMap<Sema, {
         id: number;
         len: number;
@@ -369,6 +378,40 @@ export declare function segRestatesQuery(s: Seg, query: Uint8Array, queryLen: nu
  *  (lo/hi) decision and the final concatenation: it is stale, not a second
  *  answer, but the OTHER spans a derivation chose are independent evidence
  *  and must not be discarded along with it. */
+/** The spans {@link liftAnswer} actually concatenates, in order — the answer
+ *  before it is joined.  Exposed so a caller can ask what the lifted answer is
+ *  MADE OF without re-deriving the selection: in particular how much of it is
+ *  SCAFFOLDING (a `rec: false` span — query bytes carried through verbatim
+ *  because nothing explained them, the same spans the liftAnswer trace labels
+ *  "scaffolding" rather than "chosen").
+ *
+ *  That quantity is load-bearing for the grounding decision.  Two candidates
+ *  can leave the SAME number of query bytes unaccounted and therefore grade
+ *  identically, while one of them pads its answer with those bytes and the
+ *  other does not — measured on test/22's two-fact chain, cover and recall
+ *  both graded 11001 with 11 bytes unexplained, and cover won the tie only on
+ *  consideration order, answering "The capital of France is Paris famous for"
+ *  where recall had crossed the hop.  Carrying an unexplained span into the
+ *  answer is strictly weaker than not explaining it: it manufactures fluency
+ *  out of the asker's own words.  See the tie-break in pipeline.ts. */
+export declare function liftAnswerParts(segs: Seg[], queryLen: number, query: Uint8Array, W: number): Seg[];
+/** The SCAFFOLDING byte count of a lifted answer: how many of its bytes come
+ *  from spans nothing recognised (see {@link liftAnswerParts}).
+ *
+ *  ONLY RUNS OF AT LEAST ONE RIVER WINDOW COUNT.  Not all carried-through
+ *  bytes are a failure to explain: a period, a question mark, the space
+ *  between two fused topics are GLUE — they belong to the answer's surface,
+ *  and dropping them to look better-derived would be a worse answer, not a
+ *  more honest one.  A substantive phrase the derivation never explained
+ *  ("famous for") is a different claim entirely.
+ *
+ *  W is the line between them, and it is the same line the rest of the mind
+ *  already draws: below one river window byte overlap is chance, not evidence
+ *  (see identityBar, the bridge's attestedQ, and recognition's site floor).
+ *  Counting every scaffolding byte instead — which is what this did first —
+ *  made punctuation preservation lose a tie it should win, and test/00's
+ *  "period preserved" / "question mark preserved" caught it immediately. */
+export declare function liftedScaffolding(segs: Seg[], queryLen: number, query: Uint8Array, W: number): number;
 export declare function liftAnswer(segs: Seg[], queryLen: number, query: Uint8Array, W: number): Uint8Array | null;
 /** The CHANGED NODES of a freshly-perceived `tree` against the node ids a previous
  *  tracked deposit interned (`prevSeen`). */

package/dist/src/mind/types.js

@@ -46,7 +46,23 @@ export function segRestatesQuery(s, query, queryLen, W) {
  *  (lo/hi) decision and the final concatenation: it is stale, not a second
  *  answer, but the OTHER spans a derivation chose are independent evidence
  *  and must not be discarded along with it. */
-export function liftAnswer(segs, queryLen, query, W) {
+/** The spans {@link liftAnswer} actually concatenates, in order — the answer
+ *  before it is joined.  Exposed so a caller can ask what the lifted answer is
+ *  MADE OF without re-deriving the selection: in particular how much of it is
+ *  SCAFFOLDING (a `rec: false` span — query bytes carried through verbatim
+ *  because nothing explained them, the same spans the liftAnswer trace labels
+ *  "scaffolding" rather than "chosen").
+ *
+ *  That quantity is load-bearing for the grounding decision.  Two candidates
+ *  can leave the SAME number of query bytes unaccounted and therefore grade
+ *  identically, while one of them pads its answer with those bytes and the
+ *  other does not — measured on test/22's two-fact chain, cover and recall
+ *  both graded 11001 with 11 bytes unexplained, and cover won the tie only on
+ *  consideration order, answering "The capital of France is Paris famous for"
+ *  where recall had crossed the hop.  Carrying an unexplained span into the
+ *  answer is strictly weaker than not explaining it: it manufactures fluency
+ *  out of the asker's own words.  See the tie-break in pipeline.ts. */
+export function liftAnswerParts(segs, queryLen, query, W) {
     const restated = segs.map((s) => segRestatesQuery(s, query, queryLen, W));
     const recognised = [];
     for (let k = 0; k < segs.length; k++) {
@@ -54,32 +70,65 @@ export function liftAnswer(segs, queryLen, query, W) {
             recognised.push(k);
     }
     if (recognised.length === 0)
-        return null;
+        return [];
     if (recognised.length === 1) {
         const s = segs[recognised[0]];
-        // A COMPUTED span's query-side width is operand digit-count, not
-        // evidence of how much of the query's meaning it accounts for — the
-        // half-dominance check below (built for a genuinely RECOGNISED learned
-        // form) is not a valid framing signal for it (see the `computed` field
-        // doc on Seg/GItem): "1000 - 421" outweighs "what is …?" by width only
-        // because the operands are big, not because the framing matters less.
-        // A LITERAL PREFIX before a computed span is unambiguous framing
-        // regardless of width — an arithmetic expression is never itself
-        // preceded by more literal computed content, so anything literal before
-        // it is question wording ("what is ", "compute ") to lift clear of.
-        // With no prefix (s.i === 0) the span is judged by the ordinary
-        // half-dominance rule below, which already correctly keeps a short
-        // trailing glue byte ("2+2." → "4.", the span dominates a 4-byte query).
         if (s.computed && s.i > 0)
-            return s.bytes;
+            return [s];
         if (dominates(s.j - s.i, queryLen)) {
-            return concatBytes(segs.filter((_, k) => !restated[k]).map((x) => x.bytes));
+            return segs.filter((_, k) => !restated[k]);
         }
-        return s.bytes;
+        return [s];
     }
     const lo = recognised[0];
     const hi = recognised[recognised.length - 1];
-    return concatBytes(segs.slice(lo, hi + 1).filter((_, k) => !restated[lo + k]).map((x) => x.bytes));
+    return segs.slice(lo, hi + 1).filter((_, k) => !restated[lo + k]);
+}
+/** The SCAFFOLDING byte count of a lifted answer: how many of its bytes come
+ *  from spans nothing recognised (see {@link liftAnswerParts}).
+ *
+ *  ONLY RUNS OF AT LEAST ONE RIVER WINDOW COUNT.  Not all carried-through
+ *  bytes are a failure to explain: a period, a question mark, the space
+ *  between two fused topics are GLUE — they belong to the answer's surface,
+ *  and dropping them to look better-derived would be a worse answer, not a
+ *  more honest one.  A substantive phrase the derivation never explained
+ *  ("famous for") is a different claim entirely.
+ *
+ *  W is the line between them, and it is the same line the rest of the mind
+ *  already draws: below one river window byte overlap is chance, not evidence
+ *  (see identityBar, the bridge's attestedQ, and recognition's site floor).
+ *  Counting every scaffolding byte instead — which is what this did first —
+ *  made punctuation preservation lose a tie it should win, and test/00's
+ *  "period preserved" / "question mark preserved" caught it immediately. */
+export function liftedScaffolding(segs, queryLen, query, W) {
+    // MEASURED PER CONTIGUOUS RUN, not per span.  A PASS span is one BYTE — the
+    // cover charges unrecognised bytes individually — so asking whether a single
+    // span reaches W would find no run ever, whatever the query.  " famous for"
+    // arrives as eleven one-byte spans in a row and is one eleven-byte run.
+    let n = 0;
+    let run = 0;
+    const close = () => {
+        if (run >= W)
+            n += run;
+        run = 0;
+    };
+    for (const s of liftAnswerParts(segs, queryLen, query, W)) {
+        if (s.rec)
+            close();
+        else
+            run += s.bytes.length;
+    }
+    close();
+    return n;
+}
+export function liftAnswer(segs, queryLen, query, W) {
+    // ONE selection rule, in {@link liftAnswerParts} — this is its join.  The
+    // two used to be separate copies of the same lo/hi/restated reasoning, which
+    // is exactly how an answer and the accounting OF that answer drift apart.
+    const parts = liftAnswerParts(segs, queryLen, query, W);
+    if (parts.length === 0)
+        return null;
+    return concatBytes(parts.map((x) => x.bytes));
 }
 /** The CHANGED NODES of a freshly-perceived `tree` against the node ids a previous
  *  tracked deposit interned (`prevSeen`). */

package/dist/src/store.d.ts

@@ -152,6 +152,10 @@ export interface Store {
     contentLen(id: NodeId, cap?: number): number;
     findLeaf(bytes: Uint8Array): NodeId | null;
     findBranch(kids: NodeId[]): NodeId | null;
+    /** {@link findBranch} for a run of single-byte leaves, addressed by the raw
+     *  bytes — the allocation-free probe span scanners use.  Optional: a store
+     *  without it is simply probed through `findBranch`. */
+    findFlatBranch?(bytes: Uint8Array): NodeId | null;
     /** The branch nodes that list `id` among their children — the reverse of
      *  `get(id).kids`. Lets the structural DAG be climbed upward, from a
      *  recognised fragment to the larger learned forms that contain it. */
@@ -585,6 +589,23 @@ export declare abstract class AbstractStore implements Store {
     private _prefix;
     contentLen(id: NodeId, cap?: number): number;
     findLeaf(bytes: Uint8Array): NodeId | null;
+    /** {@link findBranch} for a run of SINGLE-BYTE leaves, addressed by the
+     *  bytes themselves — no kid array, no key string, no copy.
+     *
+     *  A flat branch stores its children as {@link flatKidsBytes}, and that
+     *  encoding is the identity on single-byte leaves: kid id −(b+1) IS byte b.
+     *  So for such a run the kid array and the byte span are the same object in
+     *  two spellings, and `findBranch(leafIds.slice(i, j))` and this call are
+     *  the same lookup — except that the array path allocates the slice, then
+     *  `kids.join(",")`, then the flat bytes, all O(span), for a probe whose
+     *  answer is usually "no".  The bloom filter behind `_dbFindBranchByLeaf`
+     *  answers most of those with no I/O at all, so the allocations dominated.
+     *
+     *  Pass a subarray: it is a view, so a caller scanning spans of a query
+     *  allocates nothing per probe.  Deliberately NOT memoized — its callers
+     *  probe many spans that miss, and a key string per probe is the cost this
+     *  exists to remove. */
+    findFlatBranch(bytes: Uint8Array): NodeId | null;
     findBranch(kids: NodeId[]): NodeId | null;
     parents(id: NodeId): NodeId[];
     parentsFirst(id: NodeId, limit: number): NodeId[];

package/dist/src/store.js

@@ -770,6 +770,27 @@ export class AbstractStore {
             this._leafKey.set(key, id);
         return id;
     }
+    /** {@link findBranch} for a run of SINGLE-BYTE leaves, addressed by the
+     *  bytes themselves — no kid array, no key string, no copy.
+     *
+     *  A flat branch stores its children as {@link flatKidsBytes}, and that
+     *  encoding is the identity on single-byte leaves: kid id −(b+1) IS byte b.
+     *  So for such a run the kid array and the byte span are the same object in
+     *  two spellings, and `findBranch(leafIds.slice(i, j))` and this call are
+     *  the same lookup — except that the array path allocates the slice, then
+     *  `kids.join(",")`, then the flat bytes, all O(span), for a probe whose
+     *  answer is usually "no".  The bloom filter behind `_dbFindBranchByLeaf`
+     *  answers most of those with no I/O at all, so the allocations dominated.
+     *
+     *  Pass a subarray: it is a view, so a caller scanning spans of a query
+     *  allocates nothing per probe.  Deliberately NOT memoized — its callers
+     *  probe many spans that miss, and a key string per probe is the cost this
+     *  exists to remove. */
+    findFlatBranch(bytes) {
+        if (this.meter)
+            this.meter.branchLookups++;
+        return this._dbFindBranchByLeaf(hashOf(bytes), bytes);
+    }
     findBranch(kids) {
         if (this.meter)
             this.meter.branchLookups++;

package/example/train_base.ts

@@ -709,7 +709,18 @@ const isEpisode = (it: TrainingItem): it is Episode => typeof it !== "string";
 /** Build the accumulated-context episodes of a turn sequence: each successive
  *  turn is the continuation of ALL the turns before it joined together. This is
  *  the same cumulative-context shape a multi-turn conversation deposits, so the
- *  store learns to continue a growing context. */
+ *  store learns to continue a growing context.
+ *
+ *  The "\n" below is a CORPUS choice, not a protocol.  oasst2 turns are
+ *  paragraphs, and reading them back with the newlines kept is how this corpus
+ *  reads naturally; a different corpus may join with nothing, and
+ *  test/13-conversation.test.mjs does exactly that.  Neither has to match the
+ *  other, because Sema never scans content for turn boundaries — those are
+ *  offsets the Conversation API carries beside the bytes (see Mind.addTurn's
+ *  "ON SEPARATORS" note).  The newline here is simply part of the text this
+ *  store learnt, so anything replaying this corpus feeds it back as part of
+ *  the turn: `addTurn(conv, "\n" + turnText)`.  It is not a convention the
+ *  engine, the API, or the tests have to agree on. */
 function accumulate(turns: string[]): Episode[] {
   const out: Episode[] = [];
   for (let i = 1; i < turns.length; i++) {
@@ -894,9 +905,15 @@ export function bestOasstPath(root: OasstNode): OasstTurn[] {
  *  turn experiences and local adjacent-pair facts are NOT emitted (they are
  *  subsumed by it and would merely replicate the content).
  *
- *  The walk is byte-for-byte the pattern proven in test/13-conversation.test.mjs
- *  ("teachConversation"): each turn is the continuation of all prior turns joined
- *  by "\n", with BARE turn text — NO "User:/Assistant:" labels. Roles already
+ *  The walk is the pattern proven in test/13-conversation.test.mjs
+ *  ("teachConversation"): each turn is the continuation of all prior turns,
+ *  with BARE turn text — NO "User:/Assistant:" labels.  The SHAPE is identical
+ *  (cumulative context → next turn); the join string is not, and does not need
+ *  to be — that file joins with nothing and this corpus joins with "\n" (see
+ *  `accumulate`).  Saying "byte-for-byte", as this comment used to, invites the
+ *  reading that the two must agree on a separator.  They must not agree,
+ *  because there is nothing to agree about: turn boundaries are offsets, and
+ *  the join string is just corpus text. Roles already
  *  alternate by position in an oasst2 best-path (the root is a prompter), so a
  *  label adds nothing the position does not, while a clean continuation matches
  *  the test's recall (predictNext queries bare prior turns) and lets a turn share

package/package.json

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

package/src/canon.ts

@@ -63,3 +63,31 @@ export function canonHash(key: Uint8Array): number {
   }
   return h >>> 0;
 }
+
+/** The span of `bytes` between its first and last non-whitespace byte — the
+ *  QUESTION, with the caller's edge spacing dropped.  Returns a subarray (no
+ *  copy), and the original when there is nothing to trim.
+ *
+ *  THIS LIVES HERE, not in the core byte utilities, for the reason stated at
+ *  the top of this file: "nothing in the store or the mind's core knows what
+ *  'case' or 'whitespace' is".  Edge spacing is a TEXT fact — for a binary or
+ *  grid modality 0x20 is content, not presentation — so it belongs beside the
+ *  text canonicalizer, is injected on the same modality test, and never leaks
+ *  into a mechanism.  A modality that supplies its own canon supplies its own
+ *  reading of "edge" too, or none.
+ *
+ *  Why trimming is sound HERE when {@link textCanon} deliberately refuses it:
+ *  canon preserves edge whitespace because the hazard is a recognised SUB-span
+ *  swallowing the boundary byte that separates it from its neighbour (observed:
+ *  "ice " matching the stored "ice").  At the outer edges of a WHOLE input
+ *  there is no neighbour — nothing precedes byte 0, nothing follows the last
+ *  byte — so that hazard cannot arise, and only there. */
+export function textEdgeTrim(bytes: Uint8Array): Uint8Array {
+  const space = (b: number) =>
+    b === 0x20 || b === 0x09 || b === 0x0a || b === 0x0d;
+  let from = 0;
+  let to = bytes.length;
+  while (from < to && space(bytes[from])) from++;
+  while (to > from && space(bytes[to - 1])) to--;
+  return from === 0 && to === bytes.length ? bytes : bytes.subarray(from, to);
+}

package/src/geometry.ts

@@ -688,6 +688,97 @@ function contentFoldSpan(
   return segs[0];
 }
 
+/** A plain content fold's reusable state: the level-0 cut edges over the whole
+ *  stream and each segment's independently-folded root.  See
+ *  {@link contentFoldIncremental}. */
+export interface ContentFold {
+  edges: number[];
+  segs: Folded[];
+}
+
+/** {@link contentFoldSpan} over a WHOLE stream, reusing the segments a previous
+ *  fold of a byte-identical prefix already produced.
+ *
+ *  WHY THIS IS SOUND, AND WHY IT NEEDS NO BOUNDARIES.  A level-0 segment is a
+ *  pure function of its own bytes ({@link flatFold} reads nothing else), so
+ *  reusing one whose [start,end) is unchanged is bit-identical to refolding it
+ *  — the cache can never change the tree, only skip work.  And the cuts
+ *  themselves are stable under APPEND: {@link contentLevels} decides each cut
+ *  from a rolling hash over a local window, so bytes added at the right edge
+ *  cannot move a cut to their left (measured over a growing 12-turn context:
+ *  100% of prior cuts survive every append, zero tail churn).  Together those
+ *  two facts are the whole optimisation — a grown stream refolds only the
+ *  segments at its right edge.
+ *
+ *  This is the reuse the conversation path wants, and it costs NOTHING in
+ *  structure: the tree is exactly the tree {@link bytesToTree} builds for the
+ *  same bytes with no boundary set at all.  Turn boundaries buy prefix-ROOT
+ *  identity, which is a different property from incremental reuse; conflating
+ *  the two is what put an imposed boundary set on the inference path and left
+ *  it folding differently from the deposits it was querying.
+ *
+ *  `groupByLevel` above the segments is re-run whole.  It operates on segment
+ *  ROOTS (a few dozen items for a several-hundred-byte context), not on bytes,
+ *  and only its right edge actually changes shape — measured at ~40 rebuilt
+ *  nodes per turn, flat as the context grows sevenfold.
+ *
+ *  PRECONDITION — `prev` MUST have been folded over a BYTE-IDENTICAL PREFIX of
+ *  `bytes`.  Reuse is keyed on a segment's [start,end) OFFSETS, which is what
+ *  makes it O(1) per segment; offsets alone cannot witness that the underlying
+ *  bytes agree.  Hand it a fold of DIFFERENT bytes whose cuts happen to land
+ *  in the same places and it will splice those foreign segments in — measured,
+ *  a deliberately mismatched `prev` produced a wrong tree on 336 of 400 random
+ *  streams.  Verifying the bytes here would cost O(prefix) and defeat the
+ *  whole point, so the obligation sits with the caller, and every caller
+ *  discharges it structurally rather than by care: `perceiveDeposit` looks the
+ *  entry up under `latin1Key(bytes.subarray(0, L))` — the prefix's own bytes
+ *  ARE the cache key — and a conversation's fold state advances only by
+ *  append.  A new caller that cannot make the same structural argument must
+ *  pass no `prev` at all; the cold path is always correct.
+ *  ({@link stablePrefixFoldIncremental} carries the identical precondition for
+ *  the identical reason.) */
+export function contentFoldIncremental(
+  space: Space,
+  alphabet: Alphabet,
+  bytes: Uint8Array,
+  prev?: ContentFold,
+): { tree: Sema; fold: ContentFold } {
+  if (bytes.length === 0) {
+    return {
+      tree: sema(alphabet.vecs[0], new Uint8Array(0), null),
+      fold: { edges: [0], segs: [] },
+    };
+  }
+  const { cuts, levels } = contentLevels(space, bytes);
+  const edges = [0, ...cuts, bytes.length];
+  const segs: Folded[] = [];
+  for (let i = 0; i + 1 < edges.length; i++) {
+    const hit = prev !== undefined && prev.edges[i] === edges[i] &&
+        prev.edges[i + 1] === edges[i + 1]
+      ? prev.segs[i]
+      : undefined;
+    segs.push(hit ?? flatFold(space, alphabet, bytes, edges[i], edges[i + 1]));
+  }
+  const folded = segs.length > 1
+    ? groupByLevel(space, segs, levels, 1)
+    : segs[0];
+  // THE ROOT IS NORMALIZED IN PLACE, A CACHED SEGMENT NEVER IS.  With one
+  // segment — or with a grouping that passes a lone item through — `folded`
+  // IS a cached seg, and a later turn will reuse it as an interior node whose
+  // magnitude must stay byte-proportional.  Copy before normalizing, exactly
+  // as the stable-prefix twin does.  A single LEAF is copied too: its vector
+  // is the shared alphabet entry and must never be written.
+  const aliased = segs.some((s) => s.tree === folded.tree);
+  let tree = folded.tree;
+  if (aliased) {
+    tree = tree.kids === null
+      ? sema(tree.v, tree.leaf, null)
+      : sema(Float32Array.from(tree.v), null, tree.kids);
+  }
+  if (tree.kids !== null) normalize(tree.v);
+  return { tree, fold: { edges, segs } };
+}
+
 /** Group a row of items by the level of the cut BETWEEN them: items separated
  *  by a cut of level < L belong to the same parent, and a cut of level ≥ L ends
  *  it.  Recurses upward until one root remains, so the shape at every level is
@@ -923,9 +1014,17 @@ export function stablePrefixFoldIncremental(
   boundaries: readonly number[],
   prev?: StableFold,
 ): { tree: Sema; fold: StableFold } {
+  // SORTED, like {@link bytesToTree} does before calling the non-incremental
+  // twin.  The filter below is sequential (`b > prevB`), so an out-of-order
+  // entry is silently DROPPED rather than rejected — and these two functions
+  // are documented as producing the same cuts, so a caller that hands the
+  // same set to each and gets different trees has hit a trap, not a contract.
+  // Sorting here makes the twins genuinely interchangeable; the set is one
+  // entry per conversation turn, so the cost is nil.
+  const sorted = [...boundaries].sort((a, b) => a - b);
   const cuts: number[] = [];
   let prevB = 0;
-  for (const b of boundaries) {
+  for (const b of sorted) {
     if (b > prevB && b < bytes.length) {
       cuts.push(b);
       prevB = b;

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/bridge.ts

@@ -97,6 +97,7 @@ import type { MindContext } from "./types.js";
 import { foldTree, perceive, read } from "./primitives.js";
 import { chainReach, leafIdRun } from "./canonical.js";
 import {
+  allWindowsAreScaffolding,
   corpusN,
   edgeAncestors,
   hubBound,
@@ -383,6 +384,39 @@ async function bridgeImpl(
     );
     return null;
   }
+  // NO DISCRIMINATING LITERAL EVIDENCE — abstain (§2.13).  A bridge grounds
+  // through the literal spans it did NOT substitute; those anchors are the
+  // whole of its evidence.  When every one of them is SATURATED — containment
+  // clamped at the √N hub bound, i.e. the window is corpus-global scaffolding
+  // — the query's unsubstituted part discriminates nothing, and the single
+  // substituted span is carrying the entire semantic load.  That is not a
+  // corroborated bridge; it is a template match, and it FABRICATES.
+  //
+  // Measured on the trained store (hubBound 571).  "What is the capital of"
+  // has 19 anchors, ALL saturated ("What":572, "hat ":572, "at i":572 …), and
+  // bridged to an unrelated trained context about an integral, voiced
+  // confidently.  Every query the bridge answers CORRECTLY has at least one
+  // unsaturated anchor, by a wide margin and with no near miss:
+  // "Who is the author of Hamlet?" → "let?":12, "How do you say 'thank you'
+  // in French?" → "y 't":3, "…largest planet…" → "tem?":31, "What is the
+  // capital of France?" → "f Fr":114.  The honest-silence probes sit on the
+  // same side as the correct ones ("Zamu":3), so this gate is not what makes
+  // them silent and cannot be credited for them.
+  //
+  // This introduces NO new threshold: `bound` is the same √N reading of "hub"
+  // the anchor scan already clamps its own containment read to (§2.2, §2.7).
+  if (allWindowsAreScaffolding(ctx, query)) {
+    ctx.trace?.step(
+      "substitutionBridge",
+      [rItem(query, "query")],
+      [],
+      "every query window that could anchor is corpus-global scaffolding — " +
+        "no literal evidence to corroborate a substitution",
+      undefined,
+      diagnostics!,
+    );
+    return null;
+  }
   // CORROBORATION (see the module-level doc) over the precomputed window
   // facts: the query span [qs,qe) attests when every full W-window inside
   // it is a stored flat form and at least one is reused across ≥ 2