@hviana/sema 0.8.2 → 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,
@@ -868,6 +891,8 @@ 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
@@ -912,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
@@ -1100,20 +1124,37 @@ export class GraphSearch {
             // duplicate read and a branch that could never be taken.
             let next = 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* () {
+                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) ??

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

@@ -200,7 +200,7 @@ export declare function frameSlots(ctx: MindContext, query: Uint8Array, cand: Ui
  *  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
@@ -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

@@ -546,7 +546,7 @@ export function frameSlots(ctx, query, cand, id) {
  *  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
@@ -631,8 +631,10 @@ export function substituteAll(hay, pairs) {
     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 = [];
     let i = 0;
@@ -812,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 —