@hviana/sema 0.9.0 → 0.9.1

package/docs/INVARIANTS.md

@@ -1,18 +1,18 @@
 # INVARIANTS — Laws, Proofs, Derivations
 
-| #  | Law                                  | Defined in                                                                                                                            | Pins                | Doc                       |
-| -- | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------- | ------------------- | ------------------------- |
-| 1  | Determinism                          | `src/config.ts:seed` `src/alphabet.ts:Alphabet` `src/mind/traverse.ts:guidedFirst`                                                    | `test/20` `test/42` | `determinism.md`          |
-| 2  | Derived thresholds                   | `src/geometry.ts:mergeThreshold,identityBar,reachThreshold,significanceBar,consensusFloor,dominates`                                  | `test/64` `test/40` | `thresholds.md`           |
-| 3  | Exact decides / approximate proposes | `src/mind/primitives.ts:resolve` `src/mind/match.ts:locate,alignGraded` `src/mind/resonance.ts:bridge`                                | `test/51`           | `exact-vs-approximate.md` |
-| 4  | One cost currency                    | `src/mind/graph-search.ts:MICRO,STEP,CONCEPT,PASS` `src/derive:lightestDerivation` (min,+) `src/mind/attention.ts:poolVotes` (+,+)    | `test/55` `test/04` | `cost-model.md`           |
-| 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) `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                           | `traverse.ts:edgeAncestors,types.ts:SaturationReason` `src/mind/junction.ts:junctionContainersFrom` `src/mind/resonance.ts:pivotInto` | `test/27` `test/16` | `saturation.md`           |
-| 14 | Closure                              | `src/mind/derivation.ts:closed,admissible,advance`                                                                                    | `test/133`–`147`    | `closure.md`              |
+| #  | Law                                  | Defined in                                                                                                                                                             | Pins                           | Doc                       |
+| -- | ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------ | ------------------------- |
+| 1  | Determinism                          | `src/config.ts:seed` `src/alphabet.ts:Alphabet` `src/mind/traverse.ts:guidedFirst`                                                                                     | `test/20` `test/42`            | `determinism.md`          |
+| 2  | Derived thresholds                   | `src/geometry.ts:mergeThreshold,identityBar,reachThreshold,significanceBar,consensusFloor,dominates`                                                                   | `test/64` `test/40`            | `thresholds.md`           |
+| 3  | Exact decides / approximate proposes | `src/mind/primitives.ts:resolve` `src/mind/match.ts:locate,alignGraded` `src/mind/resonance.ts:bridge`                                                                 | `test/51`                      | `exact-vs-approximate.md` |
+| 4  | One cost currency                    | `src/mind/graph-search.ts:MICRO,STEP,CONCEPT,PASS` `src/derive:lightestDerivation` (min,+) `src/mind/attention.ts:poolVotes` (+,+)                                     | `test/55` `test/04`            | `cost-model.md`           |
+| 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,contentIdentity` `src/mind/primitives.ts:branchNaming` `src/mind/canonical.ts:canonicalWindows,chainReach` `src/canon.ts:canonicalizer` | `test/59` `test/63` `test/152` | `fold-contract.md`        |
+| 7  | Mechanism market                     | `src/mind/pipeline-mechanism.ts:PipelineMechanism,Precomputed` `src/mind/pipeline.ts:think,worthRunning`                                                               | `test/01` `test/04` `test/153` | `mechanism-market.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                           | `traverse.ts:edgeAncestors,types.ts:SaturationReason` `src/mind/junction.ts:junctionContainersFrom` `src/mind/resonance.ts:pivotInto`                                  | `test/27` `test/16`            | `saturation.md`           |
+| 14 | Closure                              | `src/mind/derivation.ts:admissible,advance,closeOver`                                                                                                                  | `test/133`–`151`               | `closure.md`              |

package/docs/architecture/bounded-reads.md

@@ -81,5 +81,5 @@ net); a walk with only a cap drifts to the cap.
   length; training throughput floor; exact recall at scale.
 - `test/89` — completion recursion stays output-sensitive (nested searches/pops
   sublinear); guards the count of reads, not just per-read size.
-- `test/90` — connector probe (`resolveConnectors`) reads by the query length
+- `test/90` — connector probe (`offerConnectors`) reads by the query length
   (`QUERY.length + 1`), not by the learnt continuation; per-read size bound.

package/docs/architecture/caches.md

@@ -31,6 +31,7 @@ candidate window for `"smallest"` never rescans from front.
 | Cache               | Field                      | Budget                       | `sizeOf`            | Eviction       |
 | ------------------- | -------------------------- | ---------------------------- | ------------------- | -------------- |
 | dedup leaf/branch   | `_leafKey` / `_branchKey`  | `dedupCacheMax` 1M entries   | 1                   | lru            |
+| flat-branch hits    | `_flatKey`                 | `dedupCacheMax` 1M entries   | 1                   | lru+clock      |
 | reconstructed bytes | `_bytesCache`              | `bytesCacheMax` 20 MB        | `byteLength`        | smallest+clock |
 | content length      | `_lenCache`                | `bytesCacheMax`              | 16                  | lru            |
 | node records        | `_recCache`                | `recCacheBytes` 10 MB        | leaf+4·kids+12      | lru+clock      |
@@ -76,10 +77,10 @@ must discharge it.
   `contentFoldIncremental` segments bit-identically.
 - Wrong: mismatched `prev` reused by offset produced wrong tree (336 vs 400
   bytes) — a coincidental prefix length aliased unrelated content.
-- Now: `perceiveDeposit` keys by `latin1Key(bytes.subarray(0,L))` (prefix
-  bytes), probes longest cached proper prefix first; `_depositTrees` populated
-  only for conversational deposits (budget discipline), otherwise cold path
-  always correct.
+- Now: `perceiveDeposit` keys by `latin1(bytes.subarray(0,L))` (prefix bytes),
+  probes longest cached proper prefix first; `_depositTrees` populated only for
+  conversational deposits (budget discipline), otherwise cold path always
+  correct.
 
 ## Pins
 

package/docs/architecture/closure.md

@@ -3,9 +3,10 @@
 > **Law:** a step is admitted only when it CLOSES the derivation, or MOVES to
 > structure it has not consumed, or CARRIES material the asker left unaccounted.
 
-One unit and one law, asked by every tier that decides whether to continue: the
-chart's frontier, the market's candidates, the post-grounding walk, fusion, and
-the mechanisms' own gates. None re-spells a condition the law owns.
+One unit, one law and one engine, asked by every tier that decides whether to
+continue: the chart's frontier, the market's candidates, the post-grounding
+walk, fusion, and the mechanisms' own gates. None re-spells a condition the law
+owns.
 
 ## The unit — `src/mind/derivation.ts`
 
@@ -43,7 +44,35 @@ not carry.
 
 The walk ends when the layer stops offering or the law refuses; owning no
 search, the law cannot prevent a cycle — that is the layer's, over the structure
-it holds.
+it holds. A transition is only ever `advance`: a fusion the law refuses is not
+taken (there is no hand-built fallback).
+
+## The engine — `closeOver`
+
+`closeOver(state, query, W, layers, enter?)` closes a derivation under the law,
+layer by layer. A layer (`ClosureLayer`) is a named `Offer` with its own
+instrumentation hooks; each is walked by `closure` to its own end, and the state
+it reaches is the state the next layer is offered against. Layers are PHASES, in
+order, never revisited.
+
+- **¬FIXED is the engine's.** A fixed state admits no transition, so no layer is
+  entered for it — the walk-skip and fusion-skip a caller used to spell by hand
+  are the law's first clause, taken before any layer pays.
+- **Engagement is the layer's.** A layer that has nothing to offer a state
+  (`engages`) is not entered: no offer, no meter phase.
+- **The pipeline's post-grounding stage IS the engine**, with two layers: the
+  walk (`walkLayer` — forward absorb or pivot) and the fusion (`fusionLayer` —
+  one composed transition, engaged only while the derivation is open). There is
+  no hand-built state anywhere outside `advance` (`test/137.7`).
+
+## The four quantities (trap 13), and where each stands
+
+| Quantity                | Status                                                                                                                                                                                                                                                                                                                                                                                            |
+| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| offer of a hop          | Consequence. Chart: the corpus's continuations under the READ cap, each a MOVE priced STEP, the search decides (`test/112`). Walk: absorb/pivot, the law admits.                                                                                                                                                                                                                                  |
+| depth of a join         | Consequence. The join consumes the shortest tail prefix naming a learnt key that leads — CONTAINS (resolves) ∧ MOVES (leads) — and chains until the tail is consumed; no count (`test/108`). It is priced for the facts a lightest derivation STANDS ON, round by round (`solve`'s join license), never for every fact the exploration reaches — the `deepen` cure for the `recompleteNode` trap. |
+| scope of a gap          | Consequence for alignment (`alignAround` walks outward, no cap). NOT for recognition's interior pass: its reach `W⁴ + 2r` bounds an exhaustive embedded-form probe; exact unbounded reach needs a whole-stream index the store does not have.                                                                                                                                                     |
+| scope of a substitution | Consequence: the gap between two aligned anchors (`unexplainedSpans`), gated as scaffolding by the global commonality reading. The filler-unanimity window (`chainReach`) is a derived decision scale, not an explosion cap.                                                                                                                                                                      |
 
 ## One cost home
 
@@ -51,7 +80,7 @@ it holds.
 `weigh`). A mechanism reports `moves` and `accounted` — what it did — and never
 a price; `cover` reports its chart derivation's work.
 
-## Two limits, proved and left out
+## Three limits, proved and left out
 
 1. **The chart cannot evaluate accounting** — its interface has no parameter for
    it, and carrying it per item was measured and rejected. The chart reads the
@@ -62,6 +91,9 @@ a price; `cover` reports its chart derivation's work.
    `reason`'s echo guards stop with the remainder non-empty, and recall's
    reverse tiers close with an empty accounting. That is a fact about the
    asker's material in the store, available only to the layer holding it.
+3. **The extension is not priced into the market** (`test/136.2`): the engine
+   closes the WINNER only; pricing each candidate's closure would run the walk
+   for every candidate, and that comparison has not been measured.
 
 ## Layering
 
@@ -78,3 +110,11 @@ vocabulary, not the tracer's.
 - `test/142`, `test/143` — the offer's contract, and the cycles.
 - `test/144`, `test/146`, `test/147` — identity is content, the `contains` gate,
   the witness ladder.
+- `test/137.7` — no transition is built by hand outside the law.
+- `test/149` — the engine: ¬FIXED first, layers as phases, engagement, a refusal
+  ends one layer, and the pipeline sequences no layer by hand.
+- `test/150` — the join prices the facts a derivation stands on, not every fact
+  the exploration reaches (a hub's degree changes nothing).
+- `test/151` — the cover's other async premises (connectors, concept hops) are
+  resolved where the search reaches them; a span's cheapest completion
+  dominates; a grounding on the whole query pays no fusion climb.

package/docs/architecture/cost-model.md

@@ -56,6 +56,21 @@ minimum per-byte cost in the ladder (every real per-byte cost is `>= MICRO`,
 including `PASS`), and only the suffix past `right` is counted, so `h` never
 exceeds the true remaining cost.
 
+## Dominance — why `PASS ≫ STEP` does not flood the chart
+
+The heuristic charges `MICRO` for a byte the goal will pay `PASS` for, so a
+cover that leaves bytes unexplained lets the search spend up to `PASS / STEP`
+hops looking for one more explained byte. Coverage itself cannot use them: every
+recognised completion of `[i, j)` advances the cover from `i` to `j` at the same
+`MICRO`. So a form or completion of `[i, j)` whose cost has reached that of a
+completion of `[i, j)` already yielded is DOMINATED and fires no rule
+(`buildSearch`, metered as `searchDominated`): every completion it could lead to
+costs at least as much, and a tie goes to the one yielded first. What a
+completion's BYTES could still do — fuse, splice, join — fires from the
+completion the search would stand on for that span, the same cure the join
+license and `deepen` apply. The first hop's stop-here (`STEP + CONCEPT`) is then
+a real horizon: no chain deeper than it is expanded.
+
 ## Policy is not cost
 
 "Computation always wins" is **not** priced into the ladder (a computed result
@@ -69,3 +84,4 @@ the sole completion there. Keep policy in callers; keep the engine neutral.
 - `test/53` — cross-region probe instrumentation
 - `test/54` — evidence `k` instrumentation
 - `test/55` — cost meter (`Meter`, `CostReport`, `searchPops`/`searchPushes`)
+- `test/151` — dominance: a hub's degree generates no chart work

package/docs/architecture/factored-machinery.md

@@ -7,19 +7,20 @@ Siblings: `match-project.md`, `commonality.md`, `meter.md`.
 
 ## Single-definition contracts
 
-| Symbol                                                        | Defined in               | One fact                                                                                                                                                                  |
-| ------------------------------------------------------------- | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `contentLevels`                                               | `src/geometry.ts`        | Single boundary rule: cuts + levels from one rolling hash pass; every segmentation reads it.                                                                              |
-| `canonicalWindows` / `chainReach` / `leafIdRun` / `windowIds` | `src/mind/canonical.ts`  | Write/read contract: training interns `W-1,W` windows, reading chains to `W²` and probes `W`-windows — drift silences recognition.                                        |
-| `junction.ts` + `WalkCache`                                   | `src/mind/junction.ts`   | Shared junction ascent (parents + containers) with bounded `√N·W` walk; `WalkCache` memoizes capped reads/parents/containers per response; bridge and attention share it. |
-| `joinWithBridge`                                              | `src/mind/resonance.ts`  | One out-of-search assembly: `bridge(left,right)` or bare concat with `bridgeMiss` trace.                                                                                  |
-| `dismissedKnownContent`                                       | `src/mind/bridge.ts`     | Pure attestation: any unaccounted `W`-window that resolves as known content — shared gap guard for substitution and CAST.                                                 |
-| `sharedReachMemo`                                             | `src/mind/traverse.ts`   | One response-scoped `AncestorReach` memo (cleared on write and for traces); every `reachOf`/`edgeAncestors` consumer shares it.                                           |
-| `guidedFirst`                                                 | `src/mind/traverse.ts`   | Guided-or-first answer bytes: `guidedNext` else first-inserted edge (`LIMIT 1`).                                                                                          |
-| `leadsSomewhere`                                              | `src/mind/traverse.ts`   | Admission predicate: `hasNext` (cached) or `hasHalo`; sites that lead nowhere contribute no derivation.                                                                   |
-| `isChunk`                                                     | `src/sema.ts`            | `kids !== null && kids.every(k=>k.kids===null)` — smallest grouped unit; governs regions, seams, indexing.                                                                |
-| `twoEndedSeat`                                                | `src/sema.ts`            | One seat algebra: first half low seats, second half high seats; shared by perception, `fold`, and canonical folds.                                                        |
-| `closed`/`admissible`/`advance`                               | `src/mind/derivation.ts` | One admission for every derivation step and the readings every tier asks.                                                                                                 |
+| Symbol                                                        | Defined in                                              | One fact                                                                                                                                                                                      |
+| ------------------------------------------------------------- | ------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `contentLevels`                                               | `src/geometry.ts`                                       | Single boundary rule: cuts + levels from one rolling hash pass; every segmentation reads it.                                                                                                  |
+| `canonicalWindows` / `chainReach` / `leafIdRun` / `windowIds` | `src/mind/canonical.ts`                                 | Write/read contract: training interns `W-1,W` windows, reading chains to `W²` and probes `W`-windows — drift silences recognition.                                                            |
+| `junction.ts` + `WalkCache`                                   | `src/mind/junction.ts`                                  | Shared junction ascent (parents + containers) with bounded `√N·W` walk; `WalkCache` memoizes capped reads/parents/containers per response; bridge and attention share it.                     |
+| `joinWithBridge`                                              | `src/mind/resonance.ts`                                 | One out-of-search assembly: `bridge(left,right)` or bare concat with `bridgeMiss` trace.                                                                                                      |
+| `dismissedKnownContent`                                       | `src/mind/bridge.ts`                                    | Pure attestation: any unaccounted `W`-window that resolves as known content — shared gap guard for substitution and CAST.                                                                     |
+| `sharedReachMemo`                                             | `src/mind/traverse.ts`                                  | One response-scoped `AncestorReach` memo (cleared on write and for traces); every `reachOf`/`edgeAncestors` consumer shares it.                                                               |
+| `guidedFirst`                                                 | `src/mind/traverse.ts`                                  | Guided-or-first answer bytes: `guidedNext` else first-inserted edge (`LIMIT 1`).                                                                                                              |
+| `leadsSomewhere`                                              | `src/store.ts` (raw), `src/mind/traverse.ts` (memoised) | Admission predicate: `hasNext` or `hasHalo`, defined once on the store; traverse memoises the edge tier per response.                                                                         |
+| `isChunk`                                                     | `src/sema.ts`                                           | `kids !== null && kids.every(k=>k.kids===null)` — smallest grouped unit; governs regions, seams, indexing.                                                                                    |
+| `twoEndedSeat`                                                | `src/sema.ts`                                           | One seat algebra: first half low seats, second half high seats; shared by perception, `fold`, and canonical folds.                                                                            |
+| `closed`/`admissible`/`advance`/`closeOver`                   | `src/mind/derivation.ts`                                | One admission for every derivation step, the readings every tier asks, and the engine that walks the post-grounding layers.                                                                   |
+| `exactNode`                                                   | `src/mind/primitives.ts`                                | The exact content-addressed lookup (`resolve`, `canonResolve`): the identity fold (`contentIdentity`, geometry.ts) — a miss decided by the segment filter, a hit named bottom-up, no vectors. |
 
 ## Pins
 

package/docs/architecture/fold-contract.md

@@ -56,6 +56,50 @@ drift without a type error. Levels are read from the hash the cut was accepted
 at — level `L` when `h` vanishes mod `W^(L+1)` — so level-`L` cuts nest inside
 level-`(L-1)` and expected span is `W^(L+1)` bytes.
 
+## One shape, two algebras
+
+Which items group under which parent is decided by the cut levels, the keyring
+and — inside an over-long row — each item's `itemKey` (eight raw gist
+coordinates). `groupByLevel`/`foldSlice` are written ONCE over a fold algebra
+(`join`, `key`) and run over two of them: the vector fold (`perceive`) and the
+identity fold (`contentIdentity`), which names the node a stream folds to by
+asking the store bottom-up and reads only the coordinates `itemKey` hashes,
+lazily, with the same float32 additions in the same order. `exactNode` is the
+identity fold, so resolving a span builds no D-dimensional gist and leaves
+nothing in the perception memo (measured on the 31.7M-node store: one join query
+went 185 s / 4.4 GB retained → 40 s / 81 MB, same answer). A grouping rule
+written twice would be a write/read drift waiting to happen; written once, the
+two folds cannot disagree about the tree.
+
+## Same tree is not enough — the read side names as the write side names
+
+The store's `intern` names a branch by its children, and when they name none it
+looks up the FLAT node over the same bytes and REUSES it (step 1b, "same bytes,
+same node"). Every deposit interns flat nodes — its whole input and each
+canonical window — so a later deposit's branch is often stored as an earlier
+deposit's window (`ver` + `!` stored as the window `ver!`). The same tree is
+then named by a node no child lookup can reach. `exactNode` and `foldTree` name
+a branch exactly as `intern` does (`branchNaming`, `src/mind/primitives.ts`):
+the children first, the flat node over the same bytes when they name nothing —
+and an unnamed child does not settle it, since the write side minted that child
+and still reached step 1b. Measured on the 31.7M-node store: 7 of 80 dialogue
+turns asked verbatim had resolved to nothing and fell to the composition path
+(26–41 s); they now resolve to their own context.
+
+A name found only through the bytes is where the exact lookup used to MISS, and
+a flat index entry is not a learnt structure, so `resolve` still asks the
+canonical class there (`exactNaming`'s `byBytes`): it holds the learnt member
+that leads somewhere, when there is one. The store holds such byte-only names
+from an earlier deposit path (today's deposits always intern the structure
+beside the flat copy), which is why `test/152` builds the state through the
+store's write API.
+
+One stored turn of the same set still does not resolve: its context was stored
+with cuts at the ends of the conversation's EARLIER contexts (103 and 227 bytes
+into a 257-byte context) — a boundary-imposed shape neither today's deposit path
+nor the training-time one produces from these bytes, and that the read side
+could reproduce only by guessing turn boundaries, which this contract forbids.
+
 ## Optional canonical capability
 
 `canonAdd`/`canonFind` (`src/store.ts` — `canonCount`/`eachContent`) is an
@@ -81,7 +125,13 @@ any change here.
 - `test/59` — shift invariance floors (content-defined cuts preserved over
   random binary and prose).
 - `test/63` — offset/W invariance and `contentLevels` distribution expectations.
+- `test/148` — the identity fold names exactly what the vector fold names (every
+  sub-span of corpus and noise), and groups exactly as it does over long
+  low-entropy streams that force the `itemKey` split.
+- `test/152` — a deposit stored through an earlier deposit's flat window
+  resolves to its own context, both folds name it, and it is answered on the
+  exact path.
 
 See:
-`src/geometry.ts:contentLevels`/`contentBoundaries`/`contentFoldIncremental`/`stablePrefixFold`;
+`src/geometry.ts:contentLevels`/`contentBoundaries`/`contentFoldIncremental`/`stablePrefixFold`/`contentIdentity`;
 `AGENTS.md` §2 invariants.

package/docs/architecture/mechanism-market.md

@@ -67,6 +67,25 @@ Weight is one currency: `weight = moves + PASS · unaccountedBytes` where
   Cover runs first so a near-zero-cost computed span prunes the rest through the
   same mechanism — not a special case.
 
+- **A cheaper bound is looked at first.** Before mechanism `m` first-touches
+  anything, every LATER mechanism whose floor grade is strictly below `m`'s runs
+  ahead of it (cheapest first); the lowest grade they reach is `bound`, and any
+  mechanism floored above `bound` is skipped (`meter.mechanismsBounded`). The
+  bound is learnt by calling `floor` with a `worthRunning` that refuses — the
+  investment discipline makes that free. The DECISION is the declared order's: a
+  run-ahead mechanism bounds the final grade whether or not the declared order
+  would have run it (if pruned, the incumbent already sat at or below its
+  floor); every candidate above `bound` loses to the winner, and every mechanism
+  floored at or below it meets the same run-or-prune decision, so `consider`
+  replays the same candidates in declared order. Equal floors are not skipped,
+  so an earlier mechanism keeps the tie it would win. Running ahead is never
+  extra work: only a mechanism floored at or below `p` can prune `p`, and each
+  such mechanism has already run or runs ahead of `p`. Measured on the
+  31.7M-node store: a lowercased Persian turn (#83) went from 18.0 s to 1.2 s,
+  and #114 from 1.9 s to 0.7 s. In both, a grade-1 recall or prefix answer no
+  longer waits behind CAST's climb and weave. Of 42 composition-regime queries,
+  none changed its answer.
+
 - **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
@@ -93,3 +112,5 @@ out so `PASS`-bridged bytes are still charged. `narrowDecision` and
 
 - `test/01-floor` — floor geometry.
 - `test/04-think` — decider, admissible pruning, investment discipline.
+- `test/153` — run-ahead bounds: the composition market is skipped below CAST's
+  floor, and the decision equals a declared-order oracle.

package/docs/architecture/memoization.md

@@ -47,9 +47,9 @@ conversation's persistent ones (content-keyed, cross-turn).
 | Memo                | Key                                       | Scope                                        |
 | ------------------- | ----------------------------------------- | -------------------------------------------- |
 | `perceiveMemo`      | `perceiveKey(bytes)` (latin1)             | response / conversation                      |
-| `recogniseMemo`     | `latin1Key(bytes)`                        | response / conversation                      |
-| `climbMemo`         | `latin1Key(bytes)`                        | response / conversation                      |
-| `canonMemo`         | `latin1Key(bytes)`                        | response (when `canon` set)                  |
+| `recogniseMemo`     | `latin1(bytes)`                           | response / conversation                      |
+| `climbMemo`         | `latin1(bytes)`                           | response / conversation                      |
+| `canonMemo`         | `latin1(bytes)`                           | response (when `canon` set)                  |
 | `_resolvedSubtrees` | `WeakMap<Sema, {id,len}>` (node identity) | response / conversation                      |
 | `_edgeChoice`       | `Map<nodeId, pick>`                       | response only — **cleared** in `endResponse` |
 | `_gistCache`        | `BoundedMap<nodeId, Vec>` 32 MB           | **session-lifetime** (not per-response)      |

package/docs/architecture/meter.md

@@ -3,7 +3,8 @@
 `src/meter.ts` is the one computational-usage accounting surface. It counts what
 inference _cost_ so a slow response can be attributed instead of guessed at. The
 rationale says why an answer was chosen; the meter says what it cost to choose
-it. Harness: `bench/profile-inference.mjs`.
+it. Harness: the public path — `new Mind({ profile: true })`, then
+`mind.lastCost` (`formatReport` / `sumReports`).
 
 ## Five contracts
 

package/docs/architecture/saturation.md

@@ -48,6 +48,18 @@ full — identical to the unbounded climb. Work is `O(bound)` contexts times loc
 structure, never `O(N)`. Container seeding is streamed in `bound`-sized pages
 for the same reason.
 
+Refuted tightening: **container fan-out as a hub** — deciding a containment seed
+saturated when its first `containersSlice(bound+1)` page overflows, the reading
+`junction.ts` applies to the same links. It conflates the PLACES a window occurs
+with the CONTEXTS it reaches, and saturation is defined over contexts. Proved on
+`test/49`'s fixture (N = 5, `sqrt(N)` = 3): `fran` sits in 4 containers yet its
+full climb reaches 2 contexts — discriminative — and the rule called it
+saturated, as it did `of f`, `fra`, `is`, `ranc`, `ance`. On the 31.7M-node
+store no such window climbed unsaturated (18 composition queries; those climbs
+were 38% of all visits), because at `sqrt(N)` = 1,560 a full page of containers
+rarely converges on few contexts — but the rule is the same wrong reading at
+both scales. The streamed seed stays.
+
 Trace records the first deciding stop as
 `SaturationStop { reason, node, observed, limit }` plus `visited`/`maxDepth`;
 absent when unsaturated or untraced.

package/docs/architecture/store.md

@@ -27,7 +27,23 @@ a row. `has(id)` is `id < 0 || id < _nextId`.
 A branch whose kids are all leaves is **flat** — stored as raw bytes in `leaf`
 with an empty `kids` blob as marker (`flatKidsBytes`/`flatBytesKids`). Dedup
 probes hash then verify: `hashOf`→`h`→`LIMIT 1` fetch→byte compare (bloom
-negative filter first).
+negative filter first). `flatBranchMayExist(bytes)` is the filter alone — its
+`false` is exact, its `true` means "look it up" — for a caller that will verify
+anyway: `exactNode` (primitives.ts) refuses a stream whose level-0 segment
+cannot exist before naming any node, so a resolve miss costs hashing.
+`findFlatBranch` memoizes HITS (`_flatKey`, keyed by the bytes themselves) and
+never misses — the filter answers first, so a span that is not stored builds no
+key, while the segments the identity fold names, asked by every span that
+contains them, cost a map hit. `flatSpans(bytes)` returns a prober over ONE
+buffer that answers exactly `findFlatBranch(bytes.subarray(s, e))`. `hashOf` is
+FNV-1a, a left fold, so the prober extends the hash each start was last probed
+at, and keeps one byte-short copy for the edge scan's trimmed retry. A span
+scanner sweeping ends upward pays O(1) per probe instead of O(span).
+Recognition's interior pass was hashing O(n·reach²) bytes: 251,660,406 for one
+response on the 31.7M-node store (`test/153.4`).
+
+`leadsSomewhere(id)` — `hasNext || hasHalo` — is the admission predicate's ONE
+raw definition; `traverse.ts` memoises its edge tier per response.
 
 `bytes(id)`/`bytesPrefix(id, cap)` are shared with `BoundedMap` caches — callers
 must **never mutate** the returned buffer. `contentLen(id, cap)` walks with
@@ -43,7 +59,14 @@ window apart. Gists sit in `_pendingGist` (byte-budgeted `BoundedMap`);
 `batchSize` batches. Buffers flush on cadence, `commit()`, and close. Halo mass
 re-indexes geometrically (`mass<=4 || powerOfTwo`) and encodes 2-bit quantized.
 Canon index is optional: `canonAdd`/ `canonFind`/`canonCount` over 32-bit
-canonical hashes, caller verifies bytes.
+canonical hashes, caller verifies bytes. The SQLite backend keeps a negative
+filter over the canon hashes too (kept exact on `canonAdd`; the table is never
+deleted from), because recognition and the join probe it once per span and
+almost every answer is "no such key". It is PERSISTED (`canon_bloom`) in the
+same transaction as the canon rows it covers, stamped with that commit's
+`canon.upto`; an open whose meta disagrees with the stamp (rows written without
+it) rebuilds it by one scan of the h column — seconds on a trained store, paid
+once instead of per process (`test/36`).
 
 ## Containment, batching, LRU
 

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

@@ -12,6 +12,15 @@ discovering bugs:**
   leads to accidental bugs, and real-world corpus must not be compromised.
 - Something that happens due to deduplication, a tie-breaking rule, etc., isn't
   a bug—and that’s a subtle point.
+- A change in behavior is not a behavioral regression: A change that shifts a
+  response from correct to incorrect is not necessarily a regression. Sometimes,
+  there may be many other responses that were incorrect but have become correct.
+  Overall, there must be a net gain. Budget adjustments or computational
+  optimizations often require this.
+- Often, a pathological search is not necessarily resolved by a constant
+  derivative. A constant derivative is typically a type of short-circuit
+  breaker; it can cause truncation and is not necessarily a budget-related
+  measure. Therefore, it must be used wisely.
 
 ### 1. `score >= threshold` decides identity
 
@@ -174,8 +183,10 @@ discovering bugs:**
   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.
+  scope of a substitution are CONSEQUENCES, not four separate decisions. Where
+  the repository stands against it — the engine (`closeOver`), which of the four
+  follow from the law, and the one that does not, with the reason — is stated in
+  `docs/architecture/closure.md`, and nowhere else.
 - **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

@@ -13,22 +13,24 @@ Guards honest silence, determinism, and every pinned contract. Silence:
 unrelated queries ground to nothing (`test/28`, `50`, `56`, `67`, `76`, `84`).
 Determinism: same seed + deposit order + query gives byte-identical answer
 (`test/20`). Every invariant is pinned, the closure law included
-(`test/133`–`147`). §14–25 (pipeline), §64 (derived thresholds), AGENTS.md §2
+(`test/133`–`151`). §14–25 (pipeline), §64 (derived thresholds), AGENTS.md §2
 invariants 1–5.
 
 ## 2 — Work accounting (profiler)
 
-```bash
-node bench/profile-inference.mjs        # add [n] to limit probes
-node bench/profile-inference.mjs --trace # trace is a debugging aid, not product
+```js
+const mind = new Mind({ profile: true }); // meter attached per response
+await mind.respondText(q); //              then read mind.lastCost
+console.log(formatReport(mind.lastCost)); // sumReports() over several
 ```
 
