@hviana/sema 0.8.2 → 0.8.5

package/dist/src/mind/mechanisms/cast.js

@@ -14,11 +14,10 @@ import { read } from "../primitives.js";
 import { argmaxBy, corpusN, edgeAncestors, hubBound, sharedReachMemo, } from "../traverse.js";
 import { analogyStrength, follow, project, reverseContext, sharedFrameStrengthOf, } from "../match.js";
 import { joinWithBridge } from "../resonance.js";
-import { restatesQuery } from "../reasoning.js";
 import { CONCEPT, STEP } from "../graph-search.js";
 import { indexOf } from "../../bytes.js";
 import { consensusFloor, dominates } from "../../geometry.js";
-import { unexplainedLabel, unexplainedSpans, } 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";
@@ -89,7 +88,7 @@ const MIN_WEAVE = 2;
  *  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 —
@@ -421,7 +420,6 @@ export async function counterfactualTransfer(ctx, query, pre) {
             used: used ?? new Set(),
             accounted,
             moves,
-            unexplained: unexplainedLabel(query, accounted),
         });
     };
     ctx.trace?.step("alignStructures", [rItem(query, "query")], points.map((p) => rNode(ctx, p.anchor, "structure", p.vote)), "the independent learnt structures the query weaves, by graded alignment");
@@ -522,7 +520,7 @@ export async function counterfactualTransfer(ctx, query, pre) {
         let answer = await joinWithBridge(ctx, filler, tail);
         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.
             //
             // `joinWithBridge` is the composition step every out-of-search assembly
@@ -588,7 +586,7 @@ export async function counterfactualTransfer(ctx, query, pre) {
     // 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
@@ -658,7 +656,7 @@ export async function counterfactualTransfer(ctx, query, pre) {
         if (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 });
         }
         // Reach through to the point's continuation targets regardless
@@ -675,7 +673,7 @@ export async function counterfactualTransfer(ctx, query, pre) {
             if (!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 });
         }
@@ -731,7 +729,7 @@ export async function counterfactualTransfer(ctx, query, pre) {
     // 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
@@ -1132,15 +1130,15 @@ export async function counterfactualTransfer(ctx, query, pre) {
         // 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) => {
-            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) => 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))
@@ -1240,7 +1238,6 @@ export const castMechanism = {
             accounted: c.accounted,
             moves: c.moves,
             used: c.used,
-            unexplained: c.unexplained,
         }));
     },
 };

package/dist/src/mind/mechanisms/confluence.d.ts

