@hviana/sema 0.8.1 → 0.8.3

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

@@ -35,12 +35,40 @@ export interface GraphSearchHost {
         starts: ReadonlySet<number>;
     };
     chooseNext?(node: number): number | undefined;
+    /** 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
      *  uses it rather than re-probing the store, which keeps the predicate
      *  single-defined AND memoised on the response-scoped struct cache. */
     leadsSomewhere?(id: number): boolean;
+    /** Report a SEARCH REFUSAL into the rationale — the channel AGENTS §6
+     *  requires: a callback threaded through a call chain must FEED the
+     *  rationale, the way `GraphSearch`'s `onDerivation` feeds `traceDerivation`,
+     *  never a channel of its own.  Optional, so a bare host stays silent rather
+     *  than crashing. */
+    reportSearch?(name: string, parts: ReadonlyArray<Uint8Array>, note: string): void;
+    /** The CANONICAL resolver ({@link canonResolve}), optional like
+     *  {@link leadsSomewhere}.  The store's keys were written through the
+     *  canonical fold, so a fact's `Gustaf Molander` and the deposited
+     *  `gustaf molander` are the SAME node (measured inside a response: the
+     *  canonical resolver maps the surface form to the deposited node while a raw
+     *  resolve returns null).  A bare host falls back to the plain probe. */
+    canonResolve?(bytes: Uint8Array): number | null;
 }
 export interface Recognition {
     /** Forms that can lead somewhere — they have an edge or a halo. */
@@ -82,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

@@ -1,6 +1,6 @@
-# Tempting but Wrong — 12 Traps
+# Tempting but Wrong — 13 Traps
 
-Twelve shortcuts that look plausible and break an invariant. Each states what
+Thirteen shortcuts that look plausible and break an invariant. Each states what
 not to do, why it fails, and what to do instead.
 
 ### 1. `score >= threshold` decides identity
@@ -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
 
@@ -141,3 +140,32 @@ not to do, why it fails, and what to do instead.
   `twoEndedSeat`); turns are API state in `mind/mind.ts`, not segmentation.
   Pinned by `test/59-fold-invariance.test.mjs` and
   `test/63-fold-invariants.test.mjs`.