-Guards without trace: counters exact and diffable between COLD runs; phases 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,
-`AGENTS.md` §6.
+The public path is the harness (`AGENTS.md` §6); there is no separate bench
+script. Guards without trace: counters exact and diffable between COLD runs;
+phases 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 an `inspectRationale` callback attached,
+recognition idempotence still holds (`test/42`). `src/meter.ts`,
+`docs/architecture/meter.md`, §55, `AGENTS.md` §6.
 
 ## 3 — Dependency footprint
 

package/docs/mechanisms/cover.md

@@ -15,8 +15,15 @@ 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`)
-  at `CONCEPT` (10), borrowing a synonym's continuation.
+- Edge-less forms may hop via a halo sibling (`conceptHop` / `offerConcepts`) at
+  `CONCEPT` (10), borrowing a synonym's continuation.
+- A span's cheapest completion DOMINATES the rest (`buildSearch`): a form or
+  completion of `[i, j)` whose cost has reached that of a completion of `[i, j)`
+  already yielded fires no rule (`searchDominated`). Coverage is positional, so
+  only the cheapest matters to the goal; the byte rules (fuse, splice, join)
+  fire from the completion the search would stand on, never from every
+  alternative it reached. It also makes the first hop's stop-here
+  (`STEP + CONCEPT`) a real horizon for the chain.
 
 ## Gate — `leadsSomewhere` (`src/mind/traverse.ts`)
 
@@ -36,11 +43,18 @@ and are filtered during recognition.
 The cover reports `moves` (its derivation's discrete work) and `accounted`; the
 ladder prices both.
 
-## Pre-resolution (`src/mind/mechanisms/cover.ts`)
+## Licensed premises (`src/mind/mechanisms/cover.ts`, `Licence` in `graph-search.ts`)
 
-`resolveConcepts` and `resolveConnectors` pre-resolve the async maps the
-synchronous search cannot gather: concept targets and learnt connectors, keyed
-by node pair. Bridges (`bridge`) splice connectors between rewrites.
+The synchronous search cannot run the async reads two of its rules need — a
+concept target (a halo lookup) and a learnt connector between two answers (a
+`bridge`). `offerConcepts` and `offerConnectors` OFFER the keys up front (cheap:
+`hasNext`, the touching-site pairs and the N-ary allowances); the search ASKS
+for an offered key only where it reaches it — a connector when its splice's two
+premises meet, a concept target when the hop's asking form (held at the hop's
+own cost) is popped. A cover that asked is provisional: `cover.run` grants the
+asked keys and covers again, until a cover asks nothing — which is then the
+cover every key resolved in advance would have made. The joins licensed by
+ask-free rounds are kept across the re-covers.
 
 ## Provenance
 
@@ -54,3 +68,6 @@ independent evidence streams meet at one anchor — see
 
 - `test/09-edges.test.mjs` — edge following and hop semantics
 - `test/19-nd.test.mjs` — form rules and multi-hop chains
+- `test/151` — connectors and concept hops resolved where the search reaches
+  them; a span's cheapest completion dominates (a hub's degree generates no
+  work)

package/jsr.json

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

package/package.json

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

package/src/alu/README.md

@@ -238,8 +238,16 @@ const sync = await prefetchResonance(resonance, spans);
 ```
 
 The synchronous op callbacks never await — they read from the pre-resolved