@@ -10,9 +10,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
  *  two or more INDEPENDENT constraints (ranked anchors supported by disjoint

package/dist/src/mind/mechanisms/confluence.js

@@ -42,7 +42,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 { rItem, rNode } from "../trace.js";
 /** The main confluence entry point.  Given a query, detect whether it weaves
  *  two or more INDEPENDENT constraints (ranked anchors supported by disjoint
@@ -75,13 +75,9 @@ export async function confluenceJoin(ctx, query, pre) {
     // Recognition and attention still see the full transcript; only this
     // mechanism's constraint population excludes answered spans.
     const queryWin = new Map();
-    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])
+        if (insideAnsweredTurn(ctx.answeredSpans, answered, off, off + W))
             continue;
         queryWin.set(off, id);
     }
@@ -98,6 +94,30 @@ export async function confluenceJoin(ctx, query, pre) {
     // constraints).  Shard-bound streams are no constraints, and their meets
     // are connective debris (". Sure,", "ngul" — observed).
     const bindsAConstituent = (cover) => 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 = [];
     const rankedCapped = ranked.length > pre.k ? ranked.slice(0, pre.k) : ranked;
     // CONJUNCTIVITY EARLY-EXIT: a conjunctive query's top-ranked anchors
@@ -234,7 +254,6 @@ export async function confluenceJoin(ctx, query, pre) {
         used: new Set([met.a.anchor, met.b.anchor]),
         accounted,
         moves: 3 * STEP,
-        unexplained: unexplainedLabel(query, accounted),
     };
 }
 // ── Pipeline mechanism ──────────────────────────────────────────────────────
@@ -265,7 +284,6 @@ export const confluenceMechanism = {
                 accounted: met.accounted,
                 moves: met.moves,
                 used: met.used,
-                unexplained: met.unexplained,
             }];
     },
 };

package/dist/src/mind/mechanisms/cover.js

@@ -13,8 +13,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 { indexOf } from "../../bytes.js";
+import { decodeText } from "../rationale.js";
+import { insideAnsweredTurn, restates } from "../derivation.js";
 import { rItem, rNode, traceDerivation } from "../trace.js";
 // ── Concept / connector pre-resolution ──────────────────────────────────────
 export async function resolveConcepts(ctx, sites) {
@@ -45,16 +45,13 @@ export async function resolveConnectors(ctx, sites, query) {
     // 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])
+        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));
@@ -77,7 +74,11 @@ export async function resolveConnectors(ctx, sites, query) {
             // 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, r) => {
@@ -171,18 +172,11 @@ export const coverMechanism = {
             ? 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) {
             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
@@ -208,7 +202,7 @@ export const coverMechanism = {
             ])),
             ...computedResults.map((u) => rItem(u.bytes, "computed")),
         ], coverDeps.length ? coverDeps : undefined);
-        const solved = ctx.search.cover(query.length, sites, concepts, rec.leaves, splits, starts, undefined, connectors, computedResults, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
+        const solved = ctx.search.cover(query.length, sites, concepts, rec.leaves, splits, undefined, connectors, computedResults, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
         const segs = solved && solved.segs;
         tCover?.done(segs === null
             ? []
@@ -247,9 +241,12 @@ export const coverMechanism = {
         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/dist/src/mind/mechanisms/extraction.d.ts

@@ -19,7 +19,6 @@ import type { PipelineMechanism, Precomputed } from "../pipeline-mechanism.js";
 export declare function extractBySkill(ctx: MindContext, query: Uint8Array, pre: Precomputed): Promise<{
     bytes: Uint8Array;
     accounted: Array<[number, number]>;
-    unexplained: string;
 } | null>;
 /** Decompose an answer into substrings of its surrounding context, in order —
  *  the STRONG span-shape reading (see the section note above).  Returns null

package/dist/src/mind/mechanisms/extraction.js

@@ -8,7 +8,7 @@
 // that contains it.
 import { locate } from "../match.js";
 import { concatBytes, indexOf } from "../../bytes.js";
-import { decodeText, unexplainedLabel } from "../rationale.js";
+import { decodeText } from "../rationale.js";
 import { CONCEPT, STEP } from "../graph-search.js";
 import { rItem, rNode, traceFail } from "../trace.js";
 // ── Extraction ────────────────────────────────────────────────────────────
@@ -81,6 +81,12 @@ export async function extractBySkill(ctx, query, pre) {
     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) {
@@ -116,15 +122,16 @@ export async function extractBySkill(ctx, query, pre) {
         // 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}`),
+                rItem(query.subarray(0, 0), `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([rItem(built.bytes, "extracted")], built.pieces === 1
             ? `apply a learnt extraction skill — read the analogous span of the query` +
@@ -134,7 +141,6 @@ export async function extractBySkill(ctx, query, pre) {
         return {
             bytes: built.bytes,
             accounted: built.accounted,
-            unexplained: unexplainedLabel(query, built.accounted),
         };
     }
     if (shapeMisses === searched.length) {
@@ -321,7 +327,6 @@ export const extractionMechanism = {
                 bytes: ex.bytes,
                 accounted: ex.accounted,
                 moves: CONCEPT + STEP * ex.accounted.length,
-                unexplained: ex.unexplained,
             }];
     },
 };

package/dist/src/mind/mechanisms/prefix-completion.js

@@ -255,7 +255,6 @@ export const prefixMechanism = {
                 // 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.
             }];

package/dist/src/mind/mechanisms/recall.d.ts

@@ -6,7 +6,6 @@ export interface RecallResult {
     echoed: boolean;
     accounted: Array<[number, number]>;
     moves: number;
-    unexplained: string;
     /** See {@link import("../pipeline-mechanism.js").MechanismResult.complete}
      *  — set by the IDENTITY-bridge tier alone. */
     complete?: boolean;

package/dist/src/mind/mechanisms/recall.js

@@ -6,11 +6,11 @@
 import { cosine } from "../../vec.js";
 import { consensusFloor, dominates, identityBar, reachThreshold, significanceBar, } from "../../geometry.js";
 import { gistOf, read, resolve } from "../primitives.js";
-import { bytesEqual, indexOf } from "../../bytes.js";
+import { indexOf } from "../../bytes.js";
 import { allWindowsAreScaffolding, corpusN, hubBound } from "../traverse.js";
 import { follow, project, reverseContext, voicesDisplacedFiller, } from "../match.js";
 import { CONCEPT, STEP } from "../graph-search.js";
-import { unexplainedLabel } from "../rationale.js";
+import { restates as lawRestates } from "../derivation.js";
 import { rItem, rNode } from "../trace.js";
 import { substitutionBridge } from "../bridge.js";
 /** Recall the answer by resonating the whole query against the content index. */
@@ -29,7 +29,6 @@ export async function recallByResonance(ctx, query, pre) {
             echoed,
             accounted,
             moves,
-            unexplained: unexplainedLabel(query, accounted),
             ...(complete ? { complete } : {}),
         };
     };
