@hviana/sema 0.8.2 → 0.8.5

package/src/mind/graph-search.ts

@@ -177,6 +177,30 @@ export interface Seg {
 /** Read the chosen spans back off a derivation: the goal is a chain of bridge
  *  steps, each whose second premise is the `out` it crossed.  Walk the chain to
  *  the axiom and reverse into left-to-right order. */
+/** The BYTE TERM of a derivation's cost: how many bytes its bridge rule charged
+ *  at PASS each — read back off the rule that charged them (`bridgeRule`:
+ *  `o.rec ? MICRO : PASS * (o.j - o.i)`), so the split exists in ONE place and
+ *  the engine's generic accumulator is left alone.
+ *
+ *  `derivation.cost - PASS * readBridgedBytes(derivation)` is therefore the
+ *  derivation's DISCRETE work — the number a mechanism reports as `moves`, which
+ *  the pipeline's one formula then prices together with `PASS * unaccounted`.
+ *  The two readings of the byte term coincide by construction: the spans this
+ *  sums are exactly the ones the chart could not recognise (`rec === false`),
+ *  which are the spans the candidate leaves unaccounted. */
+function readBridgedBytes(derivation: Derivation<GItem>): number {
+  let bytes = 0;
+  let node: Derivation<GItem> | undefined = derivation;
+  while (node && node.rule) {
+    const o = node.premises[1]?.item;
+    if (o !== undefined && o.kind === "out" && o.rec === false) {
+      bytes += o.j - o.i;
+    }
+    node = node.premises[0];
+  }
+  return bytes;
+}
+
 function readCover(derivation: Derivation<GItem>): Seg[] {
   const segs: Seg[] = [];
   let node: Derivation<GItem> | undefined = derivation;
@@ -238,6 +262,14 @@ export interface DerivationItem {
  *  {@link GraphSearch}'s rules fired, recovered from the rule's premise/
  *  conclusion shape (the rules carry no label, so this classifies by structure,
  *  the single place that maps rule geometry to a name). */
+// CLOSED ON PURPOSE — AND ONLY THIS ONE IS.  A derivation move is BRANCHED ON
+// (`classifyMove`, the rationale's readers, MOVE_NOTE's fallback), so it is a
+// closed union: adding one without teaching every reader is a compile error,
+// which is what a closed vocabulary buys.  The MECHANISM names in
+// `rationale.ts` are the opposite case — written and displayed, never
+// branched on — and they stay free strings that COMPOSE with the nesting
+// (`["respond", "think", "recognise"]`).  That asymmetry is deliberate; do not
+// "fix" it by uniting the two (see test/126 for the pipeline half of it).
 export type DerivationMove =
   | "axiom" // a seed: a perceived leaf, a recognised form, or a computed result
   | "follow-edge" // form→form via a continuation edge (STEP) — the core "what follows what"
@@ -418,7 +450,6 @@ 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>,
@@ -429,7 +460,7 @@ export class GraphSearch {
      *  the rationale instead of stopping at the first layer.  Off by default, so
      *  the search pays nothing when no one inspects. */
     onDerivation?: (steps: DerivationStep[]) => void,
-  ): { segs: Seg[]; cost: number } | null {
+  ): { segs: Seg[]; cost: number; moves: number } | null {
     // Top-level entry: reset the per-call recursion state, then run the one
     // {@link solve} routine that both the query and any produced composite go
     // through (completion is cover, recursively — see {@link recompleteNode}).
@@ -441,12 +472,7 @@ export class GraphSearch {
     this.derivationSink = onDerivation;
     const solved = this.solve(
       queryLen,
-      {
-        sites,
-        leaves,
-        splits,
-        starts,
-      },
+      { sites, leaves, splits },
       conceptTarget,
       substitutions,
       connectors,
@@ -460,9 +486,11 @@ export class GraphSearch {
     // continuations instead of following the chain the answer itself licensed.
     // With deepening only at the top, `recompleteNode` walks the accepted chain
     // one link at a time (its own memo and stack), so the work is the answer's.
-    return solved === null
-      ? null
-      : { segs: this.deepen(solved.segs), cost: solved.cost };
+    return solved === null ? null : {
+      segs: this.deepen(solved.segs),
+      cost: solved.cost,
+      moves: solved.moves,
+    };
   }
   /** Build the deduction system for one span and return its lightest cover's
    *  chosen spans — the SINGLE routine the query and every produced composite
@@ -483,21 +511,19 @@ export class GraphSearch {
       sites: ReadonlyArray<Site>;
       leaves: ReadonlyArray<Leaf>;
       splits: ReadonlySet<number>;
-      starts: ReadonlySet<number>;
     },
     conceptTarget: ReadonlyMap<number, number>,
     substitutions?: ReadonlyMap<number, Uint8Array>,
     connectors?: ReadonlyMap<string, Uint8Array>,
     computedResults?: ReadonlyArray<ComputedResult>,
     onDerivation?: (steps: DerivationStep[]) => void,
-  ): { segs: Seg[]; cost: number } | null {
+  ): { segs: Seg[]; cost: number; moves: number } | null {
     const system = this.buildSearch(
       spanLen,
       recognition.sites,
       conceptTarget,
       recognition.leaves,
       recognition.splits,
-      recognition.starts,
       substitutions,
       connectors,
       computedResults,
@@ -520,7 +546,11 @@ export class GraphSearch {
       onDerivation(readDerivation(derivation, substitutions !== undefined));
     }
     return derivation
-      ? { segs: readCover(derivation), cost: derivation.cost }
+      ? {
+        segs: readCover(derivation),
+        cost: derivation.cost,
+        moves: derivation.cost - PASS * readBridgedBytes(derivation),
+      }
       : null;
   }
 
@@ -560,7 +590,6 @@ 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>,
@@ -722,7 +751,6 @@ export class GraphSearch {
         return this.outRules(it, {
           W,
           splits,
-          starts,
           atomsAreHubs,
           coversDone,
           outsByStart,
@@ -1135,6 +1163,7 @@ export class GraphSearch {
       // concepts/connectors either (those need the caller's async
       // pre-resolution) — the recursion follows edges and fusion, which is what
       // a deeper rewrite chain is made of.
+      if (this.host.meter) this.host.meter.recompletes++;
       const rec = this.host.recogniseSpan(bytes);
       const kids = new Set(nrec.kids);
       // THE NODE'S OWN KIDS ARE SITES BY STRUCTURE — recognition cannot be the
@@ -1181,7 +1210,6 @@ export class GraphSearch {
           sites: [...recognised, ...structural],
           leaves: rec.leaves,
           splits: rec.splits,
-          starts: rec.starts,
         },
         new Map(),
         undefined,
@@ -1391,20 +1419,36 @@ export class GraphSearch {
       // duplicate read and a branch that could never be taken.
       let next: number | null = null;
       let keyBytes = c.bytes;
-      // THE PREFIX ENDS ARE THE TAIL'S OWN FOLD BOUNDARIES, not every byte
-      // length.  The key is `entity + prefix`, and the prefix that names a
-      // stored relation ends where the fold cuts: measured over four join-firing
-      // queries, 5 of 5 accepted keys ended on a boundary (or the tail's end)
-      // while the byte-by-byte scan spent 153 probes where 14 boundaries would
-      // do.  Same criterion — resolves AND leads — same shortest-first order, so
-      // the answer is the same one the enumeration found; only the candidates
-      // come from the structure instead of from the byte count.  A host with no
-      // boundary rule falls back to the enumeration.
-      const cuts = this.host.contentCuts?.(tail);
-      const ends = cuts && cuts.length > 0
-        ? [...cuts.filter((c) => c > 0 && c < tail.length), tail.length]
-        : Array.from({ length: tail.length }, (_, i) => i + 1);
-      for (const len of ends) {
+      // THE CANDIDATE ENDS ARE THE PREFIXES THAT ARE STORED NODES, ASCENDING.
+      // The key is `entity + prefix`, and it names a relation exactly when that
+      // concatenation IS a node — so the ends come from a content-addressed
+      // probe per offset (the host's `contentKeyEnds`, the learning path's own
+      // mechanism: one leaf walk plus one `findBranch` per offset, no `resolve`),
+      // never from the fold's boundaries.  A boundary is not a proxy: a stored
+      // member's end is the end of ITS OWN stream, and the fold never cuts at a
+      // stream's end — measured, "stockholm mayor" exists, leads on to the mayor
+      // fact, and its boundary 6 sits in neither the tail's cuts ([4,7]) nor the
+      // concatenation's.  Filtering the scan by "is this a node?" cannot change
+      // the winner: a position that is not a node cannot resolve, so skipping it
+      // is invisible; and the order stays SHORTEST FIRST, which is a semantic
+      // law, not an optimisation (test/106, test/108 pin it).
+      //
+      // A host that cannot answer falls back to every prefix: exact and
+      // complete, at a `resolve` per offset.  A host that CAN answer is
+      // authoritative even when it answers "none" — if no prefix is a node then
+      // no key exists to resolve, so enumerating would only pay nulls.  (A key
+      // reachable through the CANONICAL equivalence alone and ending off every
+      // node end is therefore not tried here; that dimension is unreachable on
+      // this path by construction and is not part of the exact-key law.)
+      const ends = this.host.contentKeyEnds?.(c.bytes, tail);
+      const candidateEnds = function* (): Generator<number> {
+        if (ends !== undefined) {
+          yield* ends;
+          return;
+        }
+        for (let p = 1; p <= tail.length; p++) yield p;
+      };
+      for (const len of candidateEnds()) {
         keyBytes = concat2(c.bytes, tail.subarray(0, len));
         const k = this.host.resolve(keyBytes) ??
           this.host.canonResolve?.(keyBytes) ??
@@ -1459,7 +1503,6 @@ export class GraphSearch {
     ctx: {
       W: number;
       splits: ReadonlySet<number>;
-      starts: ReadonlySet<number>;
       atomsAreHubs: boolean;
       coversDone: Set<number>;
       outsByStart: Map<number, OutItem[]>;
@@ -1622,7 +1665,6 @@ export class GraphSearch {
     r: OutItem,
     ctx: {
       W: number;
-      starts: ReadonlySet<number>;
       atomsAreHubs: boolean;
       findLeafU: (b: Uint8Array) => number | undefined;
       findBranchU: (k: number[]) => number | undefined;

package/src/mind/match.ts

@@ -723,7 +723,7 @@ export function frameSlots(
  *  ANCHOR that the query displaced.  Neither implies the other, and the
  *  observed failures pass the restatement guard cleanly.
  *
- *  Three conditions, all byte-exact and all necessary:
+ *  Four conditions, all byte-exact and all necessary:
  *
  *  1. the query and the anchor must be ONE STRUCTURE — what they share has to
  *     dominate the query, or the query is not a variant of the anchor at all
@@ -811,8 +811,10 @@ export function substituteAll(
   const usable = pairs.filter((p) => p.needle.length > 0);
   if (usable.length === 0) return hay;
   // Longest needle first, so a needle that is a prefix of another can never
-  // pre-empt it.  Ties cannot arise: an instance whose fillers are not
-  // pairwise distinct is refused by frameSlots.
+  // pre-empt it.  Ties cannot arise: a consumer that VOICES checks the
+  // fillers pairwise with `distinct` and refuses such an instance itself —
+  // `frameSlots` reports and does not judge (see its own doc), so the refusal
+  // lives with the mechanism that needs it, not here.
   const order = [...usable].sort((a, b) => b.needle.length - a.needle.length);
   const out: number[] = [];
   let i = 0;
@@ -1002,6 +1004,8 @@ export function spanHalo(
   return found ? normalize(out) : null;
 }
 
+/** A TEST SURFACE: exported for the tests that pin the synonym strength ladder
+ *  (they are its only consumers); nothing in `src/` calls it. */
 /** 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

package/src/mind/mechanisms/alu.ts

@@ -9,7 +9,6 @@
 
 import type { Alu } from "../../alu/src/alu.js";
 import { STEP } from "../graph-search.js";
-import { unexplainedLabel } from "../rationale.js";
 import type { PipelineMechanism } from "../pipeline-mechanism.js";
 
 /** Wrap the ALU as a {@link PipelineMechanism}. */
@@ -35,7 +34,6 @@ export function aluToMechanism(alu: Alu): PipelineMechanism {
         bytes: u.bytes,
         accounted: [[u.i, u.j]],
         moves: STEP,
-        unexplained: unexplainedLabel(query, [[u.i, u.j]]),
       }));
     },
   };

package/src/mind/mechanisms/cast.ts

@@ -30,15 +30,11 @@ import {
   sharedFrameStrengthOf,
 } from "../match.js";
 import { joinWithBridge } from "../resonance.js";
-import { restatesQuery } from "../reasoning.js";
 import { CONCEPT, STEP } from "../graph-search.js";
 import { concat2, indexOf } from "../../bytes.js";
 import { consensusFloor, dominates } from "../../geometry.js";
-import {
-  decodeText,
-  unexplainedLabel,
-  unexplainedSpans,
-} from "../rationale.js";
+import { decodeText } from "../rationale.js";
+import { restates, unexplainedSpans } from "../derivation.js";
 import { rItem, rNode } from "../trace.js";
 import { dismissedKnownContent } from "../bridge.js";
 import { leafIdRun } from "../canonical.js";
@@ -92,7 +88,6 @@ export interface CastResult {
   /** A human-readable label for the query bytes this schema left
    *  unexplained — purely diagnostic, never priced (see the module's
    *  Task 2 note in pipeline.ts's Candidate interface). */
-  unexplained: string;
 }
 
 /** The seat that establishes a node's role in an analogical comparison:
@@ -129,7 +124,7 @@ export interface CastResult {
  *  describes id ("...painted by Leonardo da Vinci." contains "Leonardo da
  *  Vinci").  An incidental adjacency predecessor never does — it merely
  *  preceded id in some unrelated document without ever mentioning it.  No
- *  new tuned constant: containment is the same primitive `restatesQuery`
+ *  new tuned constant: containment is the same primitive `restates`
  *  and `dominates`-style checks already use throughout this codebase.
  *
  *  `allowForward` (default true) gates the FORWARD branch specifically —
@@ -499,7 +494,6 @@ export async function counterfactualTransfer(
       used: used ?? new Set(),
       accounted,
       moves,
-      unexplained: unexplainedLabel(query, accounted),
     });
   };
   ctx.trace?.step(
@@ -613,7 +607,7 @@ export async function counterfactualTransfer(
     const fwd = await follow(ctx, proj.anchor, qv);
     if (
       fwd !== null && indexOf(answer, fwd, 0) < 0 &&
-      !restatesQuery(query, fwd)
+      !restates(query, fwd, 0, { proper: true })
     ) {
       // THROUGH THE SHARED JOINER, not a bare concatenation.
       //
@@ -695,7 +689,7 @@ export async function counterfactualTransfer(
   // cap the test reads "none of the established continuations appears".
   const domNext = ctx.store.nextFirst(dominant.anchor, hubBound(ctx));
   const displaced = domNext
-    .every((n) => indexOf(query, read(ctx, n), 0) < 0);
+    .every((n) => !restates(query, read(ctx, n), 0));
   // The SUBSTITUTE is what redirection speaks — the answer IS `project(last)`,
   // its own fact — so the same bar applies.  The displaced structure is only
   // recognised as the slot being overridden and is never voiced, so it is
@@ -791,7 +785,7 @@ export async function counterfactualTransfer(
       queryScale(p.ctx.length) &&
       indexOf(dominant.ctx, p.ctx, 0) < 0 &&
       indexOf(p.ctx, dominant.ctx, 0) < 0 &&
-      indexOf(query, p.ctx, 0) < 0
+      !restates(query, p.ctx, 0)
     ) {
       analogs.push({ anchor: p.anchor, point: p, src: p });
     }
@@ -810,7 +804,7 @@ export async function counterfactualTransfer(
         !queryScale(nctx.length) ||
         indexOf(dominant.ctx, nctx, 0) >= 0 ||
         indexOf(nctx, dominant.ctx, 0) >= 0 ||
-        indexOf(query, nctx, 0) >= 0
+        restates(query, nctx, 0)
       ) continue;
       analogs.push({ anchor: nid, point: null, src: p });
     }
@@ -867,7 +861,9 @@ export async function counterfactualTransfer(
   // grounds") — fine for ORIENTING mechanisms, not for voicing learnt
   // content the query never asked about.  Computed once here; both the
   // hub fallback below and the comparison gate consume it.
-  const rootTrusted = roots.some((r) => r.vote >= consensusFloor(corpusN(ctx)));
+  const rootTrusted = roots.some((r) =>
+    r.idfVote >= consensusFloor(corpusN(ctx))
+  ); // the IDF sum: the bar's own quantity
   // The context that ESTABLISHES a filler — the same reverse context, under
   // the same naming test, `seatOfNode` uses to VOICE an analog (a predecessor
   // whose bytes CONTAIN the node's: it names or describes it, rather than
@@ -1284,13 +1280,16 @@ export async function counterfactualTransfer(
     // consulting it here is the same fallback `resolve` already makes when an
     // exact content lookup misses, and it keeps this mechanism from carrying
     // any idea of its own about what a character is.
-    const echoesQuery = (x: Uint8Array): boolean => {
-      if (restatesQuery(query, x)) return true;
-      const canon = ctx.canon;
-      if (canon === null) return false;
-      const cq = canon(query), cx = canon(x);
-      return cx.length < cq.length && indexOf(cq, cx, 0) >= 0;
-    };
+    // TWO WITNESSES, ONE LAW: the byte reading, and — when the response carries
+    // one — the same reading under the response's own equivalence.  Asked twice
+    // rather than branched on, because the equivalence is a property of the
+    // injected canonicalizer (a substring-monotone function is the usual case,
+    // not a guarantee), and the two readings are OR-ed here exactly as they were
+    // before this became one definition.
+    const echoesQuery = (x: Uint8Array): boolean =>
+      restates(query, x, 0, { proper: true }) ||
+      (ctx.canon !== null &&
+        restates(query, x, 0, { equate: ctx.canon, proper: true }));
     if (echoesQuery(b)) {
       const fwd = await follow(ctx, bestAnalog.anchor, qv);
       if (fwd !== null && fwd.length > 0 && !echoesQuery(fwd)) b = fwd;
@@ -1404,7 +1403,6 @@ export const castMechanism: PipelineMechanism = {
       accounted: c.accounted,
       moves: c.moves,
       used: c.used,
-      unexplained: c.unexplained,
     }));
   },
 };

package/src/mind/mechanisms/confluence.ts

@@ -44,7 +44,7 @@ import { read } from "../primitives.js";
 import { corpusN, reachOf } from "../traverse.js";
 import { dominates } from "../../geometry.js";
 import { STEP } from "../graph-search.js";
-import { unexplainedLabel } from "../rationale.js";
+import { insideAnsweredTurn } from "../derivation.js";
 import type { PipelineMechanism, Precomputed } from "../pipeline-mechanism.js";
 import { rItem, rNode } from "../trace.js";
 
@@ -58,9 +58,6 @@ export interface JoinResult {
   used: ReadonlySet<number>;
   accounted: Array<[number, number]>;
   moves: number;
-  /** A human-readable label for the query bytes the meet left unexplained —
-   *  purely diagnostic, never priced. */
-  unexplained: string;
 }
 
 /** The main confluence entry point.  Given a query, detect whether it weaves
@@ -98,14 +95,9 @@ export async function confluenceJoin(
   // 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;
+  const answered = { at: 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;
+    if (insideAnsweredTurn(ctx.answeredSpans, answered, off, off + W)) continue;
     queryWin.set(off, id);
   }
   const queryIds = new Set(queryWin.values());
@@ -146,6 +138,30 @@ export async function confluenceJoin(
   const bindsAConstituent = (cover: Array<[number, number]>): boolean =>
     cover.some(([cs, ce]) => ce - cs >= 2 * W);
 
+  // THE VOTE ENTERS AS ORDER, NEVER AS A BAR.  This is the only one of the
+  // climb's four consumers (recall, fuseAttention, cast, here) that uses the
+  // evidence's MAGNITUDE without a floor, and it is legitimate by construction:
+  // `ranked` answers "which anchor is stronger" — a question about votes, so the
+  // comparison stays within one dimension — and the vote is otherwise only
+  // REPORTED (Stream.vote travels to the rationale's constraint nodes).  What
+  // actually SELECTS a constraint is byte-structural and never the magnitude: a
+  // run of at least 2W (`bindsAConstituent`, with its accidental-sharing
+  // counter-examples above), disjoint covers (`disjoint`), and scaffolding never
+  // binds at all (`dominates(reachOf(…), N)`).  The MEET such a stream may
+  // produce is selected the same way: a span shorter than 2W is rejected, and
+  // the winner is the one with the smallest `reach` (ties broken by the longer
+  // span) — a corpus quantity and bytes, never the vote, which appears only in
+  // the trace item.
+  // binds at all (`dominates(reachOf(…), N)`).  The only cut in this loop is a
+  // BUDGET, and it is measured: stopping the scan at 2W anchors saves 50-70% of
+  // confluence's cost on non-conjunctive queries while preserving every genuinely
+  // conjunctive case, whose top anchors ARE its constraints.
+  // MEASURED (this goal, on THIS file's own conjunctive fixture): the two
+  // streams appear at ranks 1 and 4 against a budget of 2W = 8, on a query whose
+  // `ranked` is 9 — so the cut IS live (it would have returned null at the 8th
+  // anchor) and it does NOT prune the case it exists to protect.  The other
+  // conjunctive fixture (the Leonardo one) finds them at ranks 0 and 1.  Scope:
+  // these are the repo's conjunctive fixtures, and no more.
   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
@@ -291,7 +307,6 @@ export async function confluenceJoin(
     used: new Set([met.a.anchor, met.b.anchor]),
     accounted,
     moves: 3 * STEP,
-    unexplained: unexplainedLabel(query, accounted),
   };
 }
 
@@ -320,7 +335,6 @@ export const confluenceMechanism: PipelineMechanism = {
       accounted: met.accounted,
       moves: met.moves,
       used: met.used,
-      unexplained: met.unexplained,
     }];
   },
 };

package/src/mind/mechanisms/cover.ts

@@ -16,7 +16,8 @@ import { guidedFirst, hubBound } from "../traverse.js";
 import { conceptHop } from "../match.js";
 import { bridge } from "../resonance.js";
 import { liftAnswer, liftedScaffolding, segRestatesQuery } from "../types.js";
-import { decodeText, unexplainedLabel } from "../rationale.js";
+import { decodeText } from "../rationale.js";
+import { insideAnsweredTurn, restates } from "../derivation.js";
 import { indexOf } from "../../bytes.js";
 import type { RationaleItem } from "../rationale.js";
 import { rItem, rNode, traceDerivation } from "../trace.js";
@@ -62,16 +63,13 @@ export async function resolveConnectors(
   // discarded — a semantically neutral gate (it removes work whose product
   // liftAnswer throws away), and a cumulative (multi-turn) query is exactly
   // where such already-answered continuations recur.
-  let answered = 0;
+  const answered = { at: 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 (insideAnsweredTurn(ctx.answeredSpans, answered, s.start, s.end)) {
+        return false;
+      }
       if (query === undefined || ctx.answeredSpans.length === 0) return true;
       const continuations = ctx.store.nextFirst(s.payload, hubBound(ctx));
       return !continuations.some((answer) => {
@@ -93,7 +91,11 @@ export async function resolveConnectors(
         // 3 bytes this reads 4 bytes per candidate instead of the ~231 it
         // averaged before.
         const bytes = read(ctx, answer, query.length + 1);
-        return bytes.length <= query.length && indexOf(query, bytes, 0) >= 0;
+        // THE CONTENT READING of the same exclusion: the site's own
+        // continuation already occurs in the query, so voicing it back adds
+        // nothing.  It is the restatement law with no `proper` flag — the
+        // containment reading that also admits the whole query.
+        return restates(query, bytes, 0);
       });
     });
   const bridgePair = async (l: number, r: number) => {
@@ -210,18 +212,11 @@ export const coverMechanism: PipelineMechanism = {
       )
       : await resolveConnectors(ctx, sites, query);
     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 = ctx.meter
@@ -262,7 +257,6 @@ export const coverMechanism: PipelineMechanism = {
       concepts,
       rec.leaves,
       splits,
-      starts,
       undefined,
       connectors,
       computedResults,
@@ -330,9 +324,12 @@ export const coverMechanism: PipelineMechanism = {
     return [{
       bytes: composed,
       accounted,
-      moves: 0,
-      weight: solved!.cost, // A*LD derivation's g-value IS the weight
-      unexplained: unexplainedLabel(query, accounted),
+      // The derivation's DISCRETE work.  The bytes the chart could not
+      // recognise are NOT priced here: they are exactly the spans `accounted`
+      // leaves uncovered, and the pipeline's one formula charges them at PASS —
+      // the same formula that prices every other mechanism's candidate.  No
+      // mechanism spells a cost of its own.
+      moves: solved!.moves,
       // How much of the composed answer is the asker's own unexplained words
       // (the spans the liftAnswer trace above labels "scaffolding").  Cover is
       // the mechanism that can carry them, because a PASS span still lands in

package/src/mind/mechanisms/extraction.ts

@@ -11,7 +11,7 @@ import type { MindContext } from "../types.js";
 import { read } from "../primitives.js";
 import { follow, isSpanShaped, locate, skillExemplar } from "../match.js";
 import { concatBytes, indexOf } from "../../bytes.js";
-import { decodeText, unexplainedLabel } from "../rationale.js";
+import { decodeText } from "../rationale.js";
 import type {
   PipelineMechanism,
   Precomputed,
@@ -46,7 +46,6 @@ export async function extractBySkill(
   {
     bytes: Uint8Array;
     accounted: Array<[number, number]>;
-    unexplained: string;
   } | null
 > {
   const t = ctx.trace?.enter("extractBySkill", [
@@ -102,6 +101,12 @@ export async function extractBySkill(
   const searched = ranked.slice(0, pre.k);
   let shapeMisses = 0;
   let subQuantum = 0;
+  // A SECOND refusal counter, because the note below used to call an UNANCHORED
+  // read "sub-quantum" — which is false, and it is the kind of instrumentation
+  // defect AGENTS §6 says to close where it lives: a reader could not tell from
+  // the trace which of the two gates refused.  Neither counter reaches a
+  // decision (meter.ts contract 1); they exist so the refusal is legible.
+  let unanchored = 0;
   for (const cand of searched) {
     const exemplar = await pre.spanShapedOf(cand.anchor);
     if (!exemplar) {
@@ -137,22 +142,23 @@ export async function extractBySkill(
     // Here the field is this mechanism's own output and carries its documented
     // meaning, so the test is sound exactly where the convention does not reach.
     if (built.accounted.length === 0) {
-      subQuantum++;
+      unanchored++;
       continue;
     }
-    if (shapeMisses > 0 || subQuantum > 0) {
+    if (shapeMisses > 0 || subQuantum > 0 || unanchored > 0) {
       ctx.trace?.step(
         "trySkillAnchors",
         [
           rItem(
             query.subarray(0, 0),
-            `skipped ${shapeMisses + subQuantum}`,
+            `skipped ${shapeMisses + subQuantum + unanchored}`,
           ),
           rNode(ctx, cand.anchor, "chosen"),
         ],
         [],
-        `skipped ${shapeMisses} non-exemplar and ${subQuantum} sub-quantum ` +
-          `anchor(s) before one yielded a usable extraction`,
+        `skipped ${shapeMisses} non-exemplar, ${subQuantum} sub-quantum and ` +
+          `${unanchored} unanchored anchor(s) before one yielded a usable ` +
+          `extraction`,
       );
     }
     t?.done(
@@ -170,7 +176,6 @@ export async function extractBySkill(
     return {
       bytes: built.bytes,
       accounted: built.accounted,
-      unexplained: unexplainedLabel(query, built.accounted),
     };
   }
   if (shapeMisses === searched.length) {
@@ -403,7 +408,6 @@ export const extractionMechanism: PipelineMechanism = {
       bytes: ex.bytes,
       accounted: ex.accounted,
       moves: CONCEPT + STEP * ex.accounted.length,
-      unexplained: ex.unexplained,
     }];
   },
 };

package/src/mind/mechanisms/prefix-completion.ts

@@ -300,7 +300,6 @@ export const prefixMechanism: PipelineMechanism = {
       // IDENTITY bridge takes.
       accounted: [[0, query.length]],
       moves: STEP,
-      unexplained: "",
       // NOT complete: the query is a proper PREFIX, so the form may carry more
       // past the remainder this voiced.
     }];