@hviana/sema 0.8.2 → 0.8.3

package/dist/src/mind/reasoning.js

@@ -6,8 +6,9 @@ import { rItem, rNode } from "./trace.js";
 import { bytesEqual, indexOf } from "../bytes.js";
 import { resolve } from "./primitives.js";
 import { hubBound } from "./traverse.js";
-import { follow, haloSiblings, project } from "./match.js";
+import { containsSpan, follow, haloSiblings, project } from "./match.js";
 import { joinWithBridge, pivotInto } from "./resonance.js";
+import { unaccountedBytes } from "./rationale.js";
 /** Whether `bytes` is a proper byte-subspan of `query` — already present in
  *  the question, so voicing it back only restates part of what was asked,
  *  never answers it.  The exact guard recallByResonance already applies to
@@ -21,15 +22,6 @@ import { joinWithBridge, pivotInto } from "./resonance.js";
 export function restatesQuery(query, bytes) {
     return bytes.length < query.length && indexOf(query, bytes, 0) >= 0;
 }
-/** Extend a grounded answer forward across facts (multi-hop reasoning).
- *  Pivots on the longest unconsumed learnt context each answer contains,
- *  then follows the pivot's continuation to the next fact.  Repeats up
- *  to `cfg.recallQueryK` hops.  `preConsumed` carries node ids already
- *  spoken for by the grounding stage (cover/extract/CAST).  `voiced` carries
- *  the BYTES of the anchors a mechanism declared it voiced (its `used` set),
- *  when it declared one — see the pivot's own containment rule.  `pre` is the
- *  response's shared pre-computation — the post-grounding stages read the
- *  same container the mechanisms did. */
 export async function reason(ctx, query, answer, preConsumed, pre, voiced = [], 
 /** The query material the GROUNDING left uncovered — the cost ladder's own
  *  `unaccounted` spans.  Only the reasoner's OWN extensions are judged
@@ -41,8 +33,9 @@ uncovered = []) {
     // back.  The grounded answer alone is the honest read-out.  Deliberately a
     // broad structural gate; pinned by test/31-audit.
     const qId = pre.queryResolved;
-    if (qId !== null && ctx.store.prevCount(qId) > 0)
-        return answer;
+    if (qId !== null && ctx.store.prevCount(qId) > 0) {
+        return { bytes: answer, carried: [], steps: 0 };
+    }
     // Consume a node and its neighbours for pivot-cycle prevention — CAPPED at
     // the hub bound, via the store's LIMITed edge reads: a common continuation's
     // reverse fan-in (and a hub context's forward fan-out) is corpus-sized, and
@@ -99,7 +92,7 @@ uncovered = []) {
         ? null
         : ctx.store.prevFirst(groundedId, bound);
     if (qId !== null && groundedPrev !== null && groundedPrev.includes(qId)) {
-        return answer;
+        return { bytes: answer, carried: [], steps: 0 };
     }
     const consumed = new Set();
     /** `prev` lets a caller hand in an already-read reverse-edge list — hop 0
@@ -147,7 +140,27 @@ uncovered = []) {
     const qv = pre.guide; // the response-wide guide IS the query's gist
     let t;
     const startedFrom = answer;
-    for (let hop = 0; hop < ctx.cfg.recallQueryK; hop++) {
+    // INSTRUMENTATION ONLY — the two facts the extension's own decision already
+    // used and threw away: the spans of uncovered material each step was
+    // JUSTIFIED by (the gate below computes which span carries it and kept only a
+    // boolean), and how many steps were taken.  Nothing here decides anything:
+    // both are read after the loop, to bump counters and to let the caller compare
+    // the extension's cost against what it explains, in the ladder's own currency.
+    const carried = [];
+    let steps = 0;
+    // NO ALLOWANCE: THE CHAIN ENDS WHEN IT STOPS.  Every exit below is the law —
+    // no pivot, no forward step, no question material carried — and the walk is
+    // bounded by the material and the graph rather than by a count: each taken
+    // step must carry a W-window of the uncovered material (finite), and
+    // `consumed` refuses to revisit a node.  `recallQueryK` no longer bounds the
+    // reasoner here; it keeps its other roles (the bridge's candidate reads, the
+    // pivot's probe budget, the resonance limits).
+    //
+    // Measured before removing it: test/89 — the corpus-cost guard, the heaviest
+    // case in the suite — is green and no slower without the allowance (27 s
+    // against 30 s); and raising it from 12 to 200 changed neither the answer nor
+    // `pivotSteps` on the chain fixtures.
+    for (let hop = 0;; hop++) {
         // Hop 0's `cur` IS `answer`, so the guard above already resolved it and
         // read its reverse edges — reuse both rather than repeat them.
         const curId = hop === 0 ? groundedId : resolve(ctx, cur);
@@ -170,6 +183,7 @@ uncovered = []) {
                 ]);
                 ctx.trace?.step("absorbForward", [rItem(cur, "answer", curId)], [rItem(fwd, "answer", resolve(ctx, fwd) ?? undefined)], "the answer is itself a learnt fact — follow its continuation to the fixpoint");
                 cur = fwd;
+                steps++;
                 continue;
             }
         }
@@ -205,14 +219,19 @@ uncovered = []) {
         if (!producerOwnsShape && uncovered.length > 0) {
             const W = ctx.space.maxGroup;
             let progress = false;
+            let justified;
             for (const [a, b] of uncovered) {
                 for (let i = a; i + W <= b && !progress; i++) {
-                    if (indexOf(fc, query.subarray(i, i + W), 0) >= 0)
+                    if (indexOf(fc, query.subarray(i, i + W), 0) >= 0) {
                         progress = true;
+                        justified = [a, b];
+                    }
                 }
                 if (progress)
                     break;
             }
+            if (progress && justified !== undefined)
+                carried.push(justified);
             if (!progress) {
                 // THE BRAKE, MADE VISIBLE.  The reasoner declines a step that carries
                 // none of the material the grounding left uncovered — the drift the
@@ -223,7 +242,25 @@ uncovered = []) {
                 // the check disabled, test/110 and test/116 fail — so this brake is the
                 // only thing keeping the extension honest until the pivot reports its
                 // own accounted spans and the ladder can judge it instead.
-                const left = uncovered.reduce((n, [a, b]) => n + (b - a), 0);
+                //
+                // THE PROMISE IS NOW KEPT, AND THE BRAKE TURNS OUT TO BE THE LADDER'S
+                // OWN CONSEQUENCE.  The extension reports what it carried (`carried`,
+                // the span each step was justified by) and what it cost (`steps`), both
+                // counted in the meter (`reasonCarriedBytes`, `reasonSteps`), so the
+                // ladder CAN judge it: it accepts while
+                //
+                //     steps · STEP  <  PASS · carried
+                //
+                // and this brake accepts whenever the step carries a `W`-window, i.e.
+                // whenever `carried ≥ W ≥ 1`.  With `PASS/STEP = 1000` the two therefore
+                // agree on every extension with `steps ≤ 1000 · carried` — and every
+                // extension this repository produces takes 0 or 1 steps (measured on
+                // chains of 3, 8, 20 and 40 links).  Above that bound the ladder would
+                // refuse what this brake accepts, which is the corner named in the
+                // closure report's limits: a chain of thousands of links explaining a
+                // handful of bytes.  No guard is added for it — a limit without a
+                // derivation is exactly what the brake must not become.
+                const left = unaccountedBytes(uncovered);
                 ctx.trace?.step("pivotRefused", [rItem(cur, "answer"), rItem(query, "query")], uncovered.map(([a, b]) => rItem(query.subarray(a, b), "uncovered")), `the step carries none of the question material the grounding left ` +
                     `uncovered (${left} byte(s) in ${uncovered.length} span(s)) — refused`);
                 break;
@@ -234,9 +271,23 @@ uncovered = []) {
         t ??= ctx.trace?.enter("reason", [rItem(startedFrom, "grounded")]);
         ctx.trace?.step("pivotStep", [rItem(cur, "answer"), rNode(ctx, pivot, "pivot")], [rItem(fc, "answer", resolve(ctx, fc) ?? undefined)], "pivot on the shared span this answer contains, then step forward across that fact");
         cur = fc;
+        steps++;
+    }
+    // INSTRUMENTATION ONLY — the extension's two facts, untraced (meter.ts
+    // contract 1: a counter never reaches a decision).  They are what a caller
+    // needs to PRICE the extension instead of taking it unconditionally: the work
+    // it did (`steps · STEP`) and the uncovered material it carried.
+    if (ctx.meter) {
+        ctx.meter.reasonSteps += steps;
+        ctx.meter.reasonCarriedBytes += unaccountedBytes(carried);
     }
-    t?.done([rItem(cur, "answer", resolve(ctx, cur) ?? undefined)], "the multi-hop chain's fixpoint");
-    return cur;
+    t?.done([rItem(cur, "answer", resolve(ctx, cur) ?? undefined)], 
+    // A FIXPOINT: no further step was possible.  This note used to also cover an
+    // exhausted hop allowance — a different fact, and the reason F1 added a
+    // counter for it.  The allowance is gone, so the only way out of the loop is
+    // a refusal, and the note is true again by construction.
+    "the multi-hop chain's fixpoint");
+    return { bytes: cur, carried, steps };
 }
 /** Fuse independent points of attention into one answer (multi-topic).
  *  When the consensus climb finds more than one dominant point, each
@@ -405,8 +456,9 @@ primarySpans = []) {
         out = await joinWithBridge(ctx, out, pieces[i].bytes);
     }
     t?.done([rItem(out, "answer", resolve(ctx, out) ?? undefined)], `fused ${pieces.length} independent points of attention into one answer`);
+    // THE FACT IS THE FUSED ANSWER, not the call: every early return above hands
+    // back `primary` untouched.  Untraced on purpose (meter.ts contract 1).
+    if (ctx.meter)
+        ctx.meter.fuseRuns++;
     return out;
 }
-// (resonance.js is already a static dependency above — `bridge` — so the old
-// dynamic import of pivotInto guarded against a cycle that does not exist.)
-import { containsSpan } from "./match.js";

package/dist/src/mind/recognition.js

@@ -519,8 +519,11 @@ function recogniseImpl(ctx, bytes) {
                 if (end - start < W)
                     return false;
                 if (flatProbe(start, end) === null) {
-                    if (!canonBudget)
+                    if (!canonBudget) {
+                        if (ctx.meter)
+                            ctx.meter.canonProbesDenied++;
                         return false;
+                    }
                     if (!canonAdmits(start, end))
                         return false;
                 }
@@ -543,13 +546,6 @@ function recogniseImpl(ctx, bytes) {
             // endpoints in order and running out partway along the query.  A form
             // longer than that is out of this tier's reach — but so is a form the
             // chain cannot span, and that is exactly the trade the budget prices.
-            // The factor is chainReach(W), the same W² scale the chain already
-            // trusts; no new constant.
-            // The factor is chainReach(W) — the same W² scale the chain itself
-            // trusts — so the cap is derived from the fold's geometry, never tuned.
-            // (It was briefly an environment variable while the cost was being
-            // measured; an env-read here would make inference non-reproducible,
-            // which the determinism contract forbids outright.)
             // The factor is chainReach(W) — the same W² scale the chain itself
             // trusts — so the cap is derived from the fold's geometry, never tuned.
             // (It was briefly an environment variable while the cost was being

package/dist/src/mind/resonance.js

@@ -249,7 +249,14 @@ export async function joinWithBridge(ctx, left, right) {
  *  overlap, so C3's genuine further hop — "Mona Lisa", a term inside the seat
  *  sentence but part of NEITHER analog — still fires. */
 export async function pivotInto(ctx, answer, consumed, voiced = []) {
-    const k = ctx.cfg.recallQueryK;
+    // The pivot's OWN shortlist capacity — not `recallQueryK`: they are different
+    // quantities (a mechanical sweep's probe budget vs the bridge's candidate-read
+    // allowance), and one number serving both means tightening either silently
+    // starves the other.  The reason is the duplication, NOT a measured strangle:
+    // an earlier version of this comment claimed "at recallQueryK 1 the pivot finds
+    // no pivot", and that was probed and is FALSE on test/23's fixture — the
+    // strangle is fixture-specific, so it is not the evidence for this split.
+    const k = ctx.cfg.pivotProbeK;
     // ONE perception of the answer, shared by the probe budget and the walk —
     // this used to fold the same bytes twice, back to back, on every hop.
     const tree = perceive(ctx, answer);
@@ -288,6 +295,18 @@ export async function pivotInto(ctx, answer, consumed, voiced = []) {
         for (const c of n.kids)
             queue.push(c); // breadth-first: larger regions first
     }
+    // The sweep's two FACTS, untraced (meter.ts contract 1: a counter never
+    // reaches a decision).  `probes` is the work done; the shortfall is the
+    // capacity the cap withheld — the branches the breadth-first order never got
+    // to.  Whether that withheld anything that mattered is NOT said here: the
+    // order spends the largest regions first, and recognition below still
+    // contributes every exact containment candidate regardless of the budget.
+    if (ctx.meter) {
+        ctx.meter.pivotProbes += probes;
+        const unprobed = branchCount - probeCap;
+        if (unprobed > 0)
+            ctx.meter.pivotBranchesUnprobed += unprobed;
+    }
     // THE FULL recognition, memo-shared with every other reader of these bytes.
     // A "skip the edge trims here" variant was refuted (see recognise's own
     // note): those trims are what find a WHOLE trained form embedded at an

package/dist/src/mind/trace.js

@@ -8,6 +8,7 @@ import { decodeText } from "./rationale.js";
 export function rItem(bytes, role, node, span) {
     return {
         text: decodeText(bytes),
+        bytes,
         role,
         node: node ?? undefined,
         span,

package/dist/src/mind/traverse.js

@@ -8,6 +8,12 @@
 import { cosine } from "../vec.js";
 import { gistOf, read } from "./primitives.js";
 import { canonicalWindows, leafIdPrefix, leafIdRun } from "./canonical.js";
+// Imported at the TOP, where every other import is.  They used to sit 800 lines
+// down under a note claiming the position mattered ("before trace module is
+// loaded") — it does not: an ES module's static imports are HOISTED, so the
+// file's line order never decides load order.  The note described an intention
+// the runtime does not honour; the imports move and the claim goes.
+import { decodeText } from "./rationale.js";
 //
 // Budgeted on the same terms as the reach memo below (caches.md): these three
 // maps are cleared on every write, but a long read-only session over a large
@@ -704,8 +710,6 @@ export function chooseAmong(ctx, candidates, guide) {
         ? { id: found.item, score: found.score }
         : { id: candidates[0], score: -Infinity };
 }
-// ── Trace shim (used by chooseNext before trace module is loaded) ────────
-import { decodeText } from "./rationale.js";
 function rItemShort(ctx, id, role, score) {
     return {
         text: decodeText(read(ctx, id)),

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

@@ -35,15 +35,21 @@ export interface GraphSearchHost {
         starts: ReadonlySet<number>;
     };
     chooseNext?(node: number): number | undefined;
-    /** The boundary positions of `bytes` under the engine's ONE boundary rule
-     *  (geometry.ts's `contentBoundaries`), or undefined when the host has no
-     *  space to ask.  The join's key is an entity plus a prefix of the tail, and
-     *  the prefix that names a stored relation ENDS on one of these boundaries —
-     *  measured, 5 of 5 accepted keys over four join-firing queries, where the
-     *  byte-by-byte scan spent 153 probes for 14 boundaries.  Boundaries are
-     *  content-defined and STABLE under prefix extension, which is why a corpus
-     *  key's end is a boundary of the query's own fold of the same bytes. */
-    contentCuts?(bytes: Uint8Array): readonly number[];
+    /** The lengths `p` for which `prefix ‖ tail[0..p]` IS A STORED NODE, ascending
+     *  — the join's candidate set, in the tail's own coordinates.  Optional: a host
+     *  that cannot answer makes the join fall back to every prefix, which is exact
+     *  and complete but pays a `resolve` per offset.
+     *
+     *  WHY NOT THE FOLD'S CUTS.  A key names a relation exactly when the
+     *  concatenation is a node, and a node's end is the end of ITS OWN stream —
+     *  where the fold never emits a cut (geometry's `emit` guards `at >= n`).  So a
+     *  key can end strictly inside the tail with no boundary anywhere near it:
+     *  measured, "stockholm mayor" exists, leads on to the mayor fact, and its
+     *  boundary 6 is in neither the tail's cuts ([4,7]) nor the concatenation's.
+     *  The fold's boundaries are a SUBSET of the real ends, not a proxy for them,
+     *  and using them skipped the shortest names first — which is a semantic law,
+     *  not an optimisation (test/106, test/108 pin it). */
+    contentKeyEnds?(prefix: Uint8Array, tail: Uint8Array): readonly number[];
     /** The admission predicate — `traverse.ts`'s `leadsSomewhere`, its ONE
      *  definition: does this node bear an edge or a halo?  Optional, so a bare
      *  host (a raw Store and nothing else) still works; when present, the search
@@ -104,11 +110,28 @@ export interface Attention {
      *  strength and its place.
      *  `vote` is a sum over every region that agreed, so it grows with how many
      *  places corroborated; `peak` is what the strongest one of them said on its
-     *  own.  A consumer holding this point to consensusFloor(N) — a bar that
-     *  prices ONE region's maximally-discriminative evidence — must read `peak`,
-     *  not `vote`: six scaffolding regions summing past the floor is not the
-     *  same claim as one region clearing it. */
+     *  own.  THIS USED TO PRESCRIBE THE WRONG OPERAND.  It read: "a consumer
+     *  holding this point to consensusFloor(N) — a bar that prices ONE region's
+     *  maximally-discriminative evidence — must read `peak`, not `vote`."  The
+     *  engine reads the POOLED vote, and thresholds.md §2 derives the floor for
+     *  exactly that ("Pooled-vote significance floor": one maximally-specific
+     *  region contributes at most ln N, and ln(N)+1/2 demands corroboration
+     *  BEYOND one region).  MEASURED across 27 anchors on 6 queries: all 11
+     *  admissions cleared the floor by the sum and NONE by `peak` alone — a gate
+     *  reading `peak` would refuse every root the engine elects.  `peak` remains
+     *  what it is: the strongest SINGLE region's contribution. */
     peak: number;
+    /** The IDF-WEIGHTED sum behind this point — the quantity `consensusFloor` is
+     *  derived for, and therefore the one the floor gates must read.  It is
+     *  MODE-INDEPENDENT by construction (its per-region weight is
+     *  `mutual · idf / roots`, never the mode-dependent `wf`), so gating on it
+     *  makes an anchor's admission the same in `inverse`, `direct` and `combined`.
+     *  In `inverse` — the only mode the engine runs — it equals `vote` exactly
+     *  (measured, test/55 test 17), so nothing about today's verdicts changes.
+     *  MEASURED before this field existed: gating on `vote` DID flip a verdict,
+     *  anchor 87 of test/55's query (inverse 2.682 admitted, direct 1.468
+     *  refused, floor 2.292). */
+    idfVote: number;
     /** SCALE-INVARIANT confidence: the fraction of the query's OWN regions
      *  whose evidence this point accounts for (Σ RegionVote.absorbed among
      *  its contributors, over the query's total region count) — read PER-

package/docs/INVARIANTS.md

@@ -11,9 +11,9 @@
 | 5  | Bounded reads                        | `src/store.ts:AbstractStore:nextFirst,parentsFirst,containersSlice,hasNext,bytesPrefix` `src/mind/traverse.ts:hubBound,hubCap`        | `test/90` `test/14` | `bounded-reads.md`           |
 | 6  | Fold contract                        | `src/geometry.ts:contentLevels` `src/mind/canonical.ts:canonicalWindows,chainReach` `src/canon.ts:canonicalizer`                      | `test/59` `test/63` | `fold-contract.md`           |
 | 7  | Mechanism market                     | `src/mind/pipeline-mechanism.ts:PipelineMechanism,Precomputed` `src/mind/pipeline.ts:think,worthRunning`                              | `test/01` `test/04` | `mechanism-market.md`        |
-| 8  | Two commonality measures             | `src/mind/traverse.ts:reachOf,dominates,corpusN` (global) `src/mind/match.ts:depth[],MIN_WEAVE` (weave-local)                         | `test/17` `test/34` | `commonality.md`             |
+| 8  | Two commonality measures             | `src/mind/traverse.ts:reachOf,dominates,corpusN` (global) `cast.ts:depth[],MIN_WEAVE` (weave-local)                                   | `test/17` `test/34` | `commonality.md`             |
 | 9  | Memoization idempotence              | `src/mind/pipeline-mechanism.ts:Precomputed` `src/mind/mind.ts:beginResponse,endResponse,_resolvedSubtrees`                           | `test/42`           | `memoization.md`             |
 | 10 | Caches as budgets                    | `src/store.ts:BoundedMap` `src/config.ts:StoreConfig:bytesCacheMax,recCacheBytes,haloCacheBytes`                                      | `test/96` `test/91` | `caches.md`                  |
 | 11 | Honest degradation                   | `src/mind/pipeline.ts:weight=moves+PASS*unaccounted` `src/store.ts:BoundedMap:miss→re-derive`                                         | `test/28` `test/84` | `store.md`+`caches.md`       |
 | 12 | Meter contracts                      | `src/meter.ts:Meter,PhaseCost,time` `src/mind/pipeline-mechanism.ts:Precomputed.shared`                                               | `test/55`           | `meter.md`                   |
-| 13 | Saturation                           | `src/mind/traverse.ts:edgeAncestors:SaturationReason` `src/mind/junction.ts:junctionContainersFrom` `src/mind/resonance.ts:pivotInto` | `test/27` `test/16` | `saturation.md`              |
+| 13 | Saturation                           | `traverse.ts:edgeAncestors,types.ts:SaturationReason` `src/mind/junction.ts:junctionContainersFrom` `src/mind/resonance.ts:pivotInto` | `test/27` `test/16` | `saturation.md`              |

package/docs/architecture/bounded-reads.md

@@ -18,7 +18,7 @@ boundFor(n) = ceil(sqrt(max(2, n)))               // ctx-free reading
 ```
 
 Defined once in `mind/traverse.ts` (`corpusN`, `hubBound`, `hubCap`,
-`boundFor`). Every consumer imports them; never spell `Math.sqrt` inline.
+`boundFor`). Every consumer imports them; never re-derive them inline.
 
 ## Enforcement at the store level
 

package/docs/architecture/commonality.md

@@ -19,8 +19,8 @@ scaffolding. Powers the consensus climb, edge following, and vote pooling.
 
 ## Weave-local — `depth[]` + `MIN_WEAVE` + `dominates`
 
-_Defined in `src/mind/match.ts` (`depth[]`, `MIN_WEAVE`, `frame`) and gated in
-`src/mind/match.ts:frame`; used by CAST._
+_Defined and gated in `src/mind/mechanisms/cast.ts` (`depth[]` from the shared
+weave, `MIN_WEAVE`); used by CAST._
 
 For an alignment weave, `depth[i]` counts how many aligned structures cover byte
 `i` of the query. `MIN_WEAVE = 2` requires agreement beyond a pair (pair columns

package/docs/architecture/cost-model.md

@@ -59,8 +59,8 @@ exceeds the true remaining cost.
 ## Policy is not cost
 
 "Computation always wins" is **not** priced into the ladder (a computed result
-costs `STEP`, same as a learned edge). It is enforced by masking: `pipeline.ts`
-removes recognised sites overlapped by a `ComputedResult` so the computation is
+costs `STEP`, same as a learned edge). It is enforced by masking: `cover.ts`
+removes recognised sites overlapped by a `ComputedResult`, so the computation is
 the sole completion there. Keep policy in callers; keep the engine neutral.
 
 ## Pins

package/docs/architecture/determinism.md

@@ -20,7 +20,7 @@ flaky, the contract was broken, not the test.
 entropy root. Subsystems derive deterministically:
 
 - **Alphabet** — `Alphabet` (`src/alphabet.ts`) via `rng` (`src/vec.ts:rng`)
-  seeded as `seed ^ seedMask`; builds 16→64→256 vectors by refinement.
+  seeded as `seed ^ seedMask`; builds 16→64→256 vectors.
 - **Keyring / Space** — `Space.seats` (`src/sema.ts:Space`) via `makeKeyring`
   (`src/vec.ts:makeKeyring`) and `rng` seeded from `seed` in `Mind`
   (`src/mind/mind.ts`); `fold`/`twoEndedSeat`/`companySignature` are pure over
@@ -34,8 +34,8 @@ derived from `D`/`W`/`N`, not sampled.
 
 ## Tie-breaks are corpus-determined
 
-Every choice among equals bottoms out in a fixed ordering — insertion order or
-lowest node id. The universal no-evidence fallback is **first-inserted**:
+Every choice bottoms out in a fixed ordering — insertion order or lowest node id
+— not interchangeable (`test/34`). The fallback is **first-inserted**:
 
 - `guidedFirst` (`src/mind/traverse.ts:guidedFirst`) — guided pick via
   `chooseNext` else first-inserted edge (`nextFirst` LIMIT 1).
@@ -46,7 +46,7 @@ lowest node id. The universal no-evidence fallback is **first-inserted**:
 - `companySignature` (`src/sema.ts:companySignature`) — `rng(id ^ 0x9e3779b9)`,
   i.e. seeded by node id, not observation order.
 
-Last-inserted was once used in one place; it was a bug. Never reintroduce it.
+Never use last-inserted.
 
 ## Memoization and trace must not break identity
 
@@ -56,7 +56,7 @@ Per-response memos (`Precomputed`, `perceiveMemo`, `recogniseMemo`, `climbMemo`,
 `src/mind/primitives.ts`) are sound because asking never writes. Only
 `guidedNext`/`sharedReachMemo` are trace-bypassed;
 `perceiveMemo`/`recogniseMemo`/`climbMemo` are always consulted — `foldTree`'s
-subtree fast path skips `visit` (and thus site emission) for cached subtrees, so
+subtree fast path skips `visit` (and site emission) for cached subtrees, so
 bypassing makes `recognise` non-idempotent.
 
 ## Follow it
@@ -69,5 +69,5 @@ call `Math.random`/`Date.now` on a behavioural path.
 
 - `test/42` pins recognition idempotence under trace — traced and untraced
   `recognise` must return the same cached object and site count.
-- Determinism suites — `test/03`, `test/04`, `test/08`, `test/20` and others
-  assert same seed + same training ⇒ byte-identical answers and stores.
+- Determinism suites — `test/03`, `test/04`, `test/08`, `test/20` — assert same
+  seed + same training ⇒ byte-identical answers and stores.

package/docs/architecture/match-project.md

@@ -16,7 +16,7 @@ functions over bytes and the store — no mechanism owns a private copy.
 | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------- |
 | **Match** (locate structure)  | `locate` (exact → halo → gist ladder), `alignRuns` (literal W-gram weave), `alignGraded` (literal + halo gaps), `alignAround` / `frameSlots` (seeded frame with contracted gaps), `bestHaloMate` (in-list halo), `analogyStrength` / `sharedFrameStrength` (distributional + structural analogy) | Finds where a query sits in a learnt form.                                              |
 | **Project** (direction)       | `follow` (forward to fixpoint, first hop may `conceptHop`), `reverseContext` (reverse to context), `project` (forward else reverse), `conceptHop` (halo sibling with edge)                                                                                                                       | Moves along the store from the match — forward toward answers, reverse toward contexts. |
-| **Gate** (structural licence) | `isSpanShaped` (sparse subsequence — open reading), `carriesFillers` (substitution carriage — strict voicing licence)                                                                                                                                                                            | Decides whether the shape licences voicing.                                             |
+| **Gate** (structural licence) | `isSpanShaped` (OPEN reading — sparse subsequence), `containsSpan` (STRICT reading — contiguous run or resolved node), `skillExemplar` (anchor → context + answer), `carriesFillers` (substitution carriage — strict voicing licence)                                                            | Two readings; not interchangeable.                                                      |
 
 Mechanisms declare only `(matcher, direction, gate)`. Thresholds behind gates
 live in `src/geometry.ts` — the match layer never invents a cutoff.
@@ -52,8 +52,7 @@ The shared layer never refuses on a consumer's behalf. Reference owns its four
 gates: frame dominates the query, each slot reaches `W` on both sides, no
 insertion/deletion, fillers pairwise distinct — plus `carriesFillers` on the
 chosen pair. CAST, recall, and cover each apply their own gate over the same
-shared inventory. Moving a consumer's gate into `match.ts` would hide who is
-responsible for the refusal.
+shared inventory. Moving a gate into `match.ts` would hide who owns the refusal.
 
 ## Pins
 

package/docs/architecture/mechanism-market.md

@@ -19,6 +19,7 @@ interface MechanismResult {
   unexplained: string;
   scaffolding?: number;
   complete?: boolean;
+  used?: ReadonlySet<number>;
 }
 ```
 
@@ -30,7 +31,7 @@ interface MechanismResult {
 
 ## Decider
 
-`think` in `mind/pipeline.ts` iterates `defaultMechanisms` in list order:
+`think` iterates `defaultMechanisms` in list order:
 
 ```
 defaultMechanisms = [cover, cast, confluence, extraction, reference, recall,
@@ -39,8 +40,7 @@ defaultMechanisms = [cover, cast, confluence, extraction, reference, recall,
 
 Weight is one currency: `weight = moves + PASS · unaccountedBytes` where
 `unaccountedBytes = unexplainedSpans(query.length, accounted)`. Comparison is at
-`STEP` grade (`grade = floor(weight/STEP)`); equal grade prefers fewer
-`scaffolding` bytes, then list order.
+`STEP` grade ; equal grade prefers fewer `scaffolding` bytes, then list order.
 
 ## Four constraints
 
@@ -48,16 +48,16 @@ Weight is one currency: `weight = moves + PASS · unaccountedBytes` where
    never touches another; no mechanism asks what already decided.
 2. **Declared competence** — binary structural gates inside `floor`/`run` (query
    length, anchor shape, weave existence). Never a learned score; rationale
-   states exactly why a mechanism abstained.
+   states why a mechanism abstained.
 3. **Visible budget** — every corpus-scale loop is capped at a named constant:
    `√N` via `hubBound`/`hubCap` and `k = 2·recallQueryK` (`Precomputed.k`).
-   Enforced at the store level.
+   Enforced at the store.
 4. **Evidence travels** — every candidate carries `accounted` (query spans
    explained), `moves` (priced on `MICRO/STEP/CONCEPT/PASS`), `unexplained`
    (diagnostic label); optionally `scaffolding` (answer bytes from unrecognised
    spans — equal-grade tie-break) and `complete` (trained-form continuation
    reached via identity; post-grounding must not extend). The decider honours
-   both without knowing who set them.
+   all three without knowing who set them.
 
 ## Two disciplines
 
@@ -70,8 +70,8 @@ Weight is one currency: `weight = moves + PASS · unaccountedBytes` where
 - **Investment discipline.** `worthRunning` is passed _into_ `floor`. A floor
   that would first-touch an expensive shared analysis (`pre.attention()` climb,
   `pre.weave()`, `pre.resonance()`) checks `worthRunning(cheapestBound)` first
-  and returns the uninvested bound when it already loses. Never compute a shared
-  analysis just to discard it. `cast.ts`/`extraction.ts` are the references.
+  and returns the uninvested bound if it loses. Never compute a shared analysis
+  just to discard it. `cast.ts`/`extraction.ts` are the references.
 
 ## Accounting
 
@@ -86,8 +86,8 @@ Weight is one currency: `weight = moves + PASS · unaccountedBytes` where
   same act is charged twice (`PASS`/byte dominates).
 
 `accounted` is a cost-ladder quantity; `cover.ts` leaves masked computed spans
-out of it so `PASS`-bridged bytes are still charged. `unexplained`,
-`narrowDecision`, `thinGrounding` are observational only.
+out so `PASS`-bridged bytes are still charged. `unexplained`, `narrowDecision`,
+`thinGrounding` are observational only.
 
 ## Pins
 

package/docs/architecture/meter.md

@@ -17,11 +17,11 @@ it. Harness: `bench/profile-inference.mjs`.
    non-deterministic hints reported separately — never use them to gate
    behaviour.
 
-3. **Phases nest, they do not partition.** `think` contains every mechanism
-   phase; a mechanism's `floor` contains whatever shared analysis it
-   first-touched; `recall.run` contains `substitutionBridge`. Read a phase as
-   inclusive wall-clock — never sum phases and expect the total.
-   `CostReport.elapsedMs` is the only whole.
+3. **Phases nest, they do not partition.** Each phase is charged by the layer
+   doing the work (`recognise`, the climb's two, the bridge), and a mechanism's
+   `floor` contains whatever shared analysis it first-touched. Read a phase as
+   inclusive wall-clock; never sum phases. `CostReport.elapsedMs` is the only
+   whole.
 
 4. **Count once.** Off by default and free when off
    (`new Mind({ profile:

package/docs/architecture/store.md

@@ -36,8 +36,8 @@ root never costs a full walk.
 
 ## Gist, halo, dedup
 
-On `put*`, content dedup (`hashOf`→probe→mint) gates first. `DedupKey` caches
-short keys (`DEDUP_KEY_MAX` bypass). Near-dedup merges by `mergeThreshold(D)` on
+On `put*`, content dedup (`hashOf`→probe→mint) gates first. Short keys are
+cached (`DEDUP_KEY_MAX` bypass). Near-dedup merges by `mergeThreshold(D)` on
 unit gist cosine. Gists sit in `_pendingGist` (byte-budgeted `BoundedMap`);
 `indexSubtree` & `pourHalo` promote via `_vecContentUpsert`/`_vecHaloUpsert` in
 `batchSize` batches. Buffers flush on cadence, `commit()`, and close. Halo mass
@@ -55,7 +55,7 @@ deferred transaction.
 Every in-memory cache is a `BoundedMap` with byte accounting and eviction (`lru`
 vs `smallest` + `clock`/`reorder` recency). ANN reads
 (`resonate`/`resonateHalo`) are content-addressed (`vecKey`) and dropped on any
-index mutation; `RESonate_CACHE_MAX=4096`.
+index mutation; `RESONATE_CACHE_MAX=4096`.
 
 ## Maintenance (incremental)
 

package/docs/failures/tempting-but-wrong.md

@@ -30,8 +30,7 @@ not to do, why it fails, and what to do instead.
 - **WRONG:** Break equal-rank ties by picking the most recently inserted
   edge/node.
 - **WHY:** Tie-breaks must be corpus-determined and stable; last-inserted is
-  recency-dependent and was fixed as a bug (`AGENTS §2` Invariant 1 —
-  first-inserted fallback).
+  recency-dependent (`AGENTS §2` Invariant 1 — first-inserted fallback).
 - **CORRECT:** `guidedFirst`/`chooseNext`/`chooseAmong`: rank then
   first-inserted (lowest node id / `LIMIT 1` insertion order). Pinned by
   `test/03-recall.test.mjs` determinism suites.
@@ -55,8 +54,8 @@ not to do, why it fails, and what to do instead.
   policy is enforced by masking, not pricing (`AGENTS §2` Invariant 4 — One cost
   currency; `docs/architecture/cost-model.md` § Policy is not cost).
 - **CORRECT:** Keep `PASS` dominating; enforce precedence in the caller (e.g.
-  `pipeline.ts` masks recognised sites overlapped by `ComputedResult`). Pinned
-  by `test/04-think.test.mjs` and `test/55-cost-meter.test.mjs`.
+  `cover.ts` masks recognised sites overlapped by `ComputedResult`). Pinned by
+  `test/04-think.test.mjs` and `test/55-cost-meter.test.mjs`.
 
 ### 6. Reimplementing `locate`/`align` inside a mechanism
 

package/docs/harness/gates.md

@@ -3,7 +3,7 @@
 Four executable gates. Each: run the command, check what it guards, follow its
 §.
 
-## 1 — Correctness (all 90 suites)
+## 1 — Correctness (all suites)
 
 ```bash
 npm test
@@ -24,7 +24,7 @@ node bench/profile-inference.mjs --trace # trace is a debugging aid, not product
 ```
 
 Guards without trace: counters deterministic and diffable between runs; phases
-nest (not disjoint — `think` contains every mechanism phase); shared analyses
+nest (not disjoint — each phase is charged by its own layer); shared analyses
 charged to themselves, not to the first toucher; millisecond fields are
 non-deterministic hints only. With `--trace`, recognition idempotence still
 holds (`test/42`). `src/meter.ts`, `docs/architecture/meter.md`, §55,

package/docs/mechanisms/cast.md

@@ -12,7 +12,7 @@ schema yields its own candidate and `think`'s single weight comparison picks.
 halo-matched `pre.rec.sites`. The product is `pre.weave()` — `points[]` (each
 with graded `runs[]`) and a per-query-byte `depth[]` (how many structures cover
 that byte). CAST's single-vs-multi test is measured from those runs: a second
-point must add ≥ one perception quantum of coverage the widest point does not.
+point must add ≥ one perception quantum of coverage the widest does not.
 
 ## Gate — weave-local discriminative frame
 
@@ -76,5 +76,5 @@ redirection, or analogical comparison), not from a literal continuation.
 ## Source
 
 `src/mind/mechanisms/cast.ts` (`counterfactualTransfer`, `seatOfNode`,
-`MIN_WEAVE`), `src/mind/match.ts` (`alignGraded`, `project`, `depth`),
+`MIN_WEAVE`, `weave.depth`), `src/mind/match.ts` (`alignGraded`, `project`),
 `src/geometry.ts` (`dominates`), `src/mind/graph-search.ts` (`STEP`).

package/docs/mechanisms/cover.md

@@ -15,9 +15,8 @@ consumes them directly; any site whose bytes overlap a computed span is masked
 - `formRules` follow continuation edges (`GraphSearch.formRules`): each hop
   costs `STEP` (1). Forks across all continuations up to the hub bound;
   disambiguation is distributional, not heuristic.
-- Edge-less forms may hop via a halo sibling (`conceptHop` / `resolveConcepts`
-  in `src/mind/mechanisms/cover.ts`) at `CONCEPT` (10), borrowing a synonym's
-  continuation.
+- Edge-less forms may hop via a halo sibling (`conceptHop` / `resolveConcepts`)
+  at `CONCEPT` (10), borrowing a synonym's continuation.
 
 ## Gate — `leadsSomewhere` (`src/mind/traverse.ts`)