@@ -103,7 +102,7 @@ export async function recallByResonance(ctx, query, pre) {
             // 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)) {
+                !lawRestates(query, g, 0, { proper: true })) {
                 return ground(g, "argument binding — the query's sole edge-source constituent, continuation followed", [[arg.start, arg.end]], STEP);
             }
         }
@@ -130,9 +129,10 @@ export async function recallByResonance(ctx, query, pre) {
     // same principle that keeps cast from voicing stored questions), and
     // projecting them forward is reverse recall's containment failure in the
     // other direction — "whatever followed these bytes in some document".
-    const qKey = ctx.canon ? ctx.canon(query) : query;
-    const restates = (b) => bytesEqual(b, query) ||
-        (ctx.canon !== null && bytesEqual(ctx.canon(b), qKey));
+    // THE EQUALITY READING of the restatement law: this tier rejects an answer
+    // that IS the question (an echo), and a proper fragment is handled by the
+    // tier's own subspan tests further down — so the law is asked with `whole`.
+    const restates = (b) => lawRestates(query, b, 0, { equate: ctx.canon, whole: true });
     const idBar = identityBar(ctx.store.D, ctx.space.maxGroup, query.length);
     if (top.score >= idBar) {
         for (const h of whole) {
@@ -194,9 +194,36 @@ export async function recallByResonance(ctx, query, pre) {
         // consensus", while breadth is the SCALE-INVARIANT reading — "a point whose
         // breadth clears `dominates` (> half the query's regions corroborate it) is
         // real consensus; one that does not is a coincidental single-region echo".
-        // Attention.peak's contract makes the same point from the other side:
-        // comparing a POOLED SUM against a floor that prices ONE region's evidence
-        // is a dimensional error.
+        // THIS USED TO CLAIM A DIMENSIONAL ERROR, AND THAT CLAIM WAS FALSE.
+        // It read: "comparing a POOLED SUM against a floor that prices ONE region's
+        // evidence is a dimensional error."  `consensusFloor` is not priced for one
+        // region: thresholds.md §2 derives it as the POOLED-vote significance floor —
+        // "each region contributes at most ln(N/c) <= ln(N); ln(N)+1/2 demands ..." —
+        // and attention.ts says the same where it builds the vote ("the scale
+        // consensusFloor is derived for").  The comparison is in ONE dimension, and
+        // it is so because the climb WEIGHTS BY IDF: `wf` in voteRegions is
+        // `direct ? df : combined ? idf + df : idf`, and the engine only ever runs the
+        // last one (DFMode's default "inverse", the mode every non-test caller uses —
+        // `direct` and `combined` are exercised by test/24 and test/27 only, and
+        // test/24 pins that their votes DO differ).  In those two the sum would leave
+        // the floor's dimension and the floor would need re-deriving.
+        //
+        // What the OR below is really for is SCALE, not dimension (the paragraph
+        // above says it): a vote that clears ln(N)+1/2 means "strong" on a small store
+        // and "weak" on a large one for the same genuine consensus, so the
+        // scale-invariant breadth reading is added beside it.
+        //
+        // AND THE PREMISE IS IDF.  The deviation in the other two weighting modes is
+        // TWO-SIDED and DERIVED: `direct` DEFLATES a region (ln(1+c) < ln(N/c) for
+        // small c) and `combined` INFLATES it (ln N + ln(1+1/c)), both by at most
+        // `ln 2` — see `geometry.ts`'s `consensusFloor`, where the bound lives.
+        // MEASURED on 8 anchors across 5 queries, running the same climb in all
+        // three modes: ZERO gate inversions — every anchor's `vote >= floor` verdict
+        // is the same in `inverse`, `direct` and `combined`, even where the readings
+        // straddle the floor on opposite sides (#148: inverse 3.39, combined 4.71
+        // above it, direct 1.31 below).  Pinned by test/55's test 20.  The bar is not
+        // re-derived for those modes because nothing reachable needs it; the premise
+        // is IDF, and that is now written where the gate reads it.
         //
         // Measured on the 15.7M-node store (N=325,615, so the old floor was 13.19).
         // The absolute vote cannot separate right from wrong at this scale, and the
@@ -265,7 +292,7 @@ export async function recallByResonance(ctx, query, pre) {
         const minVote = consensusFloor(corpusN(ctx));
         if (forest.length > 0 &&
             !allWindowsAreScaffolding(ctx, query) &&
-            (forest[0].vote >= minVote ||
+            (forest[0].idfVote >= minVote || // the IDF sum: the bar's own quantity
                 (dominates(forest[0].breadth, 1) && forest[0].peak > Math.LN2))) {
             const g = await project(ctx, forest[0].anchor, queryGist);
             // THE ANCHOR'S OCCUPANT IS NOT THE ASKER'S.  This tier grounds an anchor
@@ -288,7 +315,7 @@ export async function recallByResonance(ctx, query, pre) {
             // — never an answer (the same principle as `restates` above, extended
             // to fragments).  Genuine anchor groundings — longer than the query,
             // or disjoint from it — pass untouched.
-            else if (g && !(g.length < query.length && indexOf(query, g, 0) >= 0)) {
+            else if (g && !lawRestates(query, g, 0, { proper: true })) {
                 return ground(g, "scaffolding-dominated query — ground the consensus-climb anchor", [[forest[0].start, forest[0].end]], CONCEPT);
             }
         }
@@ -466,8 +493,8 @@ export const recallMechanism = {
                 bytes: r.bytes,
                 accounted: r.accounted,
                 moves: r.moves,
-                unexplained: r.unexplained,
                 provenance: r.echoed ? "recall-echo" : "recall",
+                used: new Set(),
                 ...(r.complete ? { complete: true } : {}),
             }];
     },

package/dist/src/mind/mechanisms/reference.js

@@ -35,8 +35,8 @@
 // made AVAILABLE, never imposed.
 import { carriesFillers, distinct, follow, substituteAll } from "../match.js";
 import { dominates } from "../../geometry.js";
-import { bytesEqual, indexOf } from "../../bytes.js";
-import { unexplainedLabel } from "../rationale.js";
+import { bytesEqual } from "../../bytes.js";
+import { restates } from "../derivation.js";
 import { STEP } from "../graph-search.js";
 import { rItem, rNode, traceFail } from "../trace.js";
 /** The minimum number of instances that can establish a frame.  One instance
@@ -196,7 +196,7 @@ export async function bindReference(ctx, query, pre) {
         return fail("the binding produced nothing");
     // Answering with the question is not answering — the same restated-fragment
     // guard every recall tier applies.
-    if (bytes.length < query.length && indexOf(query, bytes, 0) >= 0) {
+    if (restates(query, bytes, 0, { proper: true })) {
         return fail("the binding restates part of the question");
     }
     const carried = !bytesEqual(bytes, first);
@@ -230,7 +230,6 @@ export async function bindReference(ctx, query, pre) {
         // binding claims strictly more than a one-slot binding, so where both are
         // licensed the smaller claim wins.
         moves: STEP * slots.length + STEP,
-        unexplained: unexplainedLabel(query, accounted),
         // NOT scaffolding.  That field counts answer bytes carried through BECAUSE
         // NOTHING EXPLAINED THEM; a referent is carried because the frame's slot
         // explains it, and it is accounted above.  Reporting it would make every

package/dist/src/mind/mind.d.ts

@@ -75,6 +75,8 @@ export interface MindOptions {
     seed?: number;
     recallQueryK?: number;
     haloQueryK?: number;
+    /** Branch nodes the pivot sweep may probe — see {@link MindConfig}. */
+    pivotProbeK?: number;
     /** Items one rationale step may itemise — see {@link MindConfig}. */
     rationaleSampleK?: number;
     /** Corpus-reading capacities and budgets — see {@link MindConfig}. */
@@ -202,8 +204,8 @@ export declare class Mind implements MindContext {
      *  with the most distributional evidence (highest `prevOf` count — the
      *  structural manifestation of its halo).  When evidence is equal the
      *  first-inserted edge wins. */
-    /** See {@link GraphSearchHost.contentCuts}. */
-    contentCuts(bytes: Uint8Array): readonly number[];
+    /** See {@link GraphSearchHost.contentKeyEnds}. */
+    contentKeyEnds(prefix: Uint8Array, tail: Uint8Array): readonly number[];
     chooseNext(node: number): number | undefined;
     constructor(opts?: MindOptions);
     constructor(cfg: MindConfig, store: Store, _fromStore: true);

package/dist/src/mind/mind.js

@@ -11,7 +11,8 @@
 import { makeKeyring, rng, setVecConfig } from "../vec.js";
 import { sampleCorpus, searchCorpus } from "./corpus.js";
 import { Alphabet } from "../alphabet.js";
-import { contentBoundaries, contentFoldIncremental, reachThreshold, } from "../geometry.js";
+import { contentFoldIncremental, reachThreshold, } from "../geometry.js";
+import { keyEnds } from "./canonical.js";
 import { BoundedMap } from "../store.js";
 import { SQliteStore } from "../store-sqlite.js";
 import { resolveConfig } from "../config.js";
@@ -160,9 +161,9 @@ export class Mind {
      *  with the most distributional evidence (highest `prevOf` count — the
      *  structural manifestation of its halo).  When evidence is equal the
      *  first-inserted edge wins. */
-    /** See {@link GraphSearchHost.contentCuts}. */
-    contentCuts(bytes) {
-        return contentBoundaries(this.space, bytes);
+    /** See {@link GraphSearchHost.contentKeyEnds}. */
+    contentKeyEnds(prefix, tail) {
+        return keyEnds(this, prefix, tail);
     }
     chooseNext(node) {
         return chooseNext(this, node, this._edgeGuide);

package/dist/src/mind/pipeline-mechanism.d.ts

@@ -151,10 +151,14 @@ export interface MechanismResult {
     bytes: Uint8Array;
     accounted: Array<[number, number]>;
     moves: number;
+    /** WHAT THIS ANSWER SPEAKS FOR — the anchors it voices, and therefore the
+     *  content the reasoner must not pivot back through.  Declared by the
+     *  mechanism about its OWN result, exactly like `accounted`/`used`/
+     *  `complete`: post-grounding honours the property and NEVER ASKS WHICH
+     *  MECHANISM SET IT, so the market stays uniform.  An EMPTY set is a real
+     *  declaration — "this answer voices nothing" (recall) — and withholds
+     *  nothing; omit the field and the pipeline re-recognises the answer. */
     used?: ReadonlySet<number>;
-    unexplained: string;
-    /** Explicit weight override.  When absent, weight = moves + PASS·unaccounted. */
-    weight?: number;
     /** Bytes of `bytes` that came from spans nothing recognised — the asker's
      *  own words carried through verbatim rather than derived (see
      *  {@link liftedScaffolding}).  Reported, not priced: the ladder prices what