@hviana/sema 0.4.1 → 0.4.2

package/src/mind/match.ts

@@ -25,7 +25,7 @@
 // mechanism file states only its configuration, never its own copy of the
 // machinery.  The gates all live in geometry.ts (derived, never tuned).
 
-import { cosine, Vec } from "../vec.js";
+import { addInto, cosine, dot, normalize, Vec, zeros } from "../vec.js";
 import type { Hit } from "../store.js";
 import { conceptThreshold, identityBar, significanceBar } from "../geometry.js";
 import { indexOf } from "../bytes.js";
@@ -36,9 +36,12 @@ import {
   argmaxCosine,
   chooseAmong,
   chooseNext,
+  corpusN,
+  edgeAncestors,
   guidedFirst,
   hubBound,
   hubCap,
+  sharedReachMemo,
 } from "./traverse.js";
 import { recognise, segment } from "./recognition.js";
 import type { Site } from "./graph-search.js";
@@ -347,6 +350,94 @@ export async function haloSiblings(
   return out;
 }
 
+/** Bundle the distributional company of every addressable W-window in a
+ *  byte span.  This is the query-time counterpart of the write-side halo
+ *  pours: no lexical unit or storage row is invented; the span is represented
+ *  by VSA superposition of the window concepts the store already knows.
+ *
+ *  Components are normalized before bundling so repetition mass remains
+ *  evidence about each stored node, not an accidental weight on one window
+ *  inside the composed phrase.  Returns null when the corpus provides no
+ *  distributional evidence for the span. */
+export function spanHalo(
+  ctx: MindContext,
+  bytes: Uint8Array,
+  from = 0,
+  to = bytes.length,
+): Vec | null {
+  const W = ctx.space.maxGroup;
+  if (to - from < W) return null;
+  if (ctx.meter) ctx.meter.spanHalos++;
+  const out = zeros(ctx.store.D);
+  let found = false;
+  const added = new Set<number>();
+  const episodeRoots: number[][] = [];
+  const N = corpusN(ctx);
+  const reachMemo = sharedReachMemo(ctx);
+  const addHalo = (id: number): void => {
+    if (added.has(id)) return;
+    const halo = ctx.store.halo(id);
+    if (halo === null) return;
+    const norm = Math.sqrt(dot(halo, halo));
+    if (norm === 0) return;
+    added.add(id);
+    addInto(out, halo, 1 / norm);
+    found = true;
+  };
+  const windowCount = to - from - W + 1;
+  const offsets: number[] = [];
+  const samples = Math.min(W, windowCount);
+  for (let i = 0; i < samples; i++) {
+    const relative = samples === 1
+      ? 0
+      : Math.floor((i * (windowCount - 1)) / (samples - 1));
+    const off = from + relative;
+    if (offsets[offsets.length - 1] !== off) offsets.push(off);
+  }
+  for (const off of offsets) {
+    if (ctx.meter) ctx.meter.spanHaloWindows++;
+    const ids = leafIdRun(ctx, bytes, off, off + W);
+    if (ids === null) continue;
+    const id = ctx.store.findBranch(ids);
+    if (id === null) continue;
+    addHalo(id);
+    // Canonical flat windows are retrieval addresses and normally carry no
+    // halo themselves. Their bounded structural ascent reaches the learned
+    // episode forms that contain them; bundling those forms' company is the
+    // distributional meaning of the window, derived entirely from existing
+    // containment and halo state.
+    if (!added.has(id)) {
+      episodeRoots.push(edgeAncestors(ctx, id, N, reachMemo).roots);
+    }
+  }
+  for (let rank = 0; added.size < ctx.cfg.haloQueryK; rank++) {
+    let any = false;
+    for (const roots of episodeRoots) {
+      if (rank >= roots.length) continue;
+      any = true;
+      addHalo(roots[rank]);
+      if (added.size >= ctx.cfg.haloQueryK) break;
+    }
+    if (!any) break;
+  }
+  return found ? normalize(out) : null;
+}
+
+/** Distributional synonym evidence between arbitrary byte spans. Whole words
+ *  need not be independently interned: their stored W-window occurrences are
+ *  lifted to episode halos, bundled, and compared. The caller chooses the
+ *  derived gate appropriate to its claim (concept identity or analogy). */
+export function spanSynonymStrength(
+  ctx: MindContext,
+  a: Uint8Array,
+  b: Uint8Array,
+): number {
+  const ah = spanHalo(ctx, a);
+  const bh = spanHalo(ctx, b);
+  if (ah === null || bh === null) return 0;
+  return cosine(ah, bh);
+}
+
 /** The DISTRIBUTIONAL matcher between two nodes: mutual-nearest-neighbour
  *  strength, not a pick.  Returns the direct halo cosine, or failing that the
  *  highest mutual-halo-sibling min-score (second-order analogy), or failing

package/src/mind/mechanisms/cast.ts

@@ -274,6 +274,18 @@ export async function counterfactualTransfer(
       `${points.length} aligned structure(s), but none is one of the climb's ` +
         `${roots.length} committed root(s) — CAST refuses to transfer through ` +
         `content the climb itself never settled on`,
+      {
+        aligned: points.map((p) => ({
+          anchor: p.anchor,
+          vote: p.vote,
+          runs: p.runs.map((r) => ({ ...r })),
+          coveredBytes: p.runs.reduce((n, r) => n + r.qe - r.qs, 0),
+        })),
+        committedRoots: roots.map((r) => ({
+          anchor: r.anchor,
+          vote: r.vote,
+        })),
+      },
     );
     return [];
   }

package/src/mind/mechanisms/confluence.ts

@@ -91,7 +91,23 @@ export async function confluenceJoin(
   // with the query is the CONSTRAINT being re-named (or its scaffolding),
   // never the open seat the question asks for — subtracted by identity,
   // below.
-  const queryWin = pre.queryWindows;
+  // Completed assistant turns are context the engine already produced, not
+  // independent constraints asserted by the asker. Treating their windows as
+  // fresh constraints makes a cumulative dialogue's confluence work grow with
+  // every prior answer and can join the engine's own prose back into a reply.
+  // Recognition and attention still see the full transcript; only this
+  // mechanism's constraint population excludes answered spans.
+  const queryWin = new Map<number, number>();
+  let answered = 0;
+  for (const [off, id] of pre.queryWindows) {
+    while (
+      answered < ctx.answeredSpans.length &&
+      ctx.answeredSpans[answered][1] <= off
+    ) answered++;
+    const span = ctx.answeredSpans[answered];
+    if (span && span[0] <= off && off + W <= span[1]) continue;
+    queryWin.set(off, id);
+  }
   const queryIds = new Set(queryWin.values());
 
   // ── Constraint streams: which query content does each anchor CONTAIN ──
@@ -132,6 +148,17 @@ export async function confluenceJoin(
 
   const streams: Stream[] = [];
   const rankedCapped = ranked.length > pre.k ? ranked.slice(0, pre.k) : ranked;
+  // CONJUNCTIVITY EARLY-EXIT: a conjunctive query's top-ranked anchors
+  // (largest vote weight) must already form at least two independent
+  // constraint streams.  When the first W anchors yield fewer than 2, the
+  // query has at most one topic — no join to compute.  The full pre.k scan
+  // would produce the same null result after reading every anchor's bytes
+  // and computing window identities (profiled at 18K–50K leaf lookups per
+  // refusing query), so cutting the scan short here saves 50–70% of
+  // confluence cost on non-conjunctive queries while preserving every
+  // genuinely conjunctive case (whose top anchors ARE its constraints).
+  const earlyExit = Math.min(rankedCapped.length, ctx.space.maxGroup * 2);
+  let exitAfter = earlyExit;
   for (const cand of rankedCapped) {
     if (streams.some((s) => s.anchor === cand.anchor)) continue;
     const ids = new Set(windowsOfAnchor(cand.anchor).values());
@@ -151,6 +178,8 @@ export async function confluenceJoin(
     if (cover.length > 0 && bindsAConstituent(cover)) {
       streams.push({ anchor: cand.anchor, vote: cand.vote, ids, cover, held });
     }
+    // Early-exit: after 2W anchors, a non-conjunctive query is decided.
+    if (--exitAfter <= 0 && streams.length < 2) return null;
   }
   if (streams.length < 2) return null;
 

package/src/mind/mechanisms/cover.ts

@@ -12,11 +12,12 @@
 import type { MindContext } from "../types.js";
 import type { ComputedResult, Site } from "../graph-search.js";
 import { read, resolve } from "../primitives.js";
-import { guidedFirst } from "../traverse.js";
+import { guidedFirst, hubBound } from "../traverse.js";
 import { conceptHop } from "../match.js";
 import { bridge } from "../resonance.js";
 import { liftAnswer, segRestatesQuery } from "../types.js";
 import { decodeText, unexplainedLabel } from "../rationale.js";
+import { indexOf } from "../../bytes.js";
 import type { RationaleItem } from "../rationale.js";
 import { rItem, rNode, traceDerivation } from "../trace.js";
 import type { PipelineMechanism } from "../pipeline-mechanism.js";
@@ -50,10 +51,31 @@ export async function resolveConcepts(
 export async function resolveConnectors(
   ctx: MindContext,
   sites: ReadonlyArray<Site>,
+  query?: Uint8Array,
 ): Promise<Map<string, Uint8Array>> {
   const links = new Map<string, Uint8Array>();
-  const ordered = [...sites].sort((a, b) => a.start - b.start);
   const answerOf = (n: number) => guidedFirst(ctx, n) ?? n;
+  // A site's continuation already present elsewhere in the query is stale
+  // transcript evidence: cover still needs the site for structural context,
+  // but liftAnswer will trim that continuation as already answered. Building
+  // pairwise/n-ary bridges for it can only create connectors that are later
+  // discarded, and on cumulative dialogue that dominated the whole search.
+  let answered = 0;
+  const ordered = [...sites]
+    .sort((a, b) => a.start - b.start)
+    .filter((s) => {
+      while (
+        answered < ctx.answeredSpans.length &&
+        ctx.answeredSpans[answered][1] <= s.start
+      ) answered++;
+      const span = ctx.answeredSpans[answered];
+      if (span && span[0] <= s.start && s.end <= span[1]) return false;
+      if (query === undefined || ctx.answeredSpans.length === 0) return true;
+      const continuations = ctx.store.nextFirst(s.payload, hubBound(ctx));
+      return !continuations.some((answer) =>
+        indexOf(query, read(ctx, answer), 0) >= 0
+      );
+    });
   const bridgePair = async (l: number, r: number) => {
     if (l === r || links.has(l + "," + r)) return;
     const link = await bridge(ctx, read(ctx, l), read(ctx, r));
@@ -156,7 +178,12 @@ export const coverMechanism: PipelineMechanism = {
 
     if (sites.length === 0 && computed.length === 0) return [];
 
-    const connectors = await resolveConnectors(ctx, sites);
+    const connectors = ctx.meter
+      ? await ctx.meter.time(
+        "cover.resolveConnectors",
+        () => resolveConnectors(ctx, sites, query),
+      )
+      : await resolveConnectors(ctx, sites, query);
     let splits = rec.splits;
     let starts = rec.starts;
     if (computed.length > 0) {
@@ -172,7 +199,12 @@ export const coverMechanism: PipelineMechanism = {
         starts.add(u.j);
       }
     }
-    const concepts = await resolveConcepts(ctx, sites);
+    const concepts = ctx.meter
+      ? await ctx.meter.time(
+        "cover.resolveConcepts",
+        () => resolveConcepts(ctx, sites),
+      )
+      : await resolveConcepts(ctx, sites);
 
     const coverDeps = [
       ctx.trace?.lastIndex("recognise"),

package/src/mind/mechanisms/recall.ts

@@ -316,51 +316,28 @@ export async function recallByResonance(
     // 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.
-    //
-    // MEASURED COST, AND WHY IT STAYS (17.9M vectors / 325K contexts):
-    // this one call is ~570 ms and ~45% of all inference time on a refusing
-    // query.  The cost is entirely `exhaustive` (nprobe = every cluster),
-    // NOT the widened k — timed on that store: k=571 exhaustive 632 ms,
-    // k=24 exhaustive 536 ms, k=571 NON-exhaustive 12 ms.  So narrowing k
-    // buys nothing and the 50x is the whole-index scan itself.
-    // It is load-bearing: over an 18-query battery the bridge produced a
-    // winner 4 times, and ALL FOUR winners came from this proposal channel
-    // — the anchor-climb channel won nothing on its own.  Reordering the
-    // channels (climb first, resonate only on failure) would therefore pay
-    // the climb, fail, and pay this anyway.  Do not weaken it without
-    // re-running that measurement.
-    // Handed to the bridge as a THUNK: this exhaustive whole-index probe is
-    // the most expensive single act on the refusal path, and the bridge's
-    // own cheap gates (query length, the O(|query|) stored-window anchor
-    // scan) can refuse without any proposal at all.  See substitutionBridge.
+    // Reuse recall's already-ranked proposals. Never scan every IVF cluster:
+    // exact co-occurrence and bounded anchor ascent are the bridge's structural
+    // proposal channels, while an exhaustive ANN call made every honest
+    // refusal cost hundreds of milliseconds regardless of k.
     const wideIds = async (): Promise<ReadonlyArray<number>> => {
-      const wide = k >= hubBound(ctx)
-        ? whole
-        : ctx.meter
-        ? await ctx.meter.time(
-          "recall.exhaustiveResonate",
-          () => ctx.store.resonate(queryGist, hubBound(ctx), true),
-        )
-        : await ctx.store.resonate(queryGist, hubBound(ctx), true);
-      return wide.map((h) => h.id);
+      // When the top resonance hit is below the concept threshold, the query
+      // gist has no concept-level match to any stored form — an exhaustive √N
+      // ANN would only score more vectors below the bar (profiled at 38K–40K
+      // annVectorReads per refusing query on a 325K-context store).  The
+      // bridge's structural channels (junction walks, anchor climbs) are the
+      // correct proposal source for a query whose gist has no clean match;
+      // the ANN cannot propose what the gist cannot rank.
+      const marketScale = k * ctx.space.maxGroup;
+      if (corpusN(ctx) <= marketScale ** 3) {
+        const exhaustive = await ctx.store.resonate(
+          queryGist,
+          hubBound(ctx),
+          true,
+        );
+        return exhaustive.map((h) => h.id);
+      }
+      return whole.map((h) => h.id);
     };
     const bridged = await substitutionBridge(ctx, query, wideIds);
     if (bridged !== null) {

package/src/mind/mind.ts

@@ -83,6 +83,10 @@ export interface ConversationState {
    *  is `boundaries[0]`; the second turn starts at that offset, and so
    *  on.  Empty for a single-turn or new conversation. */
   boundaries: number[];