+
+### 13. Capping a combinatorial explosion instead of budgeting it
+
+- **WRONG:** Answer a combinatorial explosion with a geometry-derived limit — a
+  cap on the pairs a sweep enumerates, the continuations a hop may offer, the
+  candidates a scan probes. A derived limit is the right cutoff for a DECISION;
+  used as the answer to explosion it is a short-circuit.
+- **WHY:** It stops the computation silently. Reach is lost, the capability that
+  depended on it goes with it, and no test fails, because the tests were written
+  against the capped behaviour. Capping and removing the cap are both wrong:
+  capping truncates, removing lets the cost run, and the two failure modes hide
+  each other.
+- **CORRECT:** BUDGET it. The work is charged in the one currency
+  (`MICRO`/`STEP`/`CONCEPT`/`PASS`; `weight = moves + PASS·unaccounted`, see
+  `docs/architecture/cost-model.md`), the charge is visible in the meter and the
+  rationale, and the SEARCH decides whether the work is worth paying — so
+  inference is never locked by a limit and nothing is truncated in silence.
+  Where the work is mechanical rather than evidential — enumeration, scans,
+  sweeps — the answer is an algorithm whose cost is structural in the bytes it
+  is given, not a smaller cap.
+- **THE IDEAL:** a universal **closure engine** — one law of closure, stated in
+  the quantities the machine already has (`leadsSomewhere`, the
+  exact-then-canonical identity, `accounted` bytes, the ladder, `hubBound`),
+  from which the reach of a gap, the offer of a hop, the depth of a join and the
+  scope of a substitution are CONSEQUENCES, not four separate decisions. Nothing
+  in this repository is that today.
+- **THE STANDARD A CHANGE MUST MEET:** state which consequence it is, and show
+  it following from the law. A change that cannot be stated that way is not
+  ready.

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`)
 

package/docs/mechanisms/extraction.md

@@ -7,13 +7,13 @@ what sits between them.
 
 ## Matcher — `skillExemplar` / `isSpanShaped` / `containsSpan` (`src/mind/match.ts`)
 
-An exemplar is span-shaped when its answer is an in-order embedding of its
-context. `isSpanShaped` is the open reading (sparse subsequence, any gaps) used
-to accept candidates; `answerRunsInContext` is the strong reading (greedy
-longest contiguous runs) used to decompose the answer for projection. Candidates
-are ranked anchors from `climbAttentionAll` (`Precomputed.spanShapedOf`), tried
-in order up to `pre.k`; sub-quantum (`< W = maxGroup`) or unanchored results are
-skipped.
+An exemplar is span-shaped when its answer embeds in order. `isSpanShaped` is
+the open reading (sparse subsequence, any gaps) for acceptance; `containsSpan`
+is the strict reading (contiguous run, or a resolved node) that fusion gates on,
+extraction decomposes with `answerRunsInContext` (greedy longest runs).
+Candidates are ranked anchors from `climbAttentionAll`
+(`Precomputed.spanShapedOf`), tried up to `pre.k`; sub-quantum (`< W`) or
+unanchored results are skipped.
 
 ## Projection — read between located frames (`src/mind/mechanisms/extraction.ts`)
 

package/docs/mechanisms/recall.md

@@ -24,16 +24,15 @@ W = `maxGroup` (river window); bars from `src/geometry.ts`.
 ## Echo — the refusing tail
 
 If no tier grounded, the exact cosine of the top hit is re-folded (`gistOf` on
-its bytes). Decision uses that exact value in the same query-relative,
-chance-corrected fraction — never the RaBitQ estimate. Below `reach` → silence;
-restating → silence; otherwise the hit's own bytes are returned as an ungrounded
-echo.
+its bytes). It uses that exact value in the same chance-corrected fraction —
+never the RaBitQ estimate. Below `reach` → silence; restating → silence;
+otherwise the hit's own bytes are returned as an ungrounded echo.
 
 ## Provenance
 
 Grounded answers carry `recall`; the echo carries `recall-echo` (`echoed: true`
-on `RecallResult`). Consumers distinguish a continuation through learned edges
-from a near-identity echo.
+on `RecallResult`); it declares `used: ∅`. Consumers distinguish a continuation
+through learned edges from a near-identity echo.
 
 ## Substitution bridge — refusal-path only (`src/mind/bridge.ts`)
 
@@ -47,13 +46,13 @@ unanimous, and the raw gap is length-balanced. Coverage must dominate the query
 and no dismissed gap may hide known content (`dismissedKnownContent` gate). Cost
 is `CONCEPT` per substitution plus `STEP`; accounted spans include matched and
 substituted ranges (so a 28/29-byte paraphrase is not charged `PASS` per
-substituted byte — observed double-charge that let `cast` outbid the bridge).
+substituted byte — the double-charge that let `cast` outbid the bridge).
 Zero-substitution identity bridges carry `complete: true` (the whole read-out);
 substituted bridges do not.
 
-Scaffolding-only queries abstain: when every stored window that could anchor is
+Scaffolding-only queries abstain: when every window that could anchor is
 saturated (corpus-global scaffolding, `allWindowsAreScaffolding`), the bridge
-returns nothing — a single substituted word cannot carry the semantic load.
+returns nothing — one substituted word cannot carry the load.
 
 ## Cost
 

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://jsr.io/schema/config-file.v1.json",
   "name": "@hviana/sema",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "exports": "./src/index.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "repository": {
     "type": "git",

package/src/alu/README.md

@@ -8,10 +8,10 @@ a truth value) are declared here once.
 
 It joins the mind as a `PipelineMechanism`
 ([`../mind/pipeline-mechanism.ts`](../mind/pipeline-mechanism.ts)) whose only
-special role is the optional `parse(query)` method every mechanism may
-implement. The mind knows nothing about what the ALU computes; it only knows
-that `parse` returns `ComputedSpan[]`, which enter the one lightest-derivation
-search as authoritative axioms (at `STEP` cost, like a learned edge).
+special role is the optional `parse(query)` every mechanism may implement. The
+mind knows nothing about what the ALU computes; it only knows that `parse`
+returns `ComputedSpan[]`, which enter the one lightest-derivation search as
+authoritative axioms (at `STEP`, like a learned edge).
 
 It has no dependency on the rest of the codebase except the pure byte helpers in
 `../bytes.ts`, and is intended to be reused as a self-contained sublibrary in
@@ -166,7 +166,7 @@ The ALU is completely decoupled from Sema. It joins the mind through
 re-exported from [`../mind/pipeline.ts`](../mind/pipeline.ts)), a thin adapter
 that wraps the ALU's `parse` in a `PipelineMechanism` — the same uniform
 interface every grounding mechanism (CAST, confluence, cover, extraction,
-recall) implements, so nothing about the ALU is special-cased in the pipeline.
+recall) implements, so nothing about the ALU is special-cased.
 
 ### The contract
 
@@ -175,7 +175,7 @@ recall) implements, so nothing about the ALU is special-cased in the pipeline.
 ```ts
 interface PipelineMechanism {
   parse?(query: Uint8Array): Promise<ComputedSpan[]>;
-  floor(ctx, query, pre): Promise<number | null>;
+  floor(ctx, query, pre, worthRunning): Promise<number | null>;
   run(ctx, query, pre): Promise<MechanismResult[]>;
 }
 ```
@@ -259,7 +259,7 @@ whose span overlaps a computed span is **masked** before the search. This is the
 the computed `4` is the cover's sole completion there. The search itself stays a
 neutral cost engine (a computed `Out` and a learned edge both cost `STEP`);
 precedence lives entirely in the masking step, which is in
-`src/mind/pipeline.ts`, not in the search and not in the ALU.
+`src/mind/mechanisms/cover.ts`, not in the search and not in the ALU.
 
 A computation and an _unrelated_ rewrite still compose in one answer
 (`"ice 2+2"` → `"cold 4"`) because the masking is scoped to the colliding span
@@ -302,11 +302,10 @@ registry.derive("hypot", 2, ["hypot"], (args, ctx) =>
   ]));
 ```
 