-snapshots. The public `Mind.compute(name, operands)` path pre-resolves every
-symbol span before the synchronous kernel runs, using the same discipline.
+snapshots. A named operation applied to the query's operand stream resolves
+opposites ON DEMAND (`withOppositesOnDemand`). The kernel runs against a
+snapshot of the opposites resolved so far. When it asked for one of its symbol
+operands that is not resolved yet, that one is resolved through the host and the
+pure kernel runs again. The result is the eager prefetch's, but only the
+polymorphic inverse reads opposites. Before this, every symbol operand of ANY
+operation paid one host call, and on Sema each is a halo-index query (30–200 ms
+of a plain dialogue turn's parse that computed nothing). The public
+`Mind.compute(name, operands)` path pre-resolves every symbol span before the
+synchronous kernel runs, using the same discipline.
 
 ### The mind loop
 

package/src/alu/src/index.ts

@@ -51,6 +51,7 @@ export {
   prefetchOpposites,
   prefetchRecognisedOps,
   prefetchResonance,
+  withOppositesOnDemand,
 } from "./resonance.js";
 
 export {

package/src/alu/src/parser.ts

@@ -45,10 +45,9 @@ import type { Alu } from "./alu.js";
 import {
   type AluResonance,
   type ConceptAnchor,
-  prefetchOpposites,
   prefetchResonance,
+  withOppositesOnDemand,
 } from "./resonance.js";
-import { NO_RESONANCE } from "./operation.js";
 import { int, real, symbol, symbolSpans, type Value } from "./value.js";
 import { nonSpaceRuns } from "./text.js";
 import { bytesEqual, latin1 } from "../../bytes.js";
@@ -573,10 +572,11 @@ export class QueryParser {
     const symbols = picked.flatMap((t, k) =>
       t.kind === "term" ? [args[k]] : []
     );
-    const resonance = symbols.length > 0
-      ? await prefetchOpposites(this.resonance, symbols)
-      : NO_RESONANCE;
-    const bytes = this.alu.applyBytes(name, args, resonance);
+    const bytes = await withOppositesOnDemand(
+      this.resonance,
+      symbols,
+      (resonance) => this.alu.applyBytes(name, args, resonance),
+    );
     if (bytes === null) return null;
     if (
       symbols.length === args.length && args.some((a) => bytesEqual(bytes, a))