@hviana/sema 0.8.3 → 0.8.5

package/dist/src/mind/derivation.js

@@ -0,0 +1,327 @@
+// derivation.ts — the derivation unit and the one closure law it is governed by.
+//
+// THE LAW, in the quantities this engine already has:
+//
+//   A derivation is CLOSED for a query when the structure it built accounts for
+//   the query's REMAINDER under the engine's own identity and admission rules,
+//   and every step is priced on the one ladder.
+//
+// It is written ONCE, here, because that is where a rule has to live — in the
+// behaviour of the code and at the sites it governs (this repository's own
+// history records the same conclusion: a law written as a document was deleted,
+// and the reason given was that the rule belongs in the code).  The tiers that
+// can evaluate it ask it; the tiers that cannot say so and are named below.
+//
+// WHAT THE LAW READS, AND WHAT IT NEVER READS.  It reads the state and the
+// proposed continuation, and nothing else: no mechanism, no store, no context,
+// no producer.  Its whole purpose is that a product may be consumed by ANY
+// transition the law admits, so that composition is the next transition of the
+// same state rather than an operation with its own dispatch.
+//
+// THE TWO WITNESSES ARE THE LAYER'S.  `contains` (does the transition's
+// structure hold the product?  a node in its tree, or one contiguous byte run)
+// and `moves` (does it reach structure this derivation has not consumed?) are
+// resolved by the layer that knows the structure, and handed in.  The law never
+// re-derives them, and never probes the store to ask: a predicate that would
+// scan the store for every candidate would raise the cost of a step, which is
+// why `traverse.ts`'s own admission predicate is LENT to the chart rather than
+// called through it.
+//
+// THE UNIT: product, accounted, remainder, cost, and the two declarations a
+// producer makes about its own result (`fixed`, `used`).  No identity field
+// (the product is content-addressed, so its identity is `resolve(product)` — a
+// pure function, and a cache is not a field); no structure field (that is what
+// identity is computed over); no frontier field (a continuation is computed by
+// the layer that can offer one); no producer field (docs/architecture's own
+// contract: `provenance` is observability and nothing compares it); and no
+// count of any kind — no depth, hop, visited, once or cap.
+//
+// FIVE QUESTIONS, FIVE OWNERS — and no two of them may be answered by one fact:
+//
+//   ENGAGEMENT   does the step touch the question's material?   `carries`: admits,
+//                                                              consumes nothing
+//   PROGRESS     does it reach structure not yet consumed?      `reaches`: admits
+//                                                              AND consumes what the
+//                                                              step's window carries
+//   ACCOUNTING   what does the step price?                      the span, into
+//                                                              `accounted`
+//   CLOSURE      is the question's material all accounted for?  `closed` — the law
+//   TERMINATION  why does the walk stop at all?                 the LAYER: its offer
+//                                                              ends, or the law refuses
+//                                                              one; never a depth
+//   CYCLES       why is a loop not a walk?                      the LAYER's consumed
+//                                                              set; the law only sees
+//                                                              that a cycle never
+//                                                              closes it (test/138.1)
+//
+// A step can progress without closing the derivation; a derivation can be closed
+// with no further transition (the grounding built it closed); and neither of those
+// is termination.
+//
+// THE REMAINDER TRAVELS UNCHANGED, and this was measured, not assumed: letting
+// `advance` drain the witness made a step that engaged the gap CLOSE the
+// derivation, the next step was admitted unconstrained, and test/110's
+// three-link chain drifted one hop past its satisfying answer.  A step ENGAGES
+// the question's leftover; it does not consume it.  Termination is therefore not
+// the law's: it is the walker's cycle protection over a finite graph.
+//
+// TWO LIMITS ARE PROVED AND LEFT OUT (test/136 pins both, with the measurements):
+//   1. the CHART cannot evaluate accounting — its interface has no parameter for
+//      it, and carrying it per chart item was measured and rejected.  The chart
+//      evaluates the same law read off an item: identity is the item's `key`,
+//      continuation is the rule's existence, progress is the frontier advancing,
+//      closure is the goal test, and `fix` is `fixed`.
+//   2. closure by the QUERY'S POSITION in the graph is not a term of the unit:
+//      `reason`'s echo guards stop a derivation although the remainder is not
+//      empty, and recall's reverse-recall tiers close it with an empty
+//      accounting.  That is a fact about the asker's material in the store,
+//      available only to the layer holding it — recorded as a limit, not patched
+//      into the unit as a foreign key.
+//
+// LAYERING: this module imports `../bytes.js` only.  It sits BELOW
+// `graph-search.ts`, `match.ts`, `rationale.ts` and `pipeline.ts`, so each may
+// ask it and none may be asked by it.  The span algebra lives here too: it is
+// the law's vocabulary — gap arithmetic over the asker's bytes — and not the
+// tracer's, which is why it moved out of `rationale.ts`.
+import { indexOf } from "../bytes.js";
+// ── The span algebra: the law's vocabulary ──────────────────────────────────
+/** The BYTE COUNT of a span list — what the currency calls `unaccounted` in
+ *  `weight = moves + PASS·unaccounted`.  ONE definition: this was four copies of
+ *  the same `reduce` before the architecture audit collapsed them. */
+export function unaccountedBytes(spans) {
+    let total = 0;
+    for (const [a, b] of spans)
+        total += b - a;
+    return total;
+}
+/** The `[start, end)` gaps of `[0, queryLen)` NOT covered by `accounted` — the
+ *  union-of-spans reading the ladder prices at PASS per byte, and the raw
+ *  material every closure decision measures.  Clipped to the question, sorted
+ *  and merged, so two overlapping spans account for their union once. */
+export function unexplainedSpans(queryLen, accounted) {
+    const sorted = accounted
+        .map(([s, e]) => [Math.max(0, s), Math.min(queryLen, e)])
+        .filter(([s, e]) => e > s)
+        .sort((a, b) => a[0] - b[0]);
+    const gaps = [];
+    let reach = 0;
+    for (const [s, e] of sorted) {
+        if (s > reach)
+            gaps.push([reach, s]);
+        if (e > reach)
+            reach = e;
+    }
+    if (reach < queryLen)
+        gaps.push([reach, queryLen]);
+    return gaps;
+}
+/** THE REMAINDER: what no step has accounted for, with every span below one
+ *  river-fold quantum dropped.  `W` is the mind's own line between bridging
+ *  punctuation and a substantive phrase — the same floor `liftedScaffolding`
+ *  and the honesty-density bar use — so a remainder under it licenses nothing
+ *  and blocks nothing.  This is the law's measure. */
+export function remainderOf(queryLen, explained, W) {
+    return unexplainedSpans(queryLen, explained).filter(([a, b]) => b - a >= W);
+}
+/** The window of `span` that `product` holds, or null: the ONE reading of
+ *  coverage — used by {@link carries}, by the move branch, and by the GROUNDING
+ *  when it decides what its answer has actually paid for. */
+export function windowOf(span, product, query, W) {
+    const [a, b] = span;
+    for (let i = a; i + W <= b; i++) {
+        if (indexOf(product, query.subarray(i, i + W), 0) >= 0)
+            return [i, i + W];
+    }
+    return null;
+}
+/** PROGRESS, by coverage: the first member of `remainder` that `product` carries
+ *  a whole quantum of, or null when it carries none.  The window is taken from
+ *  `query`, the asker's own bytes, so the test is "this product restates a
+ *  quantum of what was left unaccounted", never a similarity score.
+ *
+ *  One witness per step, deterministically the FIRST in remainder order: the
+ *  measure stays a single member of a finite list, which is what makes the walk
+ *  reviewable — and, because the remainder is not drained, it is the walker's
+ *  cycle protection (not this) that terminates a chain. */
+export function carries(remainder, product, query, W) {
+    for (const span of remainder) {
+        const window = windowOf(span, product, query, W);
+        if (window !== null)
+            return [{ span, window }];
+    }
+    return null;
+}
+// ── The restatement reading ─────────────────────────────────────────────────
+/** Whether `bytes` RESTATES the question — says nothing the asker did not just
+ *  say — and is therefore not an answer.  This is a closure condition: a
+ *  derivation whose product is already the question has added nothing, and the
+ *  engine asks it in five places.  ONE definition, asked everywhere, with the
+ *  DIFFERENCES between those places supplied as WITNESSES by the caller — never
+ *  as a mechanism or a producer.  If this function ever needs to know who
+ *  produced the bytes to decide, the right conclusion is that a witness is
+ *  missing, not that it should dispatch.
+ *
+ *  `floor` is one river-fold quantum: below it, byte overlap is chance, not
+ *  evidence — the same line `identityBar`, the bridge's `attestedQ` and
+ *  recognition's site floor all draw.  `0` disables the floor, which is the
+ *  reading the callers that ask before any structure exists use.
+ *
+ *  THE THREE READINGS the callers need, and why each is a witness rather than a
+ *  branch here:
+ *
+ *   • `proper` — a PROPER part of the question (strictly shorter).  This is the
+ *     reading every tier that rejects a fragment uses.
+ *   • `whole` — the EQUALITY reading: only "the answer IS the question" counts,
+ *     because the caller has already handled a proper fragment elsewhere (a
+ *     recall tier's own subspan tests).
+ *   • `equate` — the response's own notion of "the same text" (whatever
+ *     `src/canon.ts` equates: case, width, whitespace).  A caller that has one
+ *     passes it; a caller that does not gets the byte-exact reading.  It is the
+ *     same fallback `resolve` already makes when an exact lookup misses.
+ *
+ *  The LITERAL EXEMPTION is deliberately NOT here: whether a span is the site's
+ *  own bytes at its own position is the CALLER's knowledge, and a caller states
+ *  it by not asking (see `segRestatesQuery` in types.ts, which returns false for
+ *  a literal span before reaching this). */
+export function restates(query, bytes, floor = 0, witnesses = {}) {
+    const equate = witnesses.equate ?? null;
+    const from = witnesses.from ?? 0;
+    const q = equate === null ? query : equate(query);
+    const b = equate === null ? bytes : equate(bytes);
+    if (b.length > q.length || b.length < floor)
+        return false;
+    if (witnesses.whole === true) {
+        return b.length === q.length && indexOf(q, b, from) >= 0;
+    }
+    if (witnesses.proper === true && b.length === q.length)
+        return false;
+    return indexOf(q, b, from) >= 0;
+}
+/** Whether the query span `[from, to)` lies inside a COMPLETED ASSISTANT TURN —
+ *  material the engine has already produced, so it is context rather than
+ *  something the asker is asserting.  Recognition and attention still see the
+ *  full transcript; what excludes these spans is the closure reading "this was
+ *  already answered", and it is a closure reading rather than a budget: a window
+ *  inside a prior reply is not a fresh constraint.
+ *
+ *  ONE definition of it.  `cursor` is the CALLER's own progress through `turns`
+ *  (they are ascending and each caller scans its candidates in ascending order),
+ *  so the amortised search is preserved exactly and a caller passes the same
+ *  holder for a whole scan: extracting the reading must not cost the scan. */
+export function insideAnsweredTurn(turns, cursor, from, to) {
+    while (cursor.at < turns.length && turns[cursor.at][1] <= from)
+        cursor.at++;
+    const turn = turns[cursor.at];
+    return turn !== undefined && turn[0] <= from && to <= turn[1];
+}
+/** CLOSED — nothing of the asker's material is left unaccounted. */
+export function closed(d) {
+    return d.remainder.length === 0;
+}
+/** THE LAW, evaluated once.
+ *
+ *  Returns the spans the transition accounts for — the witness that lets it be
+ *  taken — or `null` when it is inadmissible.  Evaluating it once and advancing
+ *  the state with {@link advance} is the whole of a transition; asking twice for
+ *  the same pair would repeat the scan, which this module must not make anyone
+ *  do.
+ *
+ *      ¬FIXED  ∧  CONTAINS  ∧  ( CLOSED ∨ CARRIES ∨ MOVES )
+ *
+ *  Cost is not a term: it is the lattice order the market minimises over, and
+ *  neither is any budget — a cap decides with a number of work, this decides
+ *  with the remainder. */
+export function admissible(d, t, query, W) {
+    if (d.fixed)
+        return null;
+    if (!t.contains)
+        return null;
+    if (closed(d))
+        return (t.explains ?? []).map((span) => ({ span }));
+    // MOVES BEFORE CARRIES, and that order is not arbitrary: a transition that
+    // DECLARES it moves (the walker's forward-absorb, and a pivot whose producing
+    // mechanism declared the anchors it speaks for) is admitted on that ground
+    // alone and records no coverage witness — which is exactly how the code it
+    // replaces behaved, where the brake was skipped whenever the producer owned
+    // the shape of its answer.  Reading coverage first would attribute to such a
+    // step material it was never asked to account for.
+    if (t.reaches) {
+        // A MOVE IS ITS OWN GROUND — it needs no question material to be admitted.
+        // What it CARRIES is nonetheless the one thing the question's remainder may
+        // be consumed by, and it is read here by the SAME reading the carries
+        // admission uses: one definition, so the law cannot be told a span it does
+        // not hold.  A move that carries nothing consumes nothing.
+        const carried = carries(d.remainder, t.product, query, W);
+        if (carried !== null)
+            return carried;
+        return (t.explains ?? []).map((span) => ({ span }));
+    }
+    return carries(d.remainder, t.product, query, W);
+}
+/** ADVANCE — the transition itself: the state that results from consuming `t`
+ *  with the witness {@link admissible} returned.  The product moves, the
+ *  accounting accumulates what the step engaged, and the cost is added.
+ *
+ *  THE REMAINDER DRAINS ONLY ON A DECLARED MOVE, and that is measured, not
+ *  assumed: a step admitted by CARRIES holds question material, which any
+ *  repetition also holds — draining on it let a cycle empty the remainder and
+ *  close a derivation whose product never changed.  A MOVE (structure this
+ *  derivation has not consumed) cannot be produced by repetition, so it is the
+ *  one evidence on which the question's leftover may be consumed.  The result is
+ *  no longer a supplied fixed point. */
+function drain(remainder, explains) {
+    return remainder.flatMap(([a, b]) => {
+        const cut = explains.find(([x, y]) => x >= a && y <= b);
+        if (!cut)
+            return [[a, b]];
+        const [x, y] = cut;
+        const w = y - x;
+        const out = [];
+        if (x - a >= w)
+            out.push([a, x]);
+        if (b - y >= w)
+            out.push([y, b]);
+        return out;
+    });
+}
+export function advance(d, t, explains) {
+    const spans = explains.map((w) => w.span);
+    const carried = t.reaches === true
+        ? explains.flatMap((w) => (w.window ? [w.window] : []))
+        : [];
+    return {
+        product: t.product,
+        accounted: spans.length === 0 ? d.accounted : [...d.accounted, ...spans],
+        remainder: carried.length === 0 ? d.remainder : drain(d.remainder, carried),
+        cost: d.cost + t.cost,
+        used: d.used,
+    };
+}
+/** THE CLOSURE — the walk of {@link advance} over the continuations `offer`
+ *  proposes, run until the layer has nothing further to offer or the law refuses
+ *  the one it offered.
+ *
+ *  ADMISSION is entirely the law's; TERMINATION is the layer's, and deliberately
+ *  so.  The remainder does not descend (draining it was implemented and refuted
+ *  — see the module note), so a walk cannot run forever only because the layer
+ *  offering continuations keeps its own cycle protection over a finite graph.
+ *  Nothing here counts steps, and nothing here decides admissibility. */
+export async function closure(d, query, W, offer, 
+/** Called for each step the law admits, with the state before and after. */
+onTaken, 
+/** Called when the law refused the continuation the layer offered. */
+onRefused) {
+    for (;;) {
+        const t = await offer(d);
+        if (t === null)
+            return d;
+        const explains = admissible(d, t, query, W);
+        if (explains === null) {
+            onRefused?.(d);
+            return d;
+        }
+        const next = advance(d, t, explains);
+        onTaken?.(d, next);
+        d = next;
+    }
+}

