@hviana/sema 0.1.7 → 0.1.9

package/example/train_base.ts

@@ -177,8 +177,11 @@ const LOCAL_PATH = env("LOCAL_PATH", ""); // train from a local dir of *.zip
 const CACHE_DIR = env("CACHE_DIR", join(process.cwd(), "cache"));
 const MAX_CACHE_BYTES = Number(env("MAX_CACHE_GB", "100")) * 1e9;
 const PROGRESS_MS = Number(env("PROGRESS_MS", "250")); // panel refresh cadence
-// Index maintenance at checkpoints: compact (remove garbage) then repair (fill
-// gaps). Both are idempotent batch operations; INDEX_MAINTENANCE=0 disables.
+// Index maintenance at checkpoints: compact (remove garbage), repair (fill
+// gaps), then refresh the canonical-form index (equivalence-class resolution —
+// src/canon.ts). All three are idempotent batch operations (the canon build is
+// additionally incremental via the store's `canon.upto` cursor);
+// INDEX_MAINTENANCE=0 disables.
 const INDEX_MAINTENANCE = env("INDEX_MAINTENANCE", "1") !== "0";
 const DOWNLOAD_TRIES = 5;
 // In-progress downloads are written to a sibling "<dest>.part" and atomically
@@ -1823,8 +1826,9 @@ async function main(): Promise<void> {
 
   const checkpoint = () => mind.save();
 
-  /** Run index maintenance: compact (remove garbage) then repair (fill gaps).
-   *  Both are idempotent — running twice produces the same result as once.
+  /** Run index maintenance: compact (remove garbage), repair (fill gaps),
+   *  then refresh the canonical-form index (see below).  All three are
+   *  idempotent — running twice produces the same result as once.
    *  Compaction frees index space first; repair then adds back every
    *  edge/halo-bearing node whose gist was evicted from the pending cache
    *  before it reached the content index, completing the coverage that
@@ -1877,6 +1881,27 @@ async function main(): Promise<void> {
         }`,
       );
     }
+    // Canonical-form index (src/canon.ts): lets resolution find stored forms
+    // across surface variation (case, width, whitespace).  Incremental and
+    // idempotent by construction — the `canon.upto` meta cursor scans only
+    // nodes newer than the last pass, and the (h, id) primary key ignores
+    // re-inserted rows — so it composes with the resume model exactly like
+    // compact/repair: every checkpoint (and finish) leaves the index
+    // covering all content trained so far.
+    try {
+      const added = await mind.buildCanonIndex();
+      if (added > 0) {
+        progress.log(
+          `  ${GRN}canon index: added ${int(added)} canonical-form entries${R}`,
+        );
+      }
+    } catch (err) {
+      progress.log(
+        `  ${YEL}⚠ canon index build failed${R}: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
   };
 
   // The checkpoint recall is a best-effort diagnostic. It is time-bounded so a

package/package.json

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

package/src/alu/src/parser.ts

@@ -172,10 +172,27 @@ export class QueryParser {
       j,
       bytes: this.evalRun(query.subarray(i, j)),
     }));
-    const spans: ComputedSpan[] = runs.filter(
-      (r): r is ComputedSpan => r.bytes !== null,
-    );
-    let stream = compose(tokens, runs);
+    // BRACKETED runs — "(3 + 4) * (10 - 2)" — extend across grouping
+    // notation the flat alternation cannot cross.  The expression grammar
+    // (expr.ts) already nests and parenthesizes; this only hands it the
+    // WHOLE bracketed span instead of the fragments between brackets.  A
+    // bracketed run that evaluates ABSORBS the flat runs inside it (the
+    // authority law: contained spans are its material); one that does not
+    // evaluate leaves the flat readings untouched.
+    const bracketed = this.bracketedRuns(query, tokens)
+      .map(([i, j]) => ({ i, j, bytes: this.evalRun(query.subarray(i, j)) }))
+      .filter((r): r is ComputedSpan => r.bytes !== null);
+    const absorbed = (r: { i: number; j: number }) =>
+      bracketed.some((b) => b.i <= r.i && r.j <= b.j);
+    const composedRuns = [
+      ...runs.filter((r) => !absorbed(r)),
+      ...bracketed,
+    ].sort((a, b) => a.i - b.i);
+    const spans: ComputedSpan[] = [
+      ...runs.filter((r): r is ComputedSpan => r.bytes !== null),
+      ...bracketed,
+    ];
+    let stream = compose(tokens, composedRuns);
     const readings = new Map<Token, readonly string[]>();
     for (;;) {
       const fired = await this.operations(query, stream, readings);
@@ -302,6 +319,90 @@ export class QueryParser {
     return runs;
   }
 
+  /** The maximal BRACKETED arithmetic runs: like {@link arithmeticRuns} but
+   *  grouping brackets participate — an all-'(' term opens depth where an
+   *  operand is expected, a term beginning with ')' closes it where an
+   *  operator could follow (only its bracket prefix joins the run; anything
+   *  after — a trailing "?" — ends it).  A run is recorded only when it is
+   *  BALANCED, actually crossed a bracket, and contains an operator — the
+   *  bracket-free case is {@link arithmeticRuns}' own.  Evaluation is the
+   *  same registry-derived grammar, whose lexer already reads the brackets. */
+  private bracketedRuns(
+    query: Uint8Array,
+    tokens: Token[],
+  ): Array<[number, number]> {
+    const OPEN = 0x28, CLOSE = 0x29;
+    const bracketPrefix = (t: Token, b: number): number => {
+      if (t.kind !== "term") return 0;
+      let n = 0;
+      while (t.i + n < t.j && query[t.i + n] === b) n++;
+      return n;
+    };
+    const allOf = (t: Token, b: number): boolean =>
+      bracketPrefix(t, b) === t.j - t.i;
+    const bridged = (from: number, to: number): boolean =>
+      from >= to || this.host.segment(query.subarray(from, to)).length <= 1;
+    const runs: Array<[number, number]> = [];
+    let k = 0;
+    while (k < tokens.length) {
+      const first = tokens[k];
+      if (first.kind !== "operand" && !allOf(first, OPEN)) {
+        k++;
+        continue;
+      }
+      let depth = 0;
+      let ops = 0;
+      let brackets = 0;
+      let expectOperand = true;
+      let end = -1; // byte end of the last VALID run state (balanced, after operand/close)
+      let endTok = k; // token index just past the accepted prefix
+      let m = k;
+      let prevJ = -1;
+      while (m < tokens.length) {
+        const t = tokens[m];
+        if (prevJ >= 0 && !bridged(prevJ, t.i)) break;
+        if (expectOperand) {
+          if (allOf(t, OPEN)) {
+            depth += t.j - t.i;
+            brackets++;
+          } else if (t.kind === "operand") {
+            expectOperand = false;
+            if (depth === 0) {
+              end = t.j;
+              endTok = m + 1;
+            }
+          } else break;
+        } else {
+          const c = bracketPrefix(t, CLOSE);
+          if (c > 0 && depth > 0) {
+            const take = Math.min(c, depth);
+            depth -= take;
+            brackets++;
+            if (depth === 0) {
+              end = t.i + take;
+              endTok = m + 1;
+            }
+            // A term with content beyond its usable bracket prefix ("?")
+            // ends the run inside the term.
+            if (take < t.j - t.i) break;
+          } else if (t.kind === "operator") {
+            expectOperand = true;
+            ops++;
+          } else break;
+        }
+        prevJ = t.j;
+        m++;
+      }
+      if (end >= 0 && ops > 0 && brackets > 0) {
+        runs.push([first.i, end]);
+        k = endTok;
+      } else {
+        k++;
+      }
+    }
+    return runs;
+  }
+
   /** Evaluate an infix-arithmetic run to its canonical result bytes, through
    *  the kernel's recursive expression evaluator, or null if it does not
    *  evaluate.  A whole result stays an exact int; otherwise the canonical

package/src/canon.ts

@@ -0,0 +1,65 @@
+// canon.ts — content canonicalization for equivalence-class resolution.
+//
+// The store is content-addressed on RAW bytes: "What", "WHAT" and "what" are
+// three different hashes, so a query whose surface form varies from the
+// trained form resolves to nothing even though the CONTENT is the same.  A
+// CANONICALIZER maps every surface variant of the same content onto one
+// canonical byte string; the store keeps a small hash index from canonical
+// keys to node ids (see Store.canonAdd/canonFind), and resolution falls back
+// to that index when the exact content-addressed lookup misses.
+//
+// The canonicalizer is MODALITY-SPECIFIC and always INJECTED — nothing in the
+// store or the mind's core knows what "case" or "whitespace" is.  The text
+// canonicalizer below is the one `respondText`/`respondTurnText` pass down;
+// a grid or audio modality would supply its own (or none).
+//
+// Canonical keys are equivalence-class LABELS, never content: they are hashed
+// and verified (canon(stored bytes) must equal canon(query bytes) before an
+// id is accepted), so a hash collision costs a read, never a wrong id — the
+// same discipline as the node table's own `h` index.
+
+/** A content canonicalizer: maps a byte span to the canonical representative
+ *  of its equivalence class.  Must be pure and deterministic.  Returning the
+ *  input unchanged is always sound (the class is then {input}). */
+export type Canon = (bytes: Uint8Array) => Uint8Array;
+
+const dec = new TextDecoder("utf-8", { fatal: false });
+const enc = new TextEncoder();
+
+/** The TEXT canonicalizer: Unicode-aware equivalence over every character
+ *  variation that does not change what the text SAYS —
+ *
+ *   • compatibility normalization (NFKC): full-width forms, ligatures,
+ *     composed vs decomposed accents collapse to one representation;
+ *   • case folding (locale-independent lowercase after NFKC — the standard
+ *     simple fold);
+ *   • whitespace: every INTERIOR run of Unicode whitespace becomes one plain
+ *     space.  EDGE whitespace is preserved verbatim: a span's leading or
+ *     trailing separator belongs BETWEEN forms, not to the form — trimming
+ *     it would let a recognised span swallow the boundary byte that
+ *     separates it from its neighbour (observed: "ice fire" composing to
+ *     "coldhot" because the span "ice " matched the stored "ice").
+ *
+ *  "WHAT  IS", "What is" and "ｗｈａｔ is" share one canonical form.  This is
+ *  deliberately conservative: punctuation, digits and word order are content
+ *  and pass through untouched. */
+export function textCanon(bytes: Uint8Array): Uint8Array {
+  const s = dec
+    .decode(bytes)
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/(\S)\s+(?=\S)/g, "$1 ");
+  return enc.encode(s);
+}
+
+/** 32-bit FNV-1a over a canonical key — the integer the store's canon index
+ *  is keyed on.  Same construction as the node table's content hash; a
+ *  collision is resolved by verifying canon(stored) === key, never trusted. */
+export function canonHash(key: Uint8Array): number {
+  let h = 0x811c9dc5 >>> 0;
+  for (let i = 0; i < key.length; i++) {
+    h ^= key[i];
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h >>> 0;
+}

package/src/geometry.ts

@@ -189,8 +189,13 @@ export interface Grid {
 /** Fold `items[start .. start+count)` in groups of `mg` into `out`.
  *
  *  With `force`, the trailing incomplete group (2..mg-1 items) is folded as
- *  well — only a lone singleton passes through — guaranteeing progress when
- *  the caller detected a stall. */
+ *  well — only a lone singleton passes through.  The river always folds with
+ *  force: every level contracts by ~mg, so the tree's DEPTH is a function of
+ *  ceil(log_mg(n)) alone.  Letting leftovers pass through unfolded made depth
+ *  depend on the exact byte count (39 bytes folded in 3 levels, 41 in 4), and
+ *  each extra level applies another seat permutation to the whole gist —
+ *  near-identical inputs straddling such a cliff read as orthogonal
+ *  (measured: 33-byte-identical prefixes at cos ≈ 0). */
 function foldSlice(
   space: Space,
   items: Folded[],
@@ -251,19 +256,12 @@ function riverFold(space: Space, row: Folded[], stableBytes: number): Folded {
     const next: Folded[] = [];
     if (boundary < level.length) {
       // Prefix folds independently of the suffix — structural stability.
-      foldSlice(space, level, 0, boundary, next, false);
-      foldSlice(space, level, boundary, level.length - boundary, next, false);
+      foldSlice(space, level, 0, boundary, next, true);
+      foldSlice(space, level, boundary, level.length - boundary, next, true);
     } else {
-      foldSlice(space, level, 0, level.length, next, false);
-    }
-    if (next.length === level.length) {
-      // Stuck — every group was incomplete.  Force-fold to break the stall.
-      const forced: Folded[] = [];
-      foldSlice(space, next, 0, next.length, forced, true);
-      level = forced;
-    } else {
-      level = next;
+      foldSlice(space, level, 0, level.length, next, true);
     }
+    level = next;
   }
   // LINEAR fold — this root normalize is the ONLY normalize of the entire
   // fold; every intermediate gist stays unnormalized (see the folding
@@ -413,14 +411,8 @@ function riverFoldRaw(space: Space, row: Folded[]): Folded {
   let level = row;
   while (level.length > 1) {
     const next: Folded[] = [];
-    foldSlice(space, level, 0, level.length, next, false);
-    if (next.length === level.length) {
-      const forced: Folded[] = [];
-      foldSlice(space, next, 0, next.length, forced, true);
-      level = forced;
-    } else {
-      level = next;
-    }
+    foldSlice(space, level, 0, level.length, next, true);
+    level = next;
   }
   return level[0];
 }
@@ -460,6 +452,18 @@ export function bytesToTreePyramid(
       pyramid: { levels: [], bytes: 0 },
     };
   }
+  // ZERO GROWTH: the previous pyramid already covers every byte — its top
+  // level holds the finished, normalized root.  Refolding here would not
+  // only waste the work: when the whole span is one full block, the refold's
+  // top item is a REUSED raw interior of `prev`, and the final normalize
+  // below would mutate that shared raw block in place, corrupting every
+  // later incremental fold built on `prev`.
+  if (prev && prev.bytes === bytes.length && prev.levels.length > 0) {
+    return {
+      tree: prev.levels[prev.levels.length - 1][0].tree,
+      pyramid: prev,
+    };
+  }
   const mg = space.maxGroup;
   const reusable = (L: number): ReadonlyArray<Folded> | null => {
     // prev's TOPMOST level holds its normalized ROOT — reusable blocks must
@@ -497,16 +501,8 @@ export function bytesToTreePyramid(
       reused * mg,
       level.length - reused * mg,
       next,
-      false,
+      true,
     );
-    if (next.length === level.length) {
-      // Stuck — same force-fold as riverFold (reuse cannot cause it: any
-      // reused block replaces a whole folded group, so reused > 0 implies
-      // progress).
-      const forced: Folded[] = [];
-      foldSlice(space, next, 0, next.length, forced, true);
-      next = forced;
-    }
     levels.push(next);
     level = next;
     L++;

package/src/index.ts

@@ -12,6 +12,7 @@ export * from "./mind/index.js";
 export * from "./store-sqlite.js";
 export * from "./config.js";
 export * from "./extension.js";
+export * from "./canon.js";
 export * from "./ingest-cache.js";
 // rabitq-ivf: the partitioned (IVF) vector index over 1-bit RaBitQ codes.
 export {

package/src/mind/learning.ts

@@ -7,7 +7,12 @@ import { Vec } from "../vec.js";
 import { bindSeat, companySignature, isChunk, Sema } from "../sema.js";
 import type { Input, MindContext } from "./types.js";
 import { changedNodes } from "./types.js";
-import { inputBytes, perceive, perceiveDeposit } from "./primitives.js";
+import {
+  inputBytes,
+  perceive,
+  perceiveDeposit,
+  resolve,
+} from "./primitives.js";
 import { canonicalWindows, leafIdPrefix } from "./canonical.js";
 import { fold as foldVecs } from "../sema.js";
 
@@ -171,6 +176,38 @@ export async function ingestOne(
   return Object.assign(tree, { id: rootId });
 }
 
+/** For each right-edge suffix of the context bytes, resolve it against the
+ *  store.  A suffix whose resolved node is already a known form inherits the
+ *  continuation edge.  Gate: ≥ 2 structural parents (reused across deposits),
+ *  or (halo > 0 ∧ already an edge source).  Pure answers do not qualify. */
+async function propagateSuffixes(
+  ctx: MindContext,
+  src: number,
+  dst: number,
+): Promise<void> {
+  const W = ctx.space.maxGroup;
+  const bytes = ctx.store.bytes(src);
+  const n = bytes.length;
+  if (n < 2 * W) return;
+  // Existence prefilter — the write side of the canonical contract: every
+  // deposit interns its WHOLE byte stream as a flat branch of per-byte leaf
+  // ids (deposit(), canonical.ts).  A suffix is a stored form exactly when
+  // that flat twin exists, so one content-hash probe per offset decides;
+  // only a hit pays for resolve()'s deposit-shaped perception.  This keeps
+  // the scan free of river folds — O(1) probes over cheap byte hashes
+  // instead of O(suffix) vector folds per offset.
+  const leafIds = leafIdPrefix(ctx, bytes);
+  for (let i = 1; i <= n - W; i++) {
+    if (ctx.store.findBranch(leafIds.slice(i)) === null) continue;
+    const id = resolve(ctx, bytes.subarray(i));
+    if (id === null || id === src) continue;
+    const known = ctx.store.parentsFirst(id, 2).length >= 2 ||
+      (ctx.store.haloMass(id) > 0 && ctx.store.hasNext(id));
+    if (!known) continue;
+    await ctx.store.link(id, dst);
+  }
+}
+
 /** Ingest a pair (context, continuation) — learn an edge and pour halos. */
 export async function ingestPair(
   ctx: MindContext,
@@ -182,6 +219,7 @@ export async function ingestPair(
   const ctxId = c.rootId, contId = cont_.rootId;
 
   await ctx.store.link(ctxId, contId);
+  await propagateSuffixes(ctx, ctxId, contId);
 
   // Halos pour company SIGNATURES (identity), not gists (content) — see
   // companySignature in sema.ts.

package/src/mind/match.ts

@@ -446,8 +446,10 @@ export async function follow(
  *  `guide` the context whose gist resonates with the query wins (seat
  *  symmetry) — without one, the most-corroborated context wins (poured halo
  *  MASS, the direct measure of how many episodes established it), falling
- *  back to first-learnt on equal mass.  Callers that HAVE a query gist must
- *  pass it, or they silently change disambiguation regime.
+ *  back to first-learnt on equal mass.  Among many predecessors RECIPROCAL
+ *  ones (mutual edges) are preferred when any exist (RC5).  Callers that
+ *  HAVE a query gist must pass it, or they silently change disambiguation
+ *  regime.
  *
  *  `rev`, when the caller has already materialised prevOf (one read per
  *  relation — a hub's reverse fan-in is corpus-sized), is reused instead of
@@ -466,11 +468,32 @@ export function reverseContext(
   // keeps the single-predecessor shortcut exact.
   const candidates = rev ?? ctx.store.prevFirst(id, hubBound(ctx));
   if (candidates.length === 0) return null;
-  const pick = candidates.length === 1
-    ? candidates[0]
+  // RECIPROCAL PREFERENCE: among many predecessors, one that `id` also
+  // continues TO (cand → id AND id → cand both learnt) is a mutually
+  // established pairing — the strongest structural evidence a predecessor
+  // can carry (bidirectional training deposits both directions of a genuine
+  // pair).  A bare predecessor is one episode's adjacency; guide-resonance
+  // over bare predecessors favours whichever stored document merely
+  // CONTAINS the query's bytes (the linear fold's cosine is byte overlap —
+  // the observed "merci → unrelated French document" failure).  One capped
+  // forward read decides; when no reciprocal exists, behaviour is unchanged
+  // — bare predecessors ARE the honest answer for a shared deposited
+  // continuation (two questions → one answer; audited by 31-audit C1), and
+  // this arm serves every mechanism's reverse projection, so abstaining
+  // here starves far more than the one containment failure it would fix.
+  let pool: readonly number[] = candidates;
+  if (candidates.length > 1) {
+    const fwd = new Set(ctx.store.nextFirst(id, hubBound(ctx)));
+    if (fwd.size > 0) {
+      const mutual = candidates.filter((c) => fwd.has(c));
+      if (mutual.length > 0) pool = mutual;
+    }
+  }
+  const pick = pool.length === 1
+    ? pool[0]
     : guide
-    ? chooseAmong(ctx, candidates, guide).id
-    : pickByMass(ctx, candidates);
+    ? chooseAmong(ctx, pool, guide).id
+    : pickByMass(ctx, pool);
   const g = read(ctx, pick);
   return g.length > 0 ? g : null;
 }

package/src/mind/mechanisms/cast.ts

@@ -345,14 +345,34 @@ export async function counterfactualTransfer(
   // corrupted-store read now falls back here instead of voicing a hollow
   // seat into the comparison — the same "empty bytes are no grounding"
   // invariant project() has always enforced.
-  const seatOfNode = (id: number, fallback: Uint8Array): Uint8Array =>
-    reverseContext(ctx, id, qv) ?? fallback;
-  const seatOf = (p: Point): Uint8Array => seatOfNode(p.anchor, p.ctx);
+  // A node that only ever CONTINUES — an edge SOURCE with no predecessor —
+  // is a learnt CONTEXT (a stored question-shaped frame), not an entity.
+  // Voicing it verbatim answers a question with a question (the observed
+  // cast echo: two stored questions concatenated as an "answer").  The
+  // context's role is established by what it LEADS TO, so its seat is its
+  // own continuation — the fact — with the reverse projection and the raw
+  // bytes as the ordinary fallbacks for genuine entities.
+  const seatOfNode = async (
+    id: number,
+    fallback: Uint8Array,
+  ): Promise<Uint8Array> => {
+    if (ctx.store.prevCount(id) === 0 && ctx.store.hasNext(id)) {
+      const fwd = await follow(ctx, id, qv);
+      if (fwd !== null) return fwd;
+    }
+    return reverseContext(ctx, id, qv) ?? fallback;
+  };
+  const seatOf = (p: Point): Promise<Uint8Array> => seatOfNode(p.anchor, p.ctx);
   interface AnalogCandidate {
     anchor: number;
     /** The point this candidate came from, or null when it is a nextOf
      *  descendant — then seatOfNode supplies the seat. */
     point: Point | null;
+    /** For a nextOf descendant: the aligned point whose continuation edge
+     *  named it.  Its runs ARE the query evidence this analog rests on
+     *  (the hop was reached THROUGH that alignment), so the comparison
+     *  schema accounts them. */
+    src: Point;
   }
   const analogs: AnalogCandidate[] = [];
   for (const p of points) {
@@ -365,7 +385,7 @@ export async function counterfactualTransfer(
       indexOf(p.ctx, dominant.ctx, 0) < 0 &&
       indexOf(query, p.ctx, 0) < 0
     ) {
-      analogs.push({ anchor: p.anchor, point: p });
+      analogs.push({ anchor: p.anchor, point: p, src: p });
     }
     // Reach through to the point's continuation targets regardless
     // of the point's own context length: when the point is a leaf
@@ -384,7 +404,7 @@ export async function counterfactualTransfer(
         indexOf(nctx, dominant.ctx, 0) >= 0 ||
         indexOf(query, nctx, 0) >= 0
       ) continue;
-      analogs.push({ anchor: nid, point: null });
+      analogs.push({ anchor: nid, point: null, src: p });
     }
   }
   let bestAnalog: AnalogCandidate | null = null;
@@ -494,10 +514,10 @@ export async function counterfactualTransfer(
       [],
       "the two structures keep distributional company beyond chance — genuine analogs",
     );
-    const a = seatOf(dominant);
+    const a = await seatOf(dominant);
     const b = bestAnalog.point !== null
-      ? seatOf(bestAnalog.point)
-      : seatOfNode(bestAnalog.anchor, read(ctx, bestAnalog.anchor));
+      ? await seatOf(bestAnalog.point)
+      : await seatOfNode(bestAnalog.anchor, read(ctx, bestAnalog.anchor));
     const answer = await joinWithBridge(ctx, a, b);
     record(
       answer,
@@ -506,13 +526,13 @@ export async function counterfactualTransfer(
       // A halo-mediated act (the analogy gate) plus two seat projections.
       CONCEPT + STEP + STEP,
       // What comparison READ: the dominant's own aligned runs, plus the
-      // analog's aligned runs when it was itself an aligned point (a nextOf
-      // descendant was never aligned to the query directly, so it
-      // contributes no accounted span — its seat is graph-reached, not
-      // query-matched).
+      // aligned runs of the point that named the analog — the analog itself
+      // when it was an aligned point, else the source point whose
+      // continuation edge reached it (that alignment IS the query evidence
+      // the hop rests on).
       [
         ...runSpans(dominant),
-        ...(bestAnalog.point !== null ? runSpans(bestAnalog.point) : []),
+        ...runSpans(bestAnalog.point ?? bestAnalog.src),
       ],
     );
   }

package/src/mind/mechanisms/confluence.ts

@@ -116,6 +116,20 @@ export async function confluenceJoin(
      *  recognised common form). */
     held: Array<[number, number]>;
   }
+  // A constraint must bind a CONSTITUENT, not a shard.  A genuinely shared
+  // form weaves a contiguous RUN of shared discriminative windows — its
+  // merged cover span is the form's own length, beyond one perception
+  // quantum (2W: the same "two quanta of structure" bar the conjunctive
+  // precondition `query.length < 2W` and CAST's weave live under).  A long
+  // stored document holds thousands of W-windows and will hold a FEW of any
+  // query's by accident, but accidental sharing is one window (a merged
+  // span of W, at most ~W+overlap bytes: "ow ma", "ys a", "ías " —
+  // observed), never a run ("​ translucent", " featherlight" — the genuine
+  // constraints).  Shard-bound streams are no constraints, and their meets
+  // are connective debris (". Sure,", "ngul" — observed).
+  const bindsAConstituent = (cover: Array<[number, number]>): boolean =>
+    cover.some(([cs, ce]) => ce - cs >= 2 * W);
+
   const streams: Stream[] = [];
   const rankedCapped = ranked.length > pre.k ? ranked.slice(0, pre.k) : ranked;
   for (const cand of rankedCapped) {
@@ -134,7 +148,7 @@ export async function confluenceJoin(
       if (curC !== null && off <= curC[1]) curC[1] = off + W;
       else cover.push(curC = [off, off + W]);
     }
-    if (cover.length > 0) {
+    if (cover.length > 0 && bindsAConstituent(cover)) {
       streams.push({ anchor: cand.anchor, vote: cand.vote, ids, cover, held });
     }
   }