@hviana/sema 0.9.0 → 0.9.2

package/docs/architecture/evidence.md

@@ -0,0 +1,113 @@
+# Witnessed Evidence — The Question Names the Step
+
+> **Law:** a stored form is identified by the material at hand when every one of
+> its bytes lies in a W-window that material holds — in any order, at any place,
+> and wherever each piece of the material came from. A step the question did not
+> name has to be paid for by material the question still owes.
+
+## The operation — `src/mind/evidence.ts`
+
+`witness(form, indexes, W)` reads one form against a list of window indexes
+(`windowIndex`). It is the order-free reading of correspondence, beside
+`alignRuns` (which produces runs) and `junctionContainersFrom(…, unordered)`
+(which finds containers). It is exact, deterministic and linear: one index per
+source and one probe per window of the form. A window is credited to the LAST
+source that holds it, so source 0 (the question) is credited only with what
+nothing else at hand supplies. A form shorter than W is never witnessed.
+
+## Where the material comes from
+
+The corpus records, for every continuation, the questions that establish it: its
+predecessors. A 2Wiki fact `The father of Frederick II is Peter III of
+Aragon.`
+is established by `Frederick II` and by `Frederick II father`. The asker's
+question rarely repeats either one byte for byte, but it often holds every byte
+of one of them.
+
+The derivation stands on more than the question. The node it is following is
+material too. On the second hop of
+`Where was the place of death of the
+director of film Beat Girl?` the node is
+`Edmond T. Gréville`, which the first hop reached and the asker never wrote. The
+establishing question `Edmond T.
+Gréville place of death` is held by neither the
+question nor the first hop's fact, only by both. Measured over 5,236 held-out
+2WikiMultihopQA compositional questions, such a context is wholly witnessed by
+the question alone 69 times, and by the question plus the first hop 2,153 times.
+
+## Its consumers
+
+| Where                             | What it decides                                                                                                                                                                                                                                                                                                                                              |
+| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `chooseNext` (traverse.ts)        | **The exact tier.** It names the continuation one of whose establishing contexts (other than the node) is witnessed by the question plus the node, with the question supplying at least one window the node does not. It ranks first among the readings; the distributional ladder decides only when nothing is named, or among continuations named equally. |
+| `askedEvidence` (traverse.ts)     | The question spans that named a pick. A mechanism projecting through the pick accounts for them, because evidence travels (mechanism-market.md). Recall's argument binding uses this.                                                                                                                                                                        |
+| `preConsumed` (pipeline.ts)       | When a grounding does not declare `used`, what it spoke for is the forms inside its answer that the question already holds. The entity the answer added stays pivotable.                                                                                                                                                                                     |
+| The walk (reasoning.ts)           | A pivot is NAMED when one of its continuation's establishing contexts is witnessed by what of the question no product has said yet, plus the pivot. A named pivot MOVES. An unnamed one is offered only while the derivation still owes something, and the law then decides by carrying.                                                                     |
+| Cover sites (mechanisms/cover.ts) | A FRAGMENT is a form that sits inside other forms, has several continuations, and leaves at least one window of the question beyond it. It answers other questions, so it leads somewhere for this question only when the question names one of its continuations.                                                                                           |
+
+A cover span made of nothing but scaffolding (every window a hub,
+`scaffoldSpans`) is not accounted. The form recognised there, such as the song
+`What` in the trained store, is one of thousands the bytes could name. This is
+measured only on the trained store (`What country is Jerry Bock a citizen of?`
+was won by `The performer of What is Melinda Marx.` glued onto the right fact).
+A synthetic fixture could not reproduce that regime, because content addressing
+folds every filler's `What` into a handful of shared nodes, so no suite test
+pins this rule.
+
+## What the question owes
+
+The derivation is born owing only its discriminative material. The bytes a
+corpus-global scaffolding window reaches (`scaffoldExtents`, the same "hub"
+reading as `allWindowsAreScaffolding` and the bridge's `explainedSpan`) are
+nobody's debt. Otherwise a step could claim to pay `Who is the` by restating
+`is`, which every fact holds. Pricing is untouched: the ladder still charges
+every unexplained byte, because for a question made only of scaffolding,
+covering those bytes is the evidence. Making scaffolding free in the market was
+measured and refused, because it changed dialogue answers
+(`How are you
+today?`).
+
+The hub reading behind `scaffoldExtents` is floored at `chainReach(W)`
+containers. Inside one deposit's fold, a window is already contained by up to
+that many chunks and branches, so on a store of a few facts the √N reading would
+call every window frame. That count measures fold structure, not corpus
+commonality (`test/22`'s two-fact chains are exactly that regime).
+
+## Bounds
+
+The exact tier reads at most √N establishing contexts per decision, floored at
+`chainReach(W)`. It asks the cheapest candidates first and compares scores
+afterwards in the continuations' own order. It abstains, metered as
+`askedReadsSaturated`, in two cases: the continuation read came back at the √N
+cap, or the question holds no window the node lacks. One short prefix read
+refuses most predecessors before a whole form is reconstructed. Picks are
+memoized per node per question.
+
+## Measured
+
+| Measure                                                                                | Before | After  |
+| -------------------------------------------------------------------------------------- | ------ | ------ |
+| 2Wiki held-out fixture (300 rows, deposited as `wiki2.ts` does), compositional correct | 13/133 | 47/133 |
+| Same fixture, pivot steps                                                              | 3      | 90+    |
+| Same fixture, inference correct                                                        | 8/37   | 6/37   |
+
+The inference drop is real. Two hops of `father` from a question that says
+`father` once, as in `paternal grandfather`, used to be reached by
+over-extension and are no longer. The store holds no evidence that `grandfather`
+composes `father` twice.
+
+On the 31.7M-node store's 116-query battery, two answers became correct
+(`What country is Jerry Bock a citizen of?` and
+`What is the country of citizenship of Frederick II?`), two lost a junk
+composition, three changed between wrong answers, and no correct answer was
+lost. CPU was 150 s against two baseline runs of 139 s and 166 s, inside the
+noise. The deterministic read counters rose about 20% (`bytesRead`,
+`nodeRecords`), with ANN queries unchanged.
+
+## Pins
+
+- `test/154` — witnessing semantics. The named continuation beats the
+  most-poured one. The second hop is named by the question plus the introduced
+  entity, whatever grounded the first hop. A question that names no further step
+  is not extended. A fragment voices none of its continuations unless the
+  question names one. Each assertion was verified by mutation.

package/docs/architecture/exact-vs-approximate.md

@@ -1,4 +1,4 @@
-# Exact vs Approximate — The Law and Its Five Ladders
+# Exact vs Approximate — The Law and Its Six Ladders
 
 Vector scores (`resonate` / `resonateHalo`) are RaBitQ **estimates**. They rank
 candidates and gate broad regions; they never decide identity. Identity is
@@ -15,17 +15,18 @@ thresholds gate breadth, not truth.
 
 ## Graded evidence ladders
 
-Five subsystems share one shape — **exact → distributional → geometric** — with
+Six subsystems share one shape — **exact → distributional → geometric** — with
 earlier tiers strictly preferred. Never reorder tiers; never let an approximate
 tier override an exact one.
 
-| # | Site               | Ladder (strong → weak)                                                                                                   | File                                      |
-| - | ------------------ | ------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------- |
-| 1 | `resolve`          | exact content-addressed fold → `canonResolve` (equivalence class, hash-then-verify)                                      | `mind/primitives.ts`                      |
-| 2 | `locate`           | exact bytes → halo role → gist                                                                                           | `mind/match.ts`                           |
-| 3 | `alignGraded`      | literal W-gram runs → halo-matched sites + climb proposals (weave)                                                       | `mind/match.ts` / `pipeline-mechanism.ts` |
-| 4 | `bridge`           | junction containers → edge → synonym → whole-gist                                                                        | `mind/resonance.ts`                       |
-| 5 | `crossRegionVotes` | exact containers → single synonym → double → `structuralResonance` (synthetic gist, gated hardest — no byte containment) | `mind/attention.ts`                       |
+| # | Site               | Ladder (strong → weak)                                                                                                                        | File                                      |
+| - | ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------- |
+| 1 | `resolve`          | exact content-addressed fold → `canonResolve` (equivalence class, hash-then-verify)                                                           | `mind/primitives.ts`                      |
+| 2 | `locate`           | exact bytes → halo role → gist                                                                                                                | `mind/match.ts`                           |
+| 3 | `alignGraded`      | literal W-gram runs → halo-matched sites + climb proposals (weave)                                                                            | `mind/match.ts` / `pipeline-mechanism.ts` |
+| 4 | `bridge`           | junction containers → edge → synonym → whole-gist                                                                                             | `mind/resonance.ts`                       |
+| 5 | `crossRegionVotes` | exact containers → single synonym → double → `structuralResonance` (synthetic gist, gated hardest — no byte containment)                      | `mind/attention.ts`                       |
+| 6 | `chooseNext`       | an establishing context witnessed by the question ∪ the node (evidence.md) → distributional support (prevCount, poured mass) → first-inserted | `mind/traverse.ts`                        |
 
 ## Asymmetries (attention)
 

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.2",
   "exports": "./src/index.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "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))