package/dist/src/mind/graph-search.d.ts

@@ -186,7 +186,7 @@ export declare class GraphSearch {
      *  Any learnt connector between two rewrites is spliced IN by the in-search
      *  connector rule (see {@link outRules}), so the returned spans already carry
      *  it — there is no post-pass. */
-    cover(queryLen: number, sites: ReadonlyArray<Site>, conceptTarget: ReadonlyMap<number, number>, leaves: ReadonlyArray<Leaf>, splits: ReadonlySet<number>, starts: ReadonlySet<number>, substitutions?: ReadonlyMap<number, Uint8Array>, connectors?: ReadonlyMap<string, Uint8Array>, computedResults?: ReadonlyArray<ComputedResult>, 
+    cover(queryLen: number, sites: ReadonlyArray<Site>, conceptTarget: ReadonlyMap<number, number>, leaves: ReadonlyArray<Leaf>, splits: ReadonlySet<number>, substitutions?: ReadonlyMap<number, Uint8Array>, connectors?: ReadonlyMap<string, Uint8Array>, computedResults?: ReadonlyArray<ComputedResult>, 
     /** When given, receives each solved span's lightest derivation — the full
      *  adapted A*LD proof tree as classified {@link DerivationStep}s — for the
      *  TOP cover AND every nested completion the sink is threaded into (see
@@ -196,6 +196,7 @@ export declare class GraphSearch {
     onDerivation?: (steps: DerivationStep[]) => void): {
         segs: Seg[];
         cost: number;
+        moves: number;
     } | null;
     /** Build the deduction system for one span and return its lightest cover's
      *  chosen spans — the SINGLE routine the query and every produced composite

package/dist/src/mind/graph-search.js

@@ -51,6 +51,29 @@ function pushInto(mp, k, v) {
 /** 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) {
+    let bytes = 0;
+    let node = 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) {
     const segs = [];
     let node = derivation;
@@ -229,7 +252,7 @@ export class GraphSearch {
      *  Any learnt connector between two rewrites is spliced IN by the in-search
      *  connector rule (see {@link outRules}), so the returned spans already carry
      *  it — there is no post-pass. */
-    cover(queryLen, sites, conceptTarget, leaves, splits, starts, substitutions, connectors, computedResults, 
+    cover(queryLen, sites, conceptTarget, leaves, splits, substitutions, connectors, computedResults, 
     /** When given, receives each solved span's lightest derivation — the full
      *  adapted A*LD proof tree as classified {@link DerivationStep}s — for the
      *  TOP cover AND every nested completion the sink is threaded into (see
@@ -246,12 +269,7 @@ export class GraphSearch {
         // so the recompositions a produced form needs are reported in the same
         // trace instead of vanishing after the first layer.
         this.derivationSink = onDerivation;
-        const solved = this.solve(queryLen, {
-            sites,
-            leaves,
-            splits,
-            starts,
-        }, conceptTarget, substitutions, connectors, computedResults, onDerivation);
+        const solved = this.solve(queryLen, { sites, leaves, splits }, conceptTarget, substitutions, connectors, computedResults, onDerivation);
         // Deepening runs HERE, once, on the derivation the top cover CHOSE — never
         // inside the nested solve a completion runs.  Nesting the deepening is what
         // made per-query cost track how densely the corpus interconnects the forms
@@ -259,9 +277,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
@@ -277,7 +297,7 @@ export class GraphSearch {
      *  decomposes, two recomposes, any mix — and stops only when it reaches a node
      *  that leads nowhere new, never at an arbitrary count. */
     solve(spanLen, recognition, conceptTarget, substitutions, connectors, computedResults, onDerivation) {
-        const system = this.buildSearch(spanLen, recognition.sites, conceptTarget, recognition.leaves, recognition.splits, recognition.starts, substitutions, connectors, computedResults);
+        const system = this.buildSearch(spanLen, recognition.sites, conceptTarget, recognition.leaves, recognition.splits, substitutions, connectors, computedResults);
         // Search-effort accounting (src/meter.ts): the chart's pops/pushes are
         // the cover's real cost, and a heuristic that stops being admissible
         // shows up as a pop count that explodes while the answer stays the same.
@@ -296,7 +316,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;
     }
     /** Re-cover the CHOSEN fixpoint spans, in place.
@@ -330,7 +354,7 @@ export class GraphSearch {
      *  adjacent fragments toward a known leaf (findLeaf) or branch (findBranch);
      *  a completion fused with its neighbour may spell a deeper learned form the
      *  flat probes can't name, recovered canonically by {@link resolve}. */
-    buildSearch(queryLen, sites, conceptTarget, leaves, splits, starts, substitutions, connectors, computedResults) {
+    buildSearch(queryLen, sites, conceptTarget, leaves, splits, substitutions, connectors, computedResults) {
         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 — see {@link hubBound} below for why this module
@@ -473,7 +497,6 @@ export class GraphSearch {
                 return this.outRules(it, {
                     W,
                     splits,
-                    starts,
                     atomsAreHubs,
                     coversDone,
                     outsByStart,
@@ -914,7 +937,6 @@ export class GraphSearch {
                 sites: [...recognised, ...structural],
                 leaves: rec.leaves,
                 splits: rec.splits,
-                starts: rec.starts,
             }, new Map(), undefined, undefined, undefined, this.derivationSink);
             const answer = solved && concatBytes(solved.segs.map((s) => s.bytes));
             // ACCEPT, then CONTINUE THE CHAIN — but only along an accepted

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

@@ -294,6 +294,8 @@ export declare function haloSiblings(ctx: MindContext, id: number, halo?: Vec |
  *  inside the composed phrase.  Returns null when the corpus provides no
  *  distributional evidence for the span. */
 export declare function spanHalo(ctx: MindContext, bytes: Uint8Array, from?: number, to?: number): Vec | 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/dist/src/mind/match.js

@@ -814,6 +814,8 @@ export function spanHalo(ctx, bytes, from = 0, to = bytes.length) {
     }
     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/dist/src/mind/mechanisms/alu.js

@@ -7,7 +7,6 @@
 // (`evalComputation`) are emitted inside its `parse()`.  A user extension
 // joins the same way — see MindOptions.mechanismFactories.
 import { STEP } from "../graph-search.js";
-import { unexplainedLabel } from "../rationale.js";
 /** Wrap the ALU as a {@link PipelineMechanism}. */
 export function aluToMechanism(alu) {
     return {
@@ -31,7 +30,6 @@ export function aluToMechanism(alu) {
                 bytes: u.bytes,
                 accounted: [[u.i, u.j]],
                 moves: STEP,
-                unexplained: unexplainedLabel(query, [[u.i, u.j]]),
             }));
         },
     };

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

@@ -9,10 +9,6 @@ export interface CastResult {
     used: ReadonlySet<number>;
     accounted: Array<[number, number]>;
     moves: number;
-    /** 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:
  *  the REVERSE context (what leads to it) when a predecessor genuinely
@@ -48,7 +44,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 —

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 });
         }
@@ -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