-No kernel edit, no graph-search edit, no resonance edit — name it, list its
-surface forms, write the body in terms of existing ops. A scalar op broadcasts
-over `nd` automatically; pass `structural = true` (the trailing flag on
-`prim`/`derive`) only for an op that consumes a list _whole_, like the `nd`
-kernel's own.
+No kernel, graph-search or resonance edit — name it, list its surface forms,
+write the body from existing ops. A scalar op broadcasts over `nd`
+automatically; pass `structural = true` (the trailing flag on `prim`/`derive`)
+only for an op that consumes a list _whole_, like the `nd` kernel's own.
 
 ## Layout
 

package/src/config.ts

@@ -116,6 +116,34 @@ export interface MindConfig {
   seed: number;
   recallQueryK: number;
   haloQueryK: number;
+  /** Branch nodes the pivot sweep may PROBE looking for the learnt context an
+   *  answer contains — the pivot's own shortlist capacity, separate from
+   *  `recallQueryK` because they are different quantities: this one bounds a
+   *  MECHANICAL sweep over the answer's tree (breadth-first, largest regions
+   *  first, so an exhausted allowance drops the far ones and never the near
+   *  ones), while `recallQueryK` bounds the bridge's candidate reads.  Sharing
+   *  one number for both meant that tightening either silently starved the
+   *  other — measured: at `recallQueryK: 1` the pivot cannot find a pivot at
+   *  all.  (`rationaleSampleK` was split out of `recallQueryK` for the same
+   *  reason, found by an adversarial review.) */
+  pivotProbeK: number;
+  /** Corpus reading (see src/mind/corpus.ts): results per call, resolved
+   *  nodes climbed from, contexts requested per climb, probes used to stride
+   *  the id space when browsing, bytes of each side a preview keeps, and the
+   *  smallest deposited note browsing will show.  Capacities and budgets only —
+   *  the one material floor (a resolved node must account for W bytes) is
+   *  derived from the geometry, not declared here. */
+  corpusLimitMax: number;
+  corpusClimbs: number;
+  corpusContextsPerClimb: number;
+  corpusSampleProbes: number;
+  corpusPreviewBytes: number;
+  corpusSampleFloorBytes: number;
+  /** Items one rationale step may ITEMISE (the whole field is still counted in
+   *  the step's note).  A capacity of the rationale, not of recall: sharing
+   *  `recallQueryK` meant `new Mind({recallQueryK: 100000})` un-bounded the very
+   *  payload the bound exists for (found by an adversarial review). */
+  rationaleSampleK: number;
   normalizeEpsilon: number;
   cosineEpsilon: number;
 
@@ -131,6 +159,14 @@ export const DEFAULT_CONFIG: MindConfig = {
   seed: 42,
   recallQueryK: 12,
   haloQueryK: 12,
+  pivotProbeK: 12,
+  rationaleSampleK: 12,
+  corpusLimitMax: 24,
+  corpusClimbs: 24,
+  corpusContextsPerClimb: 6,
+  corpusSampleProbes: 6000,
+  corpusPreviewBytes: 220,
+  corpusSampleFloorBytes: 12,
   normalizeEpsilon: 1e-12,
   cosineEpsilon: 1e-12,
   alu: {
@@ -172,6 +208,18 @@ export function resolveConfig(opts: Partial<MindConfig> = {}): MindConfig {
     seed: opts.seed ?? DEFAULT_CONFIG.seed,
     recallQueryK: opts.recallQueryK ?? DEFAULT_CONFIG.recallQueryK,
     haloQueryK: opts.haloQueryK ?? DEFAULT_CONFIG.haloQueryK,
+    pivotProbeK: opts.pivotProbeK ?? DEFAULT_CONFIG.pivotProbeK,
+    rationaleSampleK: opts.rationaleSampleK ?? DEFAULT_CONFIG.rationaleSampleK,
+    corpusLimitMax: opts.corpusLimitMax ?? DEFAULT_CONFIG.corpusLimitMax,
+    corpusClimbs: opts.corpusClimbs ?? DEFAULT_CONFIG.corpusClimbs,
+    corpusContextsPerClimb: opts.corpusContextsPerClimb ??
+      DEFAULT_CONFIG.corpusContextsPerClimb,
+    corpusSampleProbes: opts.corpusSampleProbes ??
+      DEFAULT_CONFIG.corpusSampleProbes,
+    corpusPreviewBytes: opts.corpusPreviewBytes ??
+      DEFAULT_CONFIG.corpusPreviewBytes,
+    corpusSampleFloorBytes: opts.corpusSampleFloorBytes ??
+      DEFAULT_CONFIG.corpusSampleFloorBytes,
     normalizeEpsilon: opts.normalizeEpsilon ?? DEFAULT_CONFIG.normalizeEpsilon,
     cosineEpsilon: opts.cosineEpsilon ?? DEFAULT_CONFIG.cosineEpsilon,
     alu: {