package/src/alu/src/resonance.ts

@@ -104,6 +104,48 @@ export async function prefetchOpposites(
   };
 }
 
+/** {@link prefetchOpposites} resolved ON DEMAND: run `apply` against a
+ *  synchronous snapshot that answers only the opposites already resolved, and
+ *  when the computation ASKED for one of `symbols` that is not yet resolved,
+ *  resolve it through the host and run `apply` again — until a run asks for
+ *  nothing new.  The result is `apply(prefetchOpposites(resonance, symbols))`
+ *  exactly: an opposite outside `symbols` reads null in both, every one inside
+ *  that the computation reads is the host's answer in both, and `apply` is
+ *  pure, so a run that read the same answers returns the same bytes.  What it
+ *  saves is every host call no computation reads: only the polymorphic
+ *  inverse reads opposites, yet the eager prefetch paid one per symbol operand
+ *  for ANY operation — on SEMA a halo-index query each, measured at 30-200 ms
+ *  of a plain dialogue turn's parse that computed nothing. */
+export async function withOppositesOnDemand<R>(
+  resonance: AluResonance,
+  symbols: Iterable<Uint8Array>,
+  apply: (sync: ResonanceSync) => R,
+): Promise<R> {
+  const allowed = new Set<string>();
+  for (const bytes of symbols) allowed.add(latin1(bytes));
+  const table = new Map<string, Uint8Array | null>();
+  const asked = new Map<string, Uint8Array>();
+  const sync: ResonanceSync = {
+    opposite: (bytes: Uint8Array) => {
+      const key = latin1(bytes);
+      if (!allowed.has(key)) return null;
+      const known = table.get(key);
+      if (known !== undefined) return known;
+      asked.set(key, bytes);
+      return null;
+    },
+    recogniseOp: () => null,
+  };
+  for (;;) {
+    const out = apply(sync);
+    if (asked.size === 0) return out;
+    for (const [key, bytes] of asked) {
+      table.set(key, (await resonance.opposite(bytes)) ?? null);
+    }
+    asked.clear();
+  }
+}
+
 /** Pre-resolve BOTH capabilities a computation may need synchronously — the
  *  resonant opposite of a symbol (for the polymorphic inverse) AND the operation
  *  a symbol's MEANING names (for a higher-order nd op's function argument) — over