@hviana/sema 0.2.1 → 0.2.3

package/src/mind/graph-search.ts

@@ -96,6 +96,18 @@ export type GItem =
     cover: boolean;
     rec: boolean;
     node?: number;
+    /** Set only for a {@link ComputedResult} axiom (an extension's derived
+     *  value, e.g. ALU arithmetic) — as opposed to a genuinely RECOGNISED
+     *  learned form.  Both set `rec: true` (a computation bridges the cover
+     *  exactly like a learned terminal answer), but they mean different
+     *  things for `i..j`'s WIDTH: a recognised form's query-span width is
+     *  real evidence of how much of the query's meaning it accounts for
+     *  (liftAnswer's half-dominance framing decision); a computed span's
+     *  width is operand digit-count, uncorrelated with meaning ("1000 - 421"
+     *  is wider than "15 * 7" only because the numbers are bigger, not
+     *  because subtraction is more "the point" of its query).  See
+     *  {@link liftAnswer}. */
+    computed?: boolean;
   };
 type OutItem = Extract<GItem, { kind: "out" }>;
 
@@ -138,6 +150,9 @@ export interface Seg {
   bytes: Uint8Array;
   rec: boolean;
   node?: number;
+  /** See the `computed` field of the "out" {@link GItem} — set only for an
+   *  extension's derived value, never a genuinely recognised learned form. */
+  computed?: boolean;
 }
 
 /** Read the chosen spans back off a derivation: the goal is a chain of bridge
@@ -155,6 +170,7 @@ function readCover(derivation: Derivation<GItem>): Seg[] {
         bytes: out.bytes,
         rec: out.rec,
         node: out.node,
+        computed: out.computed,
       });
     }
     node = node.premises[0];
@@ -356,6 +372,7 @@ export class GraphSearch {
     conceptTarget: ReadonlyMap<number, number>,
     leaves: ReadonlyArray<Leaf>,
     splits: ReadonlySet<number>,
+    starts: ReadonlySet<number>,
     substitutions?: ReadonlyMap<number, Uint8Array>,
     connectors?: ReadonlyMap<string, Uint8Array>,
     computedResults?: ReadonlyArray<ComputedResult>,
@@ -377,6 +394,7 @@ export class GraphSearch {
         sites,
         leaves,
         splits,
+        starts,
       },
       conceptTarget,
       substitutions,
@@ -405,6 +423,7 @@ export class GraphSearch {
       sites: ReadonlyArray<Site>;
       leaves: ReadonlyArray<Leaf>;
       splits: ReadonlySet<number>;
+      starts: ReadonlySet<number>;
     },
     conceptTarget: ReadonlyMap<number, number>,
     substitutions?: ReadonlyMap<number, Uint8Array>,
@@ -418,6 +437,7 @@ export class GraphSearch {
       conceptTarget,
       recognition.leaves,
       recognition.splits,
+      recognition.starts,
       substitutions,
       connectors,
       computedResults,
@@ -448,11 +468,22 @@ export class GraphSearch {
     conceptTarget: ReadonlyMap<number, number>,
     leaves: ReadonlyArray<Leaf>,
     splits: ReadonlySet<number>,
+    starts: ReadonlySet<number>,
     substitutions?: ReadonlyMap<number, Uint8Array>,
     connectors?: ReadonlyMap<string, Uint8Array>,
     computedResults?: ReadonlyArray<ComputedResult>,
   ): DeductionSystem<GItem> {
     const W = this.maxGroup; // fusible span ceiling (shortest composite bound)
+    // Same corpus-scale hub floor {@link atomIsHub}/{@link atomReach} (traverse.ts)
+    // derive for byte atoms — duplicated here rather than imported because this
+    // module is deliberately host-based (no MindContext), and both inputs
+    // (maxGroup, edgeSourceCount) are already in scope with no ctx needed.  If
+    // the formula ever changes, it must change in BOTH places (see canonical.ts's
+    // header for the same write/read-side duplication convention).
+    const atomsAreHubs = Math.max(
+      1,
+      Math.ceil((this.store.edgeSourceCount() * W) / 256),
+    ) > Math.ceil(Math.sqrt(Math.max(2, this.store.edgeSourceCount())));
     const nodeBytes = (n: number) => this.store.bytesPrefix(n, ALL);
     // Content-addressed probes over the store's hash-cons maps — the same keys
     // training filled.  No byte-by-byte trie walk.
@@ -550,6 +581,7 @@ export class GraphSearch {
               cover: true,
               rec: true,
               node: u.node,
+              computed: true,
             },
             cost: STEP,
           };
@@ -588,6 +620,8 @@ export class GraphSearch {
         return this.outRules(it, {
           W,
           splits,
+          starts,
+          atomsAreHubs,
           coversDone,
           outsByStart,
           outsByEnd,
@@ -949,6 +983,8 @@ export class GraphSearch {
     ctx: {
       W: number;
       splits: ReadonlySet<number>;
+      starts: ReadonlySet<number>;
+      atomsAreHubs: boolean;
       coversDone: Set<number>;
       outsByStart: Map<number, OutItem[]>;
       outsByEnd: Map<number, OutItem[]>;
@@ -1095,12 +1131,30 @@ export class GraphSearch {
     r: OutItem,
     ctx: {
       W: number;
+      starts: ReadonlySet<number>;
+      atomsAreHubs: boolean;
       findLeafU: (b: Uint8Array) => number | undefined;
       findBranchU: (k: number[]) => number | undefined;
     },
   ): Iterable<Rule<GItem>> {
     const bytes = concat2(l.bytes, r.bytes);
-    let node = bytes.length <= ctx.W ? ctx.findLeafU(bytes) : undefined;
+    // A PURE leaf-leaf fuse (neither side already a recognised completion)
+    // is opportunistic cross-leaf recovery exactly like recognition.ts's own
+    // canonical chain — findLeaf/findBranch here have no idea WHY these two
+    // leaves are adjacent, only that their concatenation happens to spell a
+    // trained form ("hi" recovered from "W[hi]ch").  The same corpus-scale
+    // caution recognition.ts's `boundary` gate applies: trust it fully when
+    // `l.i` is a position the query's OWN fold chose as a boundary (real
+    // structural evidence); past the scale where atoms themselves stop
+    // discriminating, an interior offset's opportunistic match is noise, not
+    // a genuine cross-leaf recovery.  A completion-involved fuse (l.rec ||
+    // r.rec) is a different, legitimate case — a rewrite growing into its
+    // neighbour — and is exempt, same as recognition.ts's rec-derived sites.
+    const trusted = l.rec || r.rec || ctx.starts.has(l.i) ||
+      !ctx.atomsAreHubs;
+    let node = (trusted && bytes.length <= ctx.W)
+      ? ctx.findLeafU(bytes)
+      : undefined;
     // Whether this pair ACTUALLY forms a 2-child branch — the hard evidence
     // that the fused bytes are a learned form worth keeping alive.  Derived
     // from the same findBranchU probe that sets `node`; when false, the pair
@@ -1108,7 +1162,10 @@ export class GraphSearch {
     // node cannot contribute to any further fusion (findBranch needs two
     // nodes, resolve needs a completion, and findLeaf already had its chance).
     let pairFormsBranch = false;
-    if (node === undefined && l.node !== undefined && r.node !== undefined) {
+    if (
+      trusted && node === undefined && l.node !== undefined &&
+      r.node !== undefined
+    ) {
       node = ctx.findBranchU([l.node, r.node]);
       pairFormsBranch = node !== undefined;
     }

package/src/mind/learning.ts

@@ -9,6 +9,7 @@ import type { Input, MindContext } from "./types.js";
 import { changedNodes } from "./types.js";
 import {
   inputBytes,
+  latin1Key,
   perceive,
   perceiveDeposit,
   resolve,
@@ -119,6 +120,7 @@ export async function deposit(
   ctx: MindContext,
   input: Input,
   track: boolean,
+  conversational = false,
 ): Promise<
   { tree: Sema; rootId: number; ids: Map<Sema, number>; changed: Sema[] }
 > {
@@ -129,8 +131,13 @@ export async function deposit(
   // (no store-probe fallback): a knownPrefixLength scan on every novel fact
   // would cost O(n²) hashing, while conversation replays are always warm —
   // re-deposition replays from the first turn, rebuilding the cache as it
-  // goes.
-  const tree = perceiveDeposit(ctx, bytes);
+  // goes.  `conversational` scopes the STABLE-PREFIX variant (turn-boundary
+  // folding, matching query-time perception) to ingestPair's own growing
+  // context argument — a bare ingestOne deposit whose bytes merely happen
+  // to extend an earlier UNRELATED deposit (no conversational relationship)
+  // must keep the plain fold, or two coincidentally-prefix-sharing facts
+  // would stop sharing structure with each other.
+  const tree = perceiveDeposit(ctx, bytes, conversational);
 
   const ids = new Map<Sema, number>();
   const rootId = await internTreeIds(ctx, tree, ids);
@@ -214,10 +221,20 @@ export async function ingestPair(
   ctxInput: Input,
   cont: Input,
 ): Promise<void> {
-  const c = await deposit(ctx, ctxInput, true);
+  const c = await deposit(ctx, ctxInput, true, true);
   const cont_ = await deposit(ctx, cont, false);
   const ctxId = c.rootId, contId = cont_.rootId;
 
+  // Stamp this turn's continuation onto its own cache entry — the proof a
+  // FUTURE, longer ctxInput needs (see perceiveDeposit) to recognise itself
+  // as this conversation's genuine next turn rather than an unrelated fact
+  // that happens to share this ctxInput's byte prefix.
+  {
+    const ctxBytes = inputBytes(ctx, ctxInput);
+    const entry = ctx._depositTrees.get(latin1Key(ctxBytes));
+    if (entry !== undefined) entry.nextBytes = inputBytes(ctx, cont);
+  }
+
   await ctx.store.link(ctxId, contId);
   await propagateSuffixes(ctx, ctxId, contId);
 

package/src/mind/mechanisms/alu.ts

@@ -16,7 +16,14 @@ import type { PipelineMechanism } from "../pipeline-mechanism.js";
 export function aluToMechanism(alu: Alu): PipelineMechanism {
   return {
     name: "alu",
-    provenance: "cover",
+    // Not a cover derivation: cover.ts composes an answer by walking
+    // recognised query STRUCTURE; the ALU evaluates a recognised expression
+    // to its authoritative result and hands the bytes back untouched. It
+    // shares cover's near-zero floor (computation always wins, masked into
+    // cover's own search — see mechanisms/cover.ts), but the candidate this
+    // produces is not one of cover's derivations, so it carries its own
+    // honest label, the same way extract/cast/recall each carry theirs.
+    provenance: "alu",
     parse: (query) => alu.parse(query),
     async floor(_ctx, _query, pre, _worthRunning) {
       return pre.computed.length > 0 ? 0 : null;

package/src/mind/mechanisms/cast.ts

@@ -102,18 +102,43 @@ export async function counterfactualTransfer(
   query: Uint8Array,
   pre: Precomputed,
 ): Promise<CastResult[]> {
+  // Opened unconditionally, at entry — the same convention recall.ts's
+  // recallByResonance and extraction.ts's extractBySkill use, so every exit
+  // path (five gates below, then the schemas themselves) closes through
+  // ONE scope and inspectRationale never hits a silent dead end.  Only the
+  // first two gates duplicate floor()'s own admissible bound (query length,
+  // ranked anchor count) — required to stay in sync per this function's own
+  // doc comment above, and effectively dead through the ordinary pipeline
+  // (floor() returning null already stops run() from being called at all),
+  // but this function is also exported and callable directly, so they stay
+  // and get the same honest trace as everything past them.
+  const t = ctx.trace?.enter("counterfactual", [rItem(query, "query")]);
+  const fail = (note: string): CastResult[] => {
+    t?.done([], note);
+    return [];
+  };
+
   const quantum = ctx.space.maxGroup;
   if (query.length < 2 * quantum || ctx.store.edgeSourceCount() === 0) {
-    return [];
+    return fail("query below the two-quantum floor, or no edges learnt yet");
   }
   const { roots, ranked } = await pre.attention();
-  if (ranked.length < 2) return [];
+  if (ranked.length < 2) {
+    return fail(
+      `only ${ranked.length} ranked anchor(s) — CAST needs at least two`,
+    );
+  }
 
   const weave = await pre.weave();
   const points = weave.points;
   const depth = weave.depth;
   const aligned = points.length;
-  if (aligned < 2) return [];
+  if (aligned < 2) {
+    return fail(
+      `only ${aligned} structure(s) aligned across the query — CAST needs ` +
+        `at least two to transfer between`,
+    );
+  }
 
   type Point = typeof points[0];
 
@@ -154,18 +179,31 @@ export async function counterfactualTransfer(
   const isRoot = (id: number) => roots.some((r) => r.anchor === id);
   // The weave must touch a COMMITTED point of attention: the dominant
   // structure itself, or another aligned point the climb committed to.
-  if (!points.some((p) => isRoot(p.anchor))) return [];
+  if (!points.some((p) => isRoot(p.anchor))) {
+    t?.done(
+      [
+        ...points.map((p) => rNode(ctx, p.anchor, "aligned")),
+        ...roots.map((r) => rNode(ctx, r.anchor, "committed-root")),
+      ],
+      `${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`,
+    );
+    return [];
+  }
 
   const woven = points.some((p) =>
     p.runs.some((r) =>
       !pre.rec.sites.some((s) => r.qs >= s.start && r.qe <= s.end)
     )
   );
-  if (!woven) return [];
+  if (!woven) {
+    return fail(
+      `every aligned run restates a recognised query site — nothing was ` +
+        `actually WOVEN across structures, so there is nothing to transfer`,
+    );
+  }
 
-  const t = ctx.trace?.enter("counterfactual", [
-    rItem(query, "query"),
-  ]);
   // Each schema tried below RECORDS its candidate (when it fires) rather than
   // returning immediately — every schema that succeeds contributes its own
   // candidate, and the grounding decider's own weight comparison (not CAST's

package/src/mind/mechanisms/cover.ts

@@ -11,6 +11,7 @@
 
 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";
@@ -158,11 +159,18 @@ export const coverMechanism: PipelineMechanism = {
 
     const connectors = await resolveConnectors(ctx, sites);
     let splits = rec.splits;
+    let starts = rec.starts;
     if (computed.length > 0) {
       splits = new Set(rec.splits);
+      starts = new Set(rec.starts);
       for (const u of computed) {
         splits.add(u.i);
         splits.add(u.j);
+        // A computation's own boundaries carry the same fold-level evidence
+        // a chunk boundary does — "computation always wins" (see the header
+        // comment) extends to being trusted ground for cross-leaf recovery.
+        starts.add(u.i);
+        starts.add(u.j);
       }
     }
     const concepts = await resolveConcepts(ctx, sites);
@@ -198,6 +206,7 @@ export const coverMechanism: PipelineMechanism = {
       concepts,
       rec.leaves,
       splits,
+      starts,
       undefined,
       connectors,
       computedResults,
@@ -217,6 +226,43 @@ export const coverMechanism: PipelineMechanism = {
 
     if (segs === null) return [];
 
+    // 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
+    // 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 [];
+      }
+    }
+
     const composed = liftAnswer(segs, query.length);
     if (composed === null) return [];
 

package/src/mind/mechanisms/extraction.ts

@@ -70,43 +70,118 @@ export async function extractBySkill(
   if (ranked.length === 0) {
     return fail("no consensus anchor — no skill to apply");
   }
-  let exemplar: SkillInfo | null = null;
-  let chosenAnchor: number | null = null;
-  let skipped = 0;
-  for (const cand of ranked) {
-    const ex = await pre.spanShapedOf(cand.anchor);
-    if (ex) {
-      exemplar = ex;
-      chosenAnchor = cand.anchor;
-      break;
+
+  // Try ranked anchors IN ORDER until one yields a USABLE extraction — not
+  // merely a span-shaped exemplar, but one whose extracted span clears the
+  // same one-river-fold quantum (W) cover.ts's restatedSpan gate already
+  // treats as the floor below which byte overlap is chance, not evidence.
+  // isSpanShaped (spanShapedOf) is a deliberately permissive sparse-
+  // subsequence check — see the section note below — so it accepts exemplars
+  // whose relation to the query is coincidental gap-matching, not genuine
+  // structure.  Stopping at the FIRST such exemplar let a coincidental match
+  // early in the ranked list win outright and read out a sub-quantum
+  // fragment (observed: a 3-byte "Hel" pulled from an unrelated exemplar,
+  // while a later ranked anchor would have read the query's own "Hello…"
+  // correctly).  Trying further anchors when one produces nothing usable is
+  // the same idiom this loop already uses for non-exemplars — extended to
+  // cover a bad extraction, not just a structural non-match.
+  //
+  // The retry is bounded at pre.k — the SAME evidence-breadth constant every
+  // other consumer of a ranked list already self-limits to (resonance, the
+  // weave, the climb itself; see Precomputed.k's own doc comment) — not the
+  // full ranked list.  locate()'s frame match has an EXACT-byte tier with no
+  // significance correction of its own (short W-byte frames are cheap to
+  // match by pure chance), so trying every ranked anchor turns that per-
+  // anchor chance into a near-certainty over enough attempts: on a pure-
+  // gibberish query, 170 anchors deep found an unrelated Zulu exemplar whose
+  // short frame happened to byte-match, producing "xyzzy pl" — a coincidence
+  // no different in kind from the "RaBitQ estimate overshot the reach bar
+  // and grounded pure gibberish" failure recall.ts's own significance
+  // correction exists to prevent (see recallByResonance's reach-threshold
+  // comment).  Bounding the search to the ranked list's own top-k restores
+  // the "genuinely relevant but not root-significant" exemplars this loop
+  // was built for, without the unbounded tail's chance collisions.
+  const W = ctx.space.maxGroup;
+  const searched = ranked.slice(0, pre.k);
+  let shapeMisses = 0;
+  let subQuantum = 0;
+  for (const cand of searched) {
+    const exemplar = await pre.spanShapedOf(cand.anchor);
+    if (!exemplar) {
+      shapeMisses++;
+      continue;
+    }
+    const built = buildFromExemplar(ctx, query, pre, exemplar);
+    if (built === null || built.bytes.length < W) {
+      subQuantum++;
+      continue;
+    }
+    if (shapeMisses > 0 || subQuantum > 0) {
+      ctx.trace?.step(
+        "trySkillAnchors",
+        [
+          rItem(
+            query.subarray(0, 0),
+            `skipped ${shapeMisses + subQuantum}`,
+          ),
+          rNode(ctx, cand.anchor, "chosen"),
+        ],
+        [],
+        `skipped ${shapeMisses} non-exemplar and ${subQuantum} sub-quantum ` +
+          `anchor(s) before one yielded a usable extraction`,
+      );
     }
-    skipped++;
+    t?.done(
+      [rItem(built.bytes, "extracted")],
+      built.pieces === 1
+        ? `apply a learnt extraction skill — read the analogous span of the query` +
+          ` framed like "${
+            decodeText(exemplar.answerBytes)
+          }" sits in its exemplar`
+        : `apply a learnt MULTI-PIECE skill — read ${built.pieces} analogous` +
+          ` pieces of the query and synthesize them like "${
+            decodeText(exemplar.answerBytes)
+          }"`,
+    );
+    return {
+      bytes: built.bytes,
+      accounted: built.accounted,
+      unexplained: unexplainedLabel(query, built.accounted),
+    };
   }
-  if (exemplar === null) {
+  if (shapeMisses === searched.length) {
     ctx.trace?.step(
       "trySkillAnchors",
       [],
       [],
-      `none of ${ranked.length} ranked anchor(s) is a span-shaped skill exemplar`,
+      `none of the top ${searched.length} ranked anchor(s) (of ${ranked.length} total) ` +
+        `is a span-shaped skill exemplar`,
     );
     return fail("no consensus root is a span-shaped skill exemplar");
   }
-  if (skipped > 0) {
-    ctx.trace?.step(
-      "trySkillAnchors",
-      [
-        rItem(query.subarray(0, 0), `skipped ${skipped}`),
-        rNode(ctx, chosenAnchor!, "chosen"),
-      ],
-      [],
-      `skipped ${skipped} anchor(s) that are not skill exemplars`,
-    );
-  }
+  return fail(
+    "no ranked anchor yielded an extraction at or above the quantum floor",
+  );
+}
+
+/** Build the extracted bytes for ONE already-accepted span-shaped exemplar —
+ *  factored out of {@link extractBySkill} so its anchor loop can try
+ *  successive ranked candidates instead of committing to the first
+ *  structural match.  Null when the exemplar's answer does not decompose
+ *  against its context, or no piece's frame locates in the query. */
+function buildFromExemplar(
+  ctx: MindContext,
+  query: Uint8Array,
+  pre: Precomputed,
+  exemplar: SkillInfo,
+):
+  | { bytes: Uint8Array; accounted: Array<[number, number]>; pieces: number }
+  | null {
   const { contextBytes, answerBytes } = exemplar;
 
   const ansCtxRuns = answerRunsInContext(ctx, contextBytes, answerBytes);
   if (ansCtxRuns === null || ansCtxRuns.length === 0) {
-    return fail("answer is not a subsequence of the context");
+    return null;
   }
 
   if (ansCtxRuns.length > 1) {
@@ -200,25 +275,11 @@ export async function extractBySkill(
     if (preBounded && postBounded) accounted.push([start, end]);
   }
   if (pieces.length === 0) {
-    return fail("no answer piece's frame located in the query");
+    return null;
   }
 
   const out = pieces.length === 1 ? pieces[0] : concatBytes(pieces);
-  t?.done(
-    [rItem(out, "extracted")],
-    pieces.length === 1
-      ? `apply a learnt extraction skill — read the analogous span of the query` +
-        ` framed like "${decodeText(answerBytes)}" sits in its exemplar`
-      : `apply a learnt MULTI-PIECE skill — read ${pieces.length} analogous` +
-        ` pieces of the query and synthesize them like "${
-          decodeText(answerBytes)
-        }"`,
-  );
-  return {
-    bytes: out,
-    accounted,
-    unexplained: unexplainedLabel(query, accounted),
-  };
+  return { bytes: out, accounted, pieces: pieces.length };
 }
 
 // ── The two span-shape readings: OPEN acceptance vs. STRONG decomposition ──

package/src/mind/mechanisms/recall.ts

@@ -113,10 +113,38 @@ export async function recallByResonance(
       maximal.push(s);
       maxEnd = s.end;
     }
-    if (maximal.length === 1) {
+    // The wrapper must actually BE scaffolding: RC8's own premise is "the
+    // wrapper is scaffolding; the argument is the span that leads
+    // somewhere" ("How do you say 'thank you' in French?" — everything
+    // outside the argument is a small fixed template).  When the query
+    // instead has ANOTHER substantial recognised form (≥ W2, the same
+    // constituent bar the argument itself must clear) sitting OUTSIDE the
+    // chosen argument, the query is not one argument in a wrapper — it is
+    // several complete, independently-meaningful pieces (a multi-turn
+    // conversation's own accumulated turns are exactly this shape), and
+    // binding to the argument's continuation would answer past content
+    // the query itself already carries forward.  Derived from the same W2
+    // bar the argument itself is held to, never a separate tuned number.
+    const hasSubstantialOutside = maximal.length === 1 &&
+      pre.rec.sites.some((s) =>
+        s.end - s.start >= W2 &&
+        (s.end <= maximal[0].start || s.start >= maximal[0].end)
+      );
+    if (maximal.length === 1 && !hasSubstantialOutside) {
       const arg = maximal[0];
       const g = await follow(ctx, arg.payload, queryGist);
-      if (g !== null && g.length > 0) {
+      // The same "no restated fragment" guard tier 2 applies below (§ "the
+      // anchor cleared the consensus floor..."): a followed continuation
+      // that is itself a proper byte-subspan of the QUERY restates part of
+      // the question — never an answer.  A multi-turn query's own later
+      // turns are exact, content-addressed matches for exactly this reason
+      // (each turn is its own previously-learnt form), so without this
+      // guard the argument's OWN later restatement in the same
+      // conversation reads as if it were the next thing to say.
+      if (
+        g !== null && g.length > 0 &&
+        !(g.length < query.length && indexOf(query, g, 0) >= 0)
+      ) {
         return ground(
           g,
           "argument binding — the query's sole edge-source constituent, continuation followed",