@hviana/sema 0.2.3 → 0.2.5

package/dist/src/mind/mechanisms/cover.js

@@ -8,12 +8,11 @@
 // cover runs FIRST in defaultMechanisms: a computed-backed cover becomes a
 // near-zero-cost incumbent that prunes the other mechanisms through the
 // ordinary admissible-floor check, with no extension special-case anywhere.
-import { bytesEqual, indexOf } from "../../bytes.js";
 import { read, resolve } from "../primitives.js";
 import { guidedFirst } from "../traverse.js";
 import { conceptHop } from "../match.js";
 import { bridge } from "../resonance.js";
-import { liftAnswer } from "../types.js";
+import { liftAnswer, segRestatesQuery } from "../types.js";
 import { decodeText, unexplainedLabel } from "../rationale.js";
 import { rItem, rNode, traceDerivation } from "../trace.js";
 // ── Concept / connector pre-resolution ──────────────────────────────────────
@@ -166,46 +165,32 @@ export const coverMechanism = {
             : "lightest derivation: the chosen spans, left to right");
         if (segs === null)
             return [];
+        const W = ctx.space.maxGroup;
         // A chosen span's SUBSTITUTED bytes (an edge followed from a recognised
         // site, not the site's own literal text read back) that equal a byte
         // span the query ALREADY CONTAINS elsewhere restates part of the
-        // question — never an answer (the same principle recall.ts's tiers
-        // apply to a whole-query projection: "a projection that is a proper
-        // byte-subspan of the query restates part of the question").  A
+        // question — never an answer (see {@link segRestatesQuery}).  A
         // recognised site that is itself an entire PRIOR TURN of a multi-turn
         // query is exactly this shape: it carries a genuine learnt
         // continuation, but that continuation is something the asker already
-        // said moments later in the SAME query, not a new answer — the cover
-        // search has no notion of "turn" to gate this itself, so the check
-        // belongs here, over the derivation it already chose.
-        const W = ctx.space.maxGroup;
-        for (const s of segs) {
-            if (!s.rec)
-                continue;
-            const literal = s.j - s.i === s.bytes.length &&
-                bytesEqual(s.bytes, query.subarray(s.i, s.j));
-            if (literal)
-                continue;
-            // A span shorter than one river window is exactly the "ice"/"c"
-            // case: a chain hop's short terminal coincidentally recurring as a
-            // substring of an unrelated longer word.  Below the quantum, byte
-            // overlap is chance, not evidence — the same floor identityBar and
-            // reachThreshold hold every other structural-overlap claim to.
-            if (s.bytes.length >= W && s.bytes.length < query.length &&
-                indexOf(query, s.bytes, 0) >= 0) {
-                ctx.trace?.step("restatedSpan", [rItem(s.bytes, "substituted", s.node, [s.i, s.j])], [], "the chosen span's substitution already occurs elsewhere in the query — restates it, not an answer");
-                return [];
-            }
+        // said moments later in the SAME query.  liftAnswer TRIMS such spans
+        // out of both the framing decision and the final concatenation — the
+        // OTHER spans a derivation chose are independent evidence and must not
+        // be discarded along with the stale one.
+        const restated = segs.filter((s) => segRestatesQuery(s, query, query.length, W));
+        if (restated.length > 0) {
+            ctx.trace?.step("restatedSpan", restated.map((s) => rItem(s.bytes, "substituted", s.node, [s.i, s.j])), [], "the chosen span's substitution already occurs elsewhere in the query — trimmed from the answer, not an answer itself");
         }
-        const composed = liftAnswer(segs, query.length);
+        const composed = liftAnswer(segs, query.length, query, W);
         if (composed === null)
             return [];
         ctx.trace?.step("liftAnswer", segs.map((s) => rItem(s.bytes, s.rec ? "chosen" : "scaffolding", s.node, [s.i, s.j])), [rItem(composed, "answer", resolve(ctx, composed) ?? undefined)], "lift the recognised region out of the asker's framing", tCover ? [tCover.index] : undefined);
-        // accounted = RECOGNISED cover spans only — PASS-carried bytes
-        // are priced in cost already; the diagnostic label reflects the
-        // same distinction.
+        // accounted = RECOGNISED, non-restating cover spans only — a trimmed
+        // restated span contributes nothing to the composed answer, so it must
+        // not be priced as if it did (PASS-carried bytes are priced already;
+        // the diagnostic label reflects the same distinction).
         const accounted = segs
-            .filter((s) => s.rec)
+            .filter((s) => s.rec && !segRestatesQuery(s, query, query.length, W))
             .map((s) => [s.i, s.j]);
         return [{
                 bytes: composed,

package/dist/src/mind/mechanisms/recall.js

@@ -12,6 +12,7 @@ import { follow, project, reverseContext } from "../match.js";
 import { CONCEPT, STEP } from "../graph-search.js";
 import { unexplainedLabel } from "../rationale.js";
 import { rItem, rNode } from "../trace.js";
+import { substitutionBridge } from "../bridge.js";
 /** Recall the answer by resonating the whole query against the content index. */
 export async function recallByResonance(ctx, query, pre) {
     const t = ctx.trace?.enter("recallByResonance", [
@@ -209,6 +210,71 @@ export async function recallByResonance(ctx, query, pre) {
             }
         }
     }
+    // 3b. Corroborated-substitution bridge — refusal-path only (bridge.ts).
+    // Every gist-based tier has failed; before refusing, align the query
+    // byte-for-byte against the trained contexts its own stored windows
+    // anchor, accepting mismatches only as corpus-attested, concept-bar
+    // substitutions.  A bridged context grounds exactly like any hit —
+    // projected through its learnt edges — under the same restated-fragment
+    // guard tiers 0b/2 apply.  Costs nothing on any answering path.
+    {
+        // The resonance hits already ranked above are handed to the bridge as
+        // PROPOSED candidates alongside its own anchor climbs: on a corpus this
+        // size a W-byte window is far too common for the clamped climb to
+        // single out the right trained context, while the whole-query gist
+        // already ranked it nearest (observed live: "what is the capital of
+        // france" resonating straight to "What is the capital of France?" yet
+        // refusing on the reach bar).  Approximate scores propose; the bridge's
+        // byte-exact alignment and attestation gates decide.
+        //
+        // The proposal breadth here is widened PAST `k` — first by requesting
+        // hubBound(ctx) candidates instead of `k` (recall's own tiers above
+        // stay at `k`; this re-resonates only on the refusal path, exactly
+        // where the bridge itself already runs), AND by asking the index to
+        // search EXHAUSTIVELY.  Both matter: the IVF only ever probes
+        // ⌈√clusters⌉ of them (store.ts's efFor) REGARDLESS of k — widening k
+        // alone just returns more hits from the SAME already-probed clusters,
+        // never a hit whose vector lives in an unprobed one.  Measured live:
+        // "What is the chemical symbol for water?" needs "What is the
+        // chemical formula for water?", scoring only 0.58 against the
+        // query's gist (a MIDDLE-of-string word swap perturbs the river-fold
+        // tree hash far more than a same-length TAIL swap like the "carbon"/
+        // "oxygen" neighbours that outrank it at 0.87+) — absent from the
+        // resonance list even at k=5000, present and byte-exact-verified the
+        // moment it's force-fed to the bridge directly.  `exhaustive` is the
+        // natural, tuning-free ceiling (probe every cluster) for a call that
+        // is ALREADY refusal-path-only and must not miss a candidate hiding
+        // behind an unlucky structural distance.
+        const wide = k < hubBound(ctx)
+            ? await ctx.store.resonate(queryGist, hubBound(ctx), true)
+            : whole;
+        const bridged = await substitutionBridge(ctx, query, wide.map((h) => h.id));
+        if (bridged !== null) {
+            const g = await project(ctx, bridged.id, queryGist);
+            // A projection contained in a substituted candidate-side span is the
+            // substitution RESTATED as if it were knowledge — the exact failure
+            // observed live: "Darwin was born in England." bridged to the
+            // Einstein fact through " England." → " Germany." and would have
+            // voiced "Germany", an answer the substitution itself manufactured.
+            // The same principle as the restated-fragment guards above, extended
+            // to the bridge's own substitutions.
+            const cBytes = ctx.store.bytes(bridged.id);
+            const manufactured = g !== null &&
+                bridged.subs.some((s) => indexOf(cBytes.subarray(s.cs, s.ce), g, 0) >= 0);
+            if (g !== null && g.length > 0 && !restates(g) && !manufactured &&
+                !(g.length < query.length && indexOf(query, g, 0) >= 0)) {
+                return ground(g, `substitution bridge — a trained context accounts for the query ` +
+                    `up to ${bridged.subs.length} corroborated substitution(s)`, 
+                // Accounted NOTHING — the same epistemic humility as the echo
+                // tier below: a substitution-bridged grounding is a last resort
+                // that must lose to ANY mechanism that actually explained the
+                // query (observed: pricing the aligned spans here outweighed
+                // extraction's correct answer in the grounding decider), while
+                // still beating silence when everything else refused.
+                [], CONCEPT * bridged.subs.length + STEP);
+            }
+        }
+    }
     // The refusal/echo decision.  The echo returns a stored form's bytes AS
     // the answer — a near-identity claim about the query — and identity-grade
     // decisions are never made on an estimated score ("approximate scores may

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

@@ -42,6 +42,8 @@ export interface Conversation {
     readonly id: number;
 }
 import type { AttentionRead, MindContext, Recognition } from "./types.js";
+export type { AnchorRejectionReason, ClimbConsensusData, ConsensusAnchorTrace, ConsensusReachTrace, ConsensusRegionTrace, CrossRegionTier, JunctionVoteTrace, RegionOutcome, } from "./attention.js";
+export type { AncestorReach, SaturationReason, SaturationStop, } from "./types.js";
 export interface MindOptions {
     seed?: number;
     recallQueryK?: number;

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

@@ -59,6 +59,11 @@ export interface RationaleStep {
     /** A one-line, human account of what the mechanism did and why — the sentence
      *  that turns the data into an explanation. */
     note?: string;
+    /** Optional structured payload — a mechanism-specific, plain-serialisable
+     *  shape (no Map/Set/vectors/mutable internals) that carries more than the
+     *  human-readable `note` can, for a debugger or downstream tool to consume
+     *  programmatically.  Never read by inference; purely additive. */
+    data?: unknown;
 }
 /** The callback {@link Mind.respond} / {@link Mind.respondText} accept.  It is
  *  invoked once per completed step, AS the inference unfolds — never batched at
@@ -86,7 +91,7 @@ export interface Scope {
     /** Close the mechanism: emit its step with these outputs and pop it off the
      *  nesting stack.  Idempotent — a second call is ignored, so a `finally` that
      *  closes after an early return is safe. */
-    done(outputs: RationaleItem[], note?: string): void;
+    done(outputs: RationaleItem[], note?: string, data?: unknown): void;
 }
 /** The live tracer: a stack of open mechanisms over one {@link Mind.respond}.
  *
@@ -130,5 +135,5 @@ export declare class Rationale {
     enter(name: string, inputs: RationaleItem[], deps?: number[]): Scope;
     /** Record a mechanism that has no sub-steps — its inputs and outputs are both
      *  known at the call site.  Returns its index, for a later step to depend on. */
-    step(name: string, inputs: RationaleItem[], outputs: RationaleItem[], note?: string, deps?: number[]): number;
+    step(name: string, inputs: RationaleItem[], outputs: RationaleItem[], note?: string, deps?: number[], data?: unknown): number;
 }

package/dist/src/mind/rationale.js

@@ -109,7 +109,7 @@ export class Rationale {
         this.lastByName.set(name, index);
         return index;
     }
-    emit(index, mechanism, inputs, outputs, deps, note) {
+    emit(index, mechanism, inputs, outputs, deps, note, data) {
         this.sink({
             index,
             mechanism,
@@ -120,6 +120,7 @@ export class Rationale {
             inputs,
             outputs,
             note,
+            data,
         });
     }
     /** Enter a mechanism that has sub-steps.  Captures its inputs and the nesting
@@ -141,22 +142,22 @@ export class Rationale {
         };
         return {
             index,
-            done: (outputs, note) => {
+            done: (outputs, note, data) => {
                 if (closed)
                     return;
                 closed = true;
                 pop();
-                emit(index, mechanism, inputs, outputs, resolvedDeps, note);
+                emit(index, mechanism, inputs, outputs, resolvedDeps, note, data);
             },
         };
     }
     /** Record a mechanism that has no sub-steps — its inputs and outputs are both
      *  known at the call site.  Returns its index, for a later step to depend on. */
-    step(name, inputs, outputs, note, deps) {
+    step(name, inputs, outputs, note, deps, data) {
         const mechanism = this.path(name);
         const resolvedDeps = deps ?? this.defaultDeps();
         const index = this.reserve(name);
-        this.emit(index, mechanism, inputs, outputs, resolvedDeps, note);
+        this.emit(index, mechanism, inputs, outputs, resolvedDeps, note, data);
         return index;
     }
 }

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

@@ -1,5 +1,16 @@
 import type { MindContext } from "./types.js";
 import type { Precomputed } from "./pipeline-mechanism.js";
+/** Whether `bytes` is a proper byte-subspan of `query` — already present in
+ *  the question, so voicing it back only restates part of what was asked,
+ *  never answers it.  The exact guard recallByResonance already applies to
+ *  its OWN grounding candidates (tier 1's `restates`, tier 2's subspan
+ *  check, tier 0b's argument-binding subspan check) — every mechanism that
+ *  walks a LEARNT CONTINUATION EDGE past an already-vetted grounding
+ *  (reason()'s own hops below, and CAST's `projectCounterfactual` seat
+ *  substitution — see cast.ts) needs the same guard applied to what the
+ *  walk turns up, since `follow()`/`chooseNext`/`pivotInto` know nothing of
+ *  the query at all — only of what structurally continues what. */
+export declare function restatesQuery(query: Uint8Array, bytes: Uint8Array): boolean;
 /** Extend a grounded answer forward across facts (multi-hop reasoning).
  *  Pivots on the longest unconsumed learnt context each answer contains,
  *  then follows the pivot's continuation to the next fact.  Repeats up

package/dist/src/mind/reasoning.js

@@ -8,6 +8,19 @@ import { resolve } from "./primitives.js";
 import { corpusN } from "./traverse.js";
 import { follow, haloSiblings, project } from "./match.js";
 import { joinWithBridge, pivotInto } from "./resonance.js";
+/** Whether `bytes` is a proper byte-subspan of `query` — already present in
+ *  the question, so voicing it back only restates part of what was asked,
+ *  never answers it.  The exact guard recallByResonance already applies to
+ *  its OWN grounding candidates (tier 1's `restates`, tier 2's subspan
+ *  check, tier 0b's argument-binding subspan check) — every mechanism that
+ *  walks a LEARNT CONTINUATION EDGE past an already-vetted grounding
+ *  (reason()'s own hops below, and CAST's `projectCounterfactual` seat
+ *  substitution — see cast.ts) needs the same guard applied to what the
+ *  walk turns up, since `follow()`/`chooseNext`/`pivotInto` know nothing of
+ *  the query at all — only of what structurally continues what. */
+export function restatesQuery(query, bytes) {
+    return bytes.length < query.length && indexOf(query, bytes, 0) >= 0;
+}
 /** Extend a grounded answer forward across facts (multi-hop reasoning).
  *  Pivots on the longest unconsumed learnt context each answer contains,
  *  then follows the pivot's continuation to the next fact.  Repeats up
@@ -81,7 +94,8 @@ export async function reason(ctx, query, answer, preConsumed, pre) {
             const fwd = await follow(ctx, curId, qv);
             const fwdId = fwd !== null ? resolve(ctx, fwd) : null;
             if (fwd !== null && !bytesEqual(fwd, cur) &&
-                (fwdId === null || !consumed.has(fwdId))) {
+                (fwdId === null || !consumed.has(fwdId)) &&
+                !restatesQuery(query, fwd)) {
                 consumeAll(curId);
                 t ??= ctx.trace?.enter("reason", [
                     rItem(startedFrom, "grounded"),
@@ -98,7 +112,7 @@ export async function reason(ctx, query, answer, preConsumed, pre) {
             break;
         const fc = await follow(ctx, pivot, qv);
         consumeAll(pivot);
-        if (fc === null || bytesEqual(fc, cur))
+        if (fc === null || bytesEqual(fc, cur) || restatesQuery(query, fc))
             break;
         t ??= ctx.trace?.enter("reason", [rItem(startedFrom, "grounded")]);
         ctx.trace?.step("pivotStep", [rItem(cur, "answer"), rNode(ctx, pivot, "pivot")], [rItem(fc, "answer", resolve(ctx, fc) ?? undefined)], "pivot on the shared span this answer contains, then step forward across that fact");
@@ -158,6 +172,48 @@ unclimbed = false) {
         ...rest.map((r) => rNode(ctx, r.anchor, "point", r.vote)),
     ]);
     for (const root of rest) {
+        // DISPERSION: this root's contributing regions are confined to a
+        // single cluster (see Attention.clusters) — one local neighbourhood of
+        // the query, not several separate places.  Raw region count already
+        // failed to discriminate a coincidental match from a genuine further
+        // topic (test/24 gap 3.1 vs test/35's echo); dispersion is a different
+        // question — not how MUCH evidence, but how many separate PLACES in the
+        // query corroborate it — and a coincidental match is structurally
+        // confined to one cluster no matter how strongly it resonates.
+        //
+        // EXCEPTION: crossRegionVotes' own joint conclusions (a query naming
+        // two attributes that were only ever learnt TOGETHER — test/34's own
+        // binding corpus) are inherently ONE fused context and are pooled from
+        // a single synthetic region, so they always read as one cluster even
+        // though they already, by construction, account for both original
+        // mentions.  `breadth` (dominates — the same > half-the-query bar used
+        // everywhere else) still correctly recognises these: a genuine joint
+        // binding explains the MAJORITY of the query's regions on its own,
+        // which a coincidental echo never does (verified: test/35's echo tops
+        // out at 0.40).  So a root is trusted when EITHER measure alone
+        // indicates real signal — excluded only when BOTH are weak.  Cheap and
+        // synchronous — checked before the async already-answered walk below.
+        if (root.clusters < 2 && root.breadth <= 0.5) {
+            ctx.trace?.step("singleCluster", [rNode(ctx, root.anchor, "point", root.vote)], [], "this point's evidence is confined to one local neighbourhood of the query — not trusted as an independent topic");
+            continue;
+        }
+        // ALREADY ANSWERED: this root's own learnt continuation — the same
+        // content-addressed walk reason()'s echo guard already trusts
+        // (`ctx.store.prevCount(qId) > 0`), here applied per-candidate instead
+        // of to the whole query — is VERBATIM present later in the query.  A
+        // query that embeds both an exchange's ask and its own already-given
+        // reply (a conversation's turn plus its own prior answer, concatenated
+        // raw by addTurn — or any caller pasting a transcript into one
+        // respond() call; the check is Mind-bookkeeping-free, so it treats both
+        // identically) has already spoken this root's answer — fusing it in
+        // again would only restate it.  Deliberately NOT a magnitude measure:
+        // it fires on exact content-addressed recurrence, not on how strongly
+        // the root resonates.
+        const cont = await follow(ctx, root.anchor, qv);
+        if (cont !== null && cont.length > 0 && indexOf(query, cont, root.end) >= 0) {
+            ctx.trace?.step("alreadyAnswered", [rNode(ctx, root.anchor, "point", root.vote)], [rItem(cont, "continuation")], "this point's own learnt continuation already appears later in the query — already answered, not fused");
+            continue;
+        }
         const g = await project(ctx, root.anchor, qv);
         if (g === null || g.length === 0)
             continue;

package/dist/src/mind/recognition.js

@@ -7,7 +7,7 @@
 import { rItem } from "./trace.js";
 import { canonResolve, foldTree, gistOf, latin1Key, perceive, resolve, } from "./primitives.js";
 import { atomIsHub, corpusN, leadsSomewhere } from "./traverse.js";
-import { chainReach, leafIdAt } from "./canonical.js";
+import { chainReach, leafIdAt, leafIdRun } from "./canonical.js";
 import { isChunk } from "../sema.js";
 /** Decompose a byte stream into every stored form that leads somewhere
  *  (has a continuation edge or a halo).  Two complementary readings:
@@ -23,13 +23,37 @@ import { isChunk } from "../sema.js";
  *  Both O(n · maxGroup) bounded O(1) probes — never a scan of the corpus. */
 export function recognise(ctx, bytes) {
     // Content-keyed memo — works for both single-turn respond() and multi-turn
-    // respondTurn() (where the map persists across calls).  Skipped while
-    // tracing so every call still emits its rationale step.
-    if (ctx.recogniseMemo && !ctx.trace) {
+    // 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
+    // recogniseImpl.
+    if (ctx.recogniseMemo) {
         const key = latin1Key(bytes);
         const hit = ctx.recogniseMemo.get(key);
-        if (hit !== undefined)
+        if (hit !== undefined) {
+            ctx.trace?.step("recognise", [rItem(bytes, "query")], hit.sites.map((s) => rItem(bytes.subarray(s.start, s.end), "form", s.payload, [
+                s.start,
+                s.end,
+            ])), `decompose the query into ${hit.sites.length} learnt form(s) that ` +
+                `lead somewhere (over ${hit.leaves.length} perceived leaves) [cached]`);
             return hit;
+        }
         const fresh = recogniseImpl(ctx, bytes);
         ctx.recogniseMemo.set(key, fresh);
         return fresh;
@@ -71,9 +95,20 @@ function recogniseImpl(ctx, bytes) {
     // silence.  Atoms stay available as leaves (PASS-carried literals) and
     // through exact tier-0 resolution regardless.
     const atomsAreHubs = atomIsHub(ctx, corpusN(ctx));
+    // Distinct probes (structural exact match, canon fallback, edge trims at
+    // several offsets) can legitimately re-derive the SAME (start, end, id)
+    // site from different tree nodes — a wide edge-trim search is exactly
+    // this on purpose (see below).  Duplicate site entries are not wrong
+    // evidence, but they double the weight cover's derivation search gives
+    // that span, distorting its cost model — the same span must count once.
+    const seen = new Set();
     const emit = (start, end, id) => {
         if (id < 0 && atomsAreHubs)
             return;
+        const key = start + "," + end + "," + id;
+        if (seen.has(key))
+            return;
+        seen.add(key);
         if (leadsSomewhere(ctx, id)) {
             sites.push({ start, end, payload: id });
         }
@@ -90,11 +125,96 @@ function recogniseImpl(ctx, bytes) {
         // missed may still be a stored form under the response's equivalence
         // (case, width, whitespace — whatever the injected canonicalizer says).
         // O(subtree bytes) per miss, memoised per response; a no-op when no
-        // canonicalizer was injected or the store has no canon index.
-        else if (end - start >= 2) {
+        // canonicalizer was injected or the store has no canon index.  A raw
+        // leaf (n.kids === null) is single-byte and handled by the byte-atom
+        // path above instead — canon equivalence only applies to composites.
+        else if (n.kids !== null) {
             const cid = canonResolve(ctx, bytes.subarray(start, end));
             if (cid !== null)
                 emit(start, end, cid);
+            // The edge-trim fallbacks below remove 1 byte from a side; the
+            // remainder must still be a composite (>= 2 bytes, the same floor
+            // n.kids !== null enforces above) rather than degenerate into
+            // single-byte-atom territory, which atomIsHub already governs
+            // separately.
+            else if (end - start - 1 >= 2) {
+                // The chunk's own boundary is drawn by content geometry, not by
+                // any notion of "form" — it can include one edge byte the query's
+                // fold happened to attach here that the trained span never had
+                // (e.g. a separator from the preceding chunk).  The core has no
+                // idea what that byte means; it only knows resolve()/canonResolve
+                // are self-verifying (hash-then-verify, same discipline as every
+                // content lookup here), so a blind one-byte-shorter guess on
+                // either edge costs nothing when wrong and is trustworthy when it
+                // hits.  Two extra probes, only on the already-failed miss path.
+                const left = resolve(ctx, bytes.subarray(start + 1, end));
+                if (left !== null)
+                    emit(start + 1, end, left);
+                const right = resolve(ctx, bytes.subarray(start, end - 1));
+                if (right !== null)
+                    emit(start, end - 1, right);
+                // A misalignment wider than one byte (e.g. more than one edge
+                // separator swallowed) is not itself geometry-quantized — the
+                // WRITE side's canonical index (canonicalWindows) interns sliding
+                // W−1/W-length windows over leaf ids at EVERY offset, not just
+                // radix-aligned ones (see canonical.ts) — so the offset that
+                // recovers a trained span can be anything, not a multiple of W.
+                // What IS bounded is how far it's worth looking: chainReach(W)=W²,
+                // the same reach the canonical pass (tryChain) trusts for a chain
+                // rebuilt off the query's own fold.  Every candidate offset is
+                // gated by store.findBranch(leafIds) first — the SAME cheap,
+                // fold-free existence check tryChain already uses — so the extra
+                // resolve() fold (the real cost) is only paid when a branch could
+                // plausibly exist there, not for every offset.  The node itself is
+                // also bounded to chunk-scale (end - start <= W²): widening this at
+                // whole-query/root scale can rediscover a smaller subtree's own
+                // content as a second, overlapping site the structural walk's own
+                // finer recursion already emits correctly on its own — a duplicate
+                // that downstream derivation can stitch into a wrong answer.
+                const W = ctx.space.maxGroup;
+                for (let k = 1; end - start <= W * W && k <= W * W && start + k < end - 1; k++) {
+                    const lIds = leafIdRun(ctx, bytes, start + k, end);
+                    if (lIds !== null && store.findBranch(lIds) !== null) {
+                        const eLeft = resolve(ctx, bytes.subarray(start + k, end));
+                        if (eLeft !== null)
+                            emit(start + k, end, eLeft);
+                    }
+                    const rIds = leafIdRun(ctx, bytes, start, end - k);
+                    if (rIds !== null && store.findBranch(rIds) !== null) {
+                        const eRight = resolve(ctx, bytes.subarray(start, end - k));
+                        if (eRight !== null)
+                            emit(start, end - k, eRight);
+                    }
+                }
+                // A REAL extra word at the left edge (a discourse connective like
+                // "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;
+                    const cid = canonResolve(ctx, bytes.subarray(p, end));
+                    if (cid !== null)
+                        emit(p, end, cid);
+                }
+            }
         }
         if (isChunk(n)) {
             starts.add(start);