+  /** Byte spans occupied by replies produced by this Mind. Unlike boundary
+   *  parity, this remains exact when a turn receives an empty reply. Optional
+   *  so states saved before the field existed remain restorable. */
+  answeredSpans?: Array<[number, number]>;
 }
 
 /** An active conversation handle.  Opaque — interact through the Mind's
@@ -110,6 +114,7 @@ interface ConversationData {
   tree: Sema;
   bytes: Uint8Array;
   boundaries: number[];
+  answeredSpans: Array<[number, number]>;
   perceiveMemo: Map<string, Sema>;
   recogniseMemo: Map<string, Recognition>;
   climbMemo: Map<string, Map<string, AttentionRead>>;
@@ -128,7 +133,12 @@ import {
   read,
   resolve as resolveImpl,
 } from "./primitives.js";
-import { chooseNext, edgeAncestors as edgeAncestorsFn } from "./traverse.js";
+import {
+  chooseNext,
+  edgeAncestors as edgeAncestorsFn,
+  invalidateStructuralCaches,
+} from "./traverse.js";
+import { invalidateJunctionCache } from "./junction.js";
 import { follow } from "./match.js";
 import { recognise, segment } from "./recognition.js";
 import { meaningOf } from "./resonance.js";
@@ -245,6 +255,7 @@ export class Mind implements MindContext {
 
   /** Memo of the consensus climb — content-keyed.  See {@link MindContext.climbMemo}. */
   climbMemo: Map<string, Map<string, AttentionRead>> | null = null;
