@hviana/sema 0.2.3 → 0.2.5

package/src/mind/mechanisms/cover.ts

@@ -11,12 +11,11 @@
 
 import type { MindContext } from "../types.js";
 import type { ComputedResult, Site } from "../graph-search.js";
-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 type { RationaleItem } from "../rationale.js";
 import { rItem, rNode, traceDerivation } from "../trace.js";
@@ -226,44 +225,31 @@ export const coverMechanism: PipelineMechanism = {
 
     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(
@@ -276,11 +262,12 @@ export const coverMechanism: PipelineMechanism = {
       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: Array<[number, number]> = segs
-      .filter((s) => s.rec)
+      .filter((s) => s.rec && !segRestatesQuery(s, query, query.length, W))
       .map((s) => [s.i, s.j]);
 
     return [{

package/src/mind/mechanisms/recall.ts

@@ -20,6 +20,7 @@ import { CONCEPT, STEP } from "../graph-search.js";
 import { unexplainedLabel } from "../rationale.js";
 import type { PipelineMechanism, Precomputed } from "../pipeline-mechanism.js";
 import { rItem, rNode } from "../trace.js";
+import { substitutionBridge } from "../bridge.js";
 
 /** A recall result. */
 export interface RecallResult {
@@ -293,6 +294,84 @@ export async function recallByResonance(
       }
     }
   }
+  // 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/src/mind/mind.ts

@@ -136,6 +136,21 @@ import {
   climbAttention as climbAttentionFn,
   naturalBreak as naturalBreakFn,
 } from "./attention.js";
+export type {
+  AnchorRejectionReason,
+  ClimbConsensusData,
+  ConsensusAnchorTrace,
+  ConsensusReachTrace,
+  ConsensusRegionTrace,
+  CrossRegionTier,
+  JunctionVoteTrace,
+  RegionOutcome,
+} from "./attention.js";
+export type {
+  AncestorReach,
+  SaturationReason,
+  SaturationStop,
+} from "./types.js";
 import { aluToMechanism, defaultMechanisms, think } from "./pipeline.js";
 import { articulate } from "./articulation.js";
 import { ingest } from "./learning.js";

package/src/mind/rationale.ts

@@ -83,6 +83,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
@@ -142,7 +147,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}.
@@ -212,6 +217,7 @@ export class Rationale {
     outputs: RationaleItem[],
     deps: number[] | undefined,
     note: string | undefined,
+    data?: unknown,
   ): void {
     this.sink({
       index,
@@ -223,6 +229,7 @@ export class Rationale {
       inputs,
       outputs,
       note,
+      data,
     });
   }
 
@@ -248,11 +255,11 @@ 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);
       },
     };
   }
@@ -265,11 +272,12 @@ export class Rationale {
     outputs: RationaleItem[],
     note?: string,
     deps?: number[],
+    data?: unknown,
   ): number {
     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/src/mind/reasoning.ts

@@ -13,6 +13,20 @@ import { joinWithBridge, pivotInto } from "./resonance.js";
 import type { Precomputed } from "./pipeline-mechanism.js";
 import type { Rationale } from "./rationale.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: Uint8Array, bytes: Uint8Array): boolean {
+  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
@@ -91,7 +105,8 @@ export async function reason(
       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", [
@@ -115,7 +130,7 @@ export async function reason(
 
     const fc = await follow(ctx, pivot, qv);
     consumeAll(pivot);
-    if (fc === null || bytesEqual(fc, cur)) break;
+    if (fc === null || bytesEqual(fc, cur) || restatesQuery(query, fc)) break;
     t ??= ctx.trace?.enter("reason", [rItem(startedFrom, "grounded")]);
     ctx.trace?.step(
       "pivotStep",
@@ -189,6 +204,60 @@ export async function fuseAttention(
     ...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;
     if (pieces.some((p) => indexOf(p.bytes, g, 0) >= 0)) continue;

package/src/mind/recognition.ts

@@ -16,7 +16,7 @@ import {
   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, type Sema } from "../sema.js";
 import type { Leaf, Site } from "./graph-search.js";
 
@@ -34,12 +34,44 @@ import type { Leaf, Site } from "./graph-search.js";
  *  Both O(n · maxGroup) bounded O(1) probes — never a scan of the corpus. */
 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).  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) return hit;
+    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;
@@ -83,8 +115,18 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
   // 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<string>();
   const emit = (start: number, end: number, id: number) => {
     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 });
     }
@@ -101,10 +143,93 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
     // 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);