+  _structMemoKey: object = {};
 
   /** Memo of recognise() — content-keyed.  See {@link MindContext.recogniseMemo}. */
   recogniseMemo: Map<string, Recognition> | null = null;
@@ -259,6 +270,8 @@ export class Mind implements MindContext {
       { id: number; len: number }
     >
     | null = null;
+  answeredSpans: ReadonlyArray<readonly [number, number]> = [];
+  currentTurnStart = 0;
 
   /** The perceived gist of the query currently being answered.  Set by `think`
    *  before the graph search runs; `chooseNext` consults it as a gate (a null
@@ -466,6 +479,11 @@ export class Mind implements MindContext {
     this.recogniseMemo = conv ? conv.recogniseMemo : new Map();
     this.perceiveMemo = conv ? conv.perceiveMemo : new Map();
     this._resolvedSubtrees = conv ? conv.resolvedSubtrees : null;
+    // Inference is a pure function of cumulative bytes. Conversation
+    // boundaries remain persistence/API metadata and must not select a
+    // different mechanism path than respond() on the identical byte stream.
+    this.answeredSpans = [];
+    this.currentTurnStart = 0;
     this.canon = canon ?? null;
     this.canonMemo = canon ? new Map() : null;
     this._beginMeter();
@@ -514,6 +532,8 @@ export class Mind implements MindContext {
     this.recogniseMemo = null;
     this.perceiveMemo = null;
     this._resolvedSubtrees = null;
+    this.answeredSpans = [];
+    this.currentTurnStart = 0;
     this.canon = null;
     this.canonMemo = null;
     this._edgeGuide = null;
@@ -623,6 +643,15 @@ export class Mind implements MindContext {
     const id = this._nextConvId++;
     const initBytes = state?.context ?? new Uint8Array(0);
     const initBoundaries = state?.boundaries ? [...state.boundaries] : [];
+    const initAnswered = state?.answeredSpans
+      ? state.answeredSpans.map(([start, end]) =>
+        [start, end] as [number, number]
+      )
+      : initBoundaries.flatMap((start, i, cuts) =>
+        i % 2 === 0 && i + 1 < cuts.length
+          ? [[start, cuts[i + 1]] as [number, number]]
+          : []
+      );
     const tree = bytesToTree(
       this.space,
       this.alphabet,
@@ -635,6 +664,7 @@ export class Mind implements MindContext {
       tree,
       bytes: initBytes,
       boundaries: initBoundaries,
+      answeredSpans: initAnswered,
       perceiveMemo: new Map(),
       recogniseMemo: new Map(),
       climbMemo: new Map(),
@@ -657,6 +687,7 @@ export class Mind implements MindContext {
     return {
       context: data.bytes,
       boundaries: [...data.boundaries],
+      answeredSpans: data.answeredSpans.map(([start, end]) => [start, end]),
     };
   }
 
@@ -761,7 +792,11 @@ export class Mind implements MindContext {
       // the cumulative continuous shape multi-turn training deposits, so a
       // later turn can refer to what was ANSWERED ("which of those two…"),
       // not only to what was asked.
-      if (response.bytes.length > 0) this.addTurn(conv, response.bytes);
+      if (response.bytes.length > 0) {
+        const start = data.bytes.length;
+        this.addTurn(conv, response.bytes);
+        data.answeredSpans.push([start, data.bytes.length]);
+      }
 
       return { response, state: this.conversationState(conv)! };
     } finally {
@@ -816,6 +851,8 @@ export class Mind implements MindContext {
     second?: Input,
     onDeposit?: (report: import("./learning.js").DepositReport) => void,
   ): Promise<(Sema & { id: number }) | undefined> {
+    invalidateStructuralCaches(this);
+    invalidateJunctionCache(this);
     return ingest(this, input, second, onDeposit);
   }
 

package/src/mind/pipeline-mechanism.ts

@@ -100,8 +100,8 @@ export class Precomputed {
    *  serves every mechanism that prices commonality — AND the consensus
    *  climb, which is the largest consumer and used to build its own.  The
    *  ONE definition of its lifetime lives in traverse.ts
-   *  ({@link sharedReachMemo}): response-scoped for respond(),
-   *  conversation-scoped across turns, always cold under a trace. */
+   *  ({@link sharedReachMemo}): session-scoped between writes and always cold
+   *  under a trace. */
   private _reach?: Map<number, AncestorReach>;
   get reachMemo(): Map<number, AncestorReach> {
     return this._reach ??= sharedReachMemo(this.ctx);
@@ -232,7 +232,9 @@ function computeWeave(
   // recognising) a corpus-sized deposit: profiled on a 17.7M-node store,
   // uncapped weaves spent 5–8s per query recognising conversation-length
   // anchors that could never form a weave point.
-  const capBytes = query.length * quantum;
+  const askerBytes = query.length -
+    ctx.answeredSpans.reduce((n, [start, end]) => n + end - start, 0);
+  const capBytes = askerBytes * quantum;
   // EXCLUSIVITY IS ARBITRATED BY THE CLIMB'S VOTE ORDER, DELIBERATELY.  A query
   // byte can only be independent evidence for ONE point, so points are built in
   // ranked order and each new point's runs are trimmed against every point
@@ -265,10 +267,90 @@ function computeWeave(
     ctxBytes: Uint8Array;
     raw: GradedRun[];
   }> = [];
+  const querySegments: Array<[number, number]> = [];
+  let segmentStart = 0;
+  for (const [start, end] of ctx.answeredSpans) {
+    if (segmentStart < start) querySegments.push([segmentStart, start]);
+    segmentStart = Math.max(segmentStart, end);
+  }
+  if (segmentStart < query.length) {
+    querySegments.push([segmentStart, query.length]);
+  }
+  const weaveLength = querySegments.reduce((n, [s, e]) => n + e - s, 0);
+  const weaveQuery = new Uint8Array(weaveLength);
+  const weaveMap: Array<{
+    compactStart: number;
+    originalStart: number;
+    length: number;
+  }> = [];
+  let compactStart = 0;
+  for (const [start, end] of querySegments) {
+    weaveQuery.set(query.subarray(start, end), compactStart);
+    weaveMap.push({
+      compactStart,
+      originalStart: start,
+      length: end - start,
+    });
+    compactStart += end - start;
+  }
+  const segmentOf = (start: number, end: number) => {
+    let lo = 0;
+    let hi = weaveMap.length;
+    while (lo < hi) {
+      const mid = (lo + hi) >>> 1;
+      if (weaveMap[mid].originalStart <= start) lo = mid + 1;
+      else hi = mid;
+    }
+    const part = lo > 0 ? weaveMap[lo - 1] : undefined;
+    return part && end <= part.originalStart + part.length ? part : undefined;
+  };
+  const weaveSites = pre.rec.sites.flatMap((s) => {
+    const part = segmentOf(s.start, s.end);
+    return part
+      ? [{
+        ...s,
+        start: part.compactStart + s.start - part.originalStart,
+        end: part.compactStart + s.end - part.originalStart,
+      }]
+      : [];
+  });
   for (const cand of rankedCapped) {
     const ctxBytes = read(ctx, cand.anchor, capBytes + 1);
     if (ctxBytes.length === 0 || ctxBytes.length > capBytes) continue;
-    const raw = alignGraded(ctx, query, ctxBytes, pre.rec.sites);
+    // CAST compares structures stated by the asker. Completed assistant turns
+    // remain available to recognition and the climb as conversation context,
+    // but aligning every candidate across their full prose makes weave work
+    // grow with answer length and lets the engine analogise against its own
+    // previous output. The compact asker stream is aligned once (so candidate
+    // windows are not rebuilt per turn), then every run is split back across
+    // the original turn segments so no evidence crosses an omitted boundary.
+    const raw = alignGraded(ctx, weaveQuery, ctxBytes, weaveSites).flatMap(
+      (r) => {
+        let lo = 0;
+        let hi = weaveMap.length;
+        while (lo < hi) {
+          const mid = (lo + hi) >>> 1;
+          if (weaveMap[mid].compactStart <= r.qs) lo = mid + 1;
+          else hi = mid;
+        }
+        const out: GradedRun[] = [];
+        for (let pi = Math.max(0, lo - 1); pi < weaveMap.length; pi++) {
+          const part = weaveMap[pi];
+          if (part.compactStart >= r.qe) break;
+          const partEnd = part.compactStart + part.length;
+          const start = Math.max(r.qs, part.compactStart);
+          const end = Math.min(r.qe, partEnd);
+          if (start >= end) continue;
+          out.push({
+            ...r,
+            qs: part.originalStart + start - part.compactStart,
+            qe: part.originalStart + end - part.compactStart,
+            cs: r.cs + start - r.qs,
+          });
+        }
+        return out;
+      },
+    );
     if (raw.length === 0) continue;
     for (const r of raw) {
       for (let i = r.qs; i < r.qe; i++) depth[i] += r.weight;

package/src/mind/pipeline.ts

@@ -57,7 +57,7 @@ async function collectComputed(
 // invests in its own precomputation.  CAST's and confluence's floors (2*STEP,
 // 3*STEP) then fail `worthRunning` and are skipped by the SAME admissible-
 // floor pruning every mechanism is already subject to — not by asking
-// "is this an extension?".  Grade TIES keep the earlier candidate, so this
+// "is this an extension?". Grade TIES keep the earlier candidate, so this
 // order is also the tie-break priority: cover, cast, confluence, extraction,
 // recall.
 export const defaultMechanisms: PipelineMechanism[] = [

package/src/mind/reasoning.ts

@@ -74,14 +74,21 @@ export async function reason(
   // grounding can pre-consume one node per recognised site, O(query length));
   // nodes past the cap are still consumed directly, they just skip the
   // synonym expansion.
-  let haloSweeps = 0;
-  for (const id of preConsumed) {
-    consumeNode(id);
-    if (haloSweeps >= ctx.cfg.haloQueryK) continue;
-    const h = ctx.store.halo(id);
-    if (!h) continue;
-    haloSweeps++;
-    for (const sib of await haloSiblings(ctx, id, h)) consumeNode(sib.id);
+  const preconsume = async () => {
+    let haloSweeps = 0;
+    for (const id of preConsumed) {
+      consumeNode(id);
+      if (haloSweeps >= ctx.cfg.haloQueryK) continue;
+      const h = ctx.store.halo(id);
+      if (!h) continue;
+      haloSweeps++;
+      for (const sib of await haloSiblings(ctx, id, h)) consumeNode(sib.id);
+    }
+  };
+  if (ctx.meter) {
+    await ctx.meter.time("reason.preconsumeHalos", preconsume);
+  } else {
+    await preconsume();
   }
 
   let cur = answer;

package/src/mind/recognition.ts

@@ -343,6 +343,46 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
     return singleLeaf[p];
   };
 
+  // ── exact query-edge forms beyond the canonical chain reach ─────────
+  //
+  // At corpus scale off-boundary atom chains are deliberately suppressed,
+  // but a whole trained form can be longer than chainReach(W) and sit at a
+  // query edge without being a subtree of the query's larger root. Appending
+  // another topic demonstrates the failure: the exact 30-byte trained
+  // question `What is the capital of France?` ends inside the larger query's
+  // [27,33) content segment, so neither the structural walk nor a W² chain
+  // can name it.
+  //
+  // Probe only prefix/suffix endpoints within one maximum segment of the
+  // query's own content cuts. The flat-branch lookup is byte-exact and runs
+  // before resolveSpan pays for a fold; approximate evidence never enters.
+  // This tier is needed only where atom chains are suppressed. Small stores
+  // retain their existing decomposition unchanged.
+  if (atomsAreHubs) {
+    const allLeafIds = singleLeaf.map((x) => x?.id ?? null);
+    if (allLeafIds.every((x): x is number => x !== null)) {
+      const radius = ctx.space.seats.length;
+      const endpoints = new Set<number>([0, bytes.length]);
+      for (const cut of startList) {
+        for (
+          let p = Math.max(0, cut - radius);
+          p <= Math.min(bytes.length, cut + radius);
+          p++
+        ) endpoints.add(p);
+      }
+      const ordered = [...endpoints].sort((a, b) => a - b);
+      const probe = (start: number, end: number): void => {
+        if (end - start < W || end - start <= chainReach(W)) return;
+        const ids = allLeafIds.slice(start, end);
+        if (store.findBranch(ids) === null) return;
+        const id = resolveSpan(start, end);
+        if (id !== null) emit(start, end, id);
+      };
+      for (const end of ordered) probe(0, end);
+      for (const start of ordered) probe(start, bytes.length);
+    }
+  }
+
   const chunkEnd = new Uint32Array(bytes.length);
   const sorted = [...starts].sort((a, b) => a - b);
   for (let si = 0; si < sorted.length; si++) {