@hviana/sema 0.9.4 → 0.9.5

package/docs/architecture/caches.md

@@ -1,90 +1,70 @@
-# Caches — Every Acceleration Is a BoundedMap
+# Caches — Every Acceleration Is a Budget
 
-> **Law:** every acceleration is a `BoundedMap` with a byte budget. A miss
-> re-derives from durable state. Degradation order is speed/reach lost, never
-> identity.
+> **Law:** every acceleration is a byte-budgeted `BoundedMap`, and a miss
+> re-derives from durable state. Eviction may cost speed or reach. It never
+> changes what is stored, what is resolved or what tree is folded.
 
-No cache may change what is stored, what is resolved, or what tree is folded.
-Eviction costs a re-read, a re-walk, or a narrower reach — never a wrong answer
-or a wrong tree.
+**Why.** Resident memory is capped by configuration, not by how much was learnt,
+so a large store does not need a large machine. That holds only if every cache
+can forget without being wrong.
 
-## `BoundedMap` — the one cache primitive
+## `BoundedMap` — the one cache primitive (`src/store.ts`)
 
-`src/store.ts:BoundedMap<K,V>` — LRU with byte accounting (`maxBytes`, `sizeOf`,
-`evict`, `recency`).
+An LRU with byte accounting (`maxBytes`, `sizeOf`), whose eviction is amortised
+O(1) over a persistent cursor. It has two settings:
 
-- `evict: "lru"` — uniform-cost entries (dedup, vectors, records).
-- `evict: "smallest"` — variable-cost reconstruction (`_bytesCache`): protects
+**`evict`, which entry goes:**
+
+- `"lru"` — for entries of uniform cost.
+- `"smallest"` — for variable-cost reconstructions (`_bytesCache`). It protects
   expensive large branches over cheap leaves.
-- `recency: "reorder"` (default) — exact LRU via `delete+set`; required when
-  eviction choice is load-bearing (`_depositTrees` — 8 entries, victim changes
-  fold).
-- `recency: "clock"` — bit instead of reorder; only for transparent caches where
-  wrong victim costs a re-read (`_bytesCache`, `_recCache`). Measured: same
-  entries cached, hot-path time 55% → bit.
-
-Persistent cursor over V8 insertion order makes eviction amortised O(1);
-candidate window for `"smallest"` never rescans from front.
-
-## Store caches — budgets in `src/config.ts:StoreConfig`
-
-| 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      |
-| pending gists       | `_pendingGist`             | `pendingGistBytes` 16 MB     | `byteLength` (D·4)  | lru            |
-| halo exact / norm   | `_haloExact` / `_haloNorm` | `haloCacheBytes` 16 MB each  | `byteLength`        | lru            |
-| skipped interiors   | `_coveredIds`              | `coveredIdsMax` 100K entries | 1                   | lru            |
-| indexed ids         | `_indexedIds`              | `coveredIdsMax`              | 1                   | lru            |
-| transparent chains  | `_chainMemo`               | `chainCacheBytes` 16 MB      | 4·len+32            | lru            |
-| ingest memo         | `CachedIngest._memo`       | `ingestCacheBytes` 50 MB     | vector+ids+keyBytes | lru            |
-
-ANN read caches (`_resonateCache`, `_resonateHaloCache`) are `Map<string,Hit[]>`
-keyed by `vecKey(v)+":"+k`, dropped on any index mutation.
-`vectorCacheMb`/`sqliteCacheMb` are pure page-cache latency knobs.
-
-`_bytesCache` only caches complete reconstructions — `bytesPrefix(id,cap)` with
-`got < cap`; a truncated prefix is never stored. `_chainMemo` is dropped on any
-write that could break transparency; `_pendingGist` eviction falls back to DAG
-climb; halo eviction re-decodes the durable 2-bit row.
-
-## Mind caches — session and per-response
-
-| Cache               | Location                                         | Budget    | Scope / invalidation                                               |
-| ------------------- | ------------------------------------------------ | --------- | ------------------------------------------------------------------ |
-| `_gistCache`        | `Mind._gistCache`                                | 32 MB     | session-lifetime, never invalidated (perception pure)              |
-| `_depositTrees`     | `Mind._depositTrees`                             | 8 entries | session; `perceiveDeposit` only when `conversational`              |
-| `_depositLens`      | `Mind._depositLens`                              | —         | byte lengths for prefix probes; cleared with map when >64          |
-| `_internIds`        | `Mind._internIds: WeakMap<Sema,number>`          | —         | Mind lifetime; ids permanent                                       |
-| `_resolvedSubtrees` | `Mind._resolvedSubtrees: WeakMap<Sema,{id,len}>` | —         | per-response/conversation; fast path only when `visit===undefined` |
-
-`REACH_MEMO_MAX` / `STRUCT_MEMO_MAX` 100K (`src/mind/traverse.ts`) — whole-climb
-and per-node structural probes (`hasNext`/`prevCount`/`hasParents`); cleared on
-write or when cap reached. `reachMemo`/`structCaches` keyed by `_structMemoKey`,
-bypassed under trace.
-
-## Deposit caches — offset-keyed, caller-discharged
-
-`_depositTrees`/`_depositLens`/`_internIds`/`_resolvedSubtrees` key **offsets**,
-not bytes, for O(1) reuse. Offsets alone cannot witness byte agreement — caller
-must discharge it.
-
-- Correct: conversation append — each turn extends the prior cumulative context
-  by its own bytes; longest cached proper prefix hit (`L < bytes.length`) reuses
-  `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 `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.
+
+**`recency`, how use is recorded:**
+
+- `"reorder"`, the default — exact LRU. It is required wherever the choice of
+  victim is load-bearing.
+- `"clock"` — a use bit. It is only for transparent caches, where a wrong victim
+  costs a re-read: `_bytesCache` and `_recCache`. It caches the same entries as
+  `"reorder"`, at a fraction of the hot-path time.
+
+## Store caches — budgets in `StoreConfig` (`src/config.ts`)
+
+| Cache                          | Field                         | Default budget               | Eviction         | A miss costs                                       |
+| ------------------------------ | ----------------------------- | ---------------------------- | ---------------- | -------------------------------------------------- |
+| dedup keys                     | `_leafKey` / `_branchKey`     | `dedupCacheMax`, 1M entries  | lru              | a durable content probe                            |
+| flat-branch hits               | `_flatKey`                    | `dedupCacheMax`              | lru + clock      | a hashed probe                                     |
+| reconstructed bytes            | `_bytesCache`                 | `bytesCacheMax`, 20 MB       | smallest + clock | a subtree walk                                     |
+| content length                 | `_lenCache`                   | `bytesCacheMax`              | lru              | a capped walk                                      |
+| node records                   | `_recCache`                   | `recCacheBytes`, 10 MB       | lru + clock      | a row read                                         |
+| pending gists                  | `_pendingGist`                | `pendingGistBytes`, 16 MB    | lru              | a DAG climb                                        |
+| exact halos / norms            | `_haloExact` / `_haloNorm`    | `haloCacheBytes`, 16 MB each | lru              | decoding the 2-bit row                             |
+| skipped interiors, indexed ids | `_coveredIds` / `_indexedIds` | `coveredIdsMax`, 100K        | lru              | a re-check                                         |
+| transparent chains             | `_chainMemo`                  | `chainCacheBytes`, 16 MB     | lru              | one CTE; dropped on writes that break transparency |
+| ingest memo                    | `CachedIngest._memo`          | `ingestCacheBytes`, 50 MB    | lru              | a re-fold (the ids are hash-consed)                |
+
+- `_bytesCache` stores only complete reconstructions. A truncated prefix is
+  never cached.
+- The ANN read caches (`_resonateCache`, `_resonateHaloCache`) are keyed by
+  `vecKey(v):k`, dropped on any index mutation, and cleared at
+  `RESONATE_CACHE_MAX`.
+- `vectorCacheMb` and `sqliteCacheMb` only tune page-cache latency.
+
+## Mind caches — the session
+
+- **`_gistCache`** (32 MB): node gists, kept for the session's lifetime and
+  never invalidated, since perception is pure.
+- **`_depositTrees` / `_depositLens`**: up to 8 folds, keyed by their bytes,
+  written only by conversational deposits, so that a growing context re-folds
+  only its suffix (`fold-contract.md`). Both reset together when the length set
+  exceeds 64.
+- **`_internIds`** (a `WeakMap` from tree node to id): skips re-interning a
+  shared subtree. The ids it holds are permanent.
+
+Per-response memos are in `memoization.md`.
 
 ## Pins
 
-- `test/91` — `chainRun` via capped `_prefix`: bounded transparent-chain hop,
-  not per-node probes.
-- `test/96` — `_bytesCache` is byte-accounted `BoundedMap` that evicts; miss
-  re-derives.
+- `test/96` — `_bytesCache` is a byte-accounted `BoundedMap` that evicts, and a
+  miss re-derives.
+- `test/91` — `chainRun` hops a transparent chain in one bounded read, not with
+  probes per node.

package/docs/architecture/closure.md

@@ -1,120 +1,101 @@
-# Closure — One Law, One Unit, Every Transition
-
-> **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, 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`
-
-| Field       | What it is                                            |
-| ----------- | ----------------------------------------------------- |
-| `product`   | the answer bytes so far                               |
-| `accounted` | the spans of the asker's bytes it explains            |
-| `remainder` | what the asker still owes, per span, at the `W` floor |
-| `cost`      | the currency's total for the steps taken              |
-| `fixed`     | a declared fixpoint: no transition is offered         |
-| `used`      | the anchors the producer speaks for                   |
-
-No identity field (`resolve(product)` is one), no structure field, no frontier
-field, no producer field, and no count of any kind. The witnesses `contains` and
-`moves` are the LAYER's: it holds the structure and hands them in, so the law
-never probes the store.
-
-## The boundary
-
-`product` (what it stands on, its identity being `resolve(product)`),
-`accounted` (the price its steps summed) and `remainder` (the question's debt,
-at one quantum) are the derivation's own. What it REACHED and what it SPENT are
-the layer's (`reaches`, `consumed`), never a field here: the law decides
-admission and consumption, the layer decides frontier and termination.
+# Closure — One Law for Every Transition
+
+> **Law:** a step is admitted only when it **closes** the derivation, **moves**
+> to structure the derivation has not consumed, or **carries** material the
+> asker left unaccounted.
+
+**Why.** Every tier that decides whether to continue asks this one law, and none
+re-spells a condition it owns. Those tiers are the chart's frontier, the market,
+the walk after grounding, fusion, and the mechanisms' own gates. Without the law
+a derivation could wander: restate what it already said, cycle, or extend into
+facts nobody asked for.
+
+## The unit — `DerivationState` (`src/mind/derivation.ts`)
+
+| Field       | Meaning                                                                             |
+| ----------- | ----------------------------------------------------------------------------------- |
+| `product`   | the answer bytes, what the derivation stands on; its identity is `resolve(product)` |
+| `accounted` | the asker's spans its steps explain, a cost quantity                                |
+| `remainder` | what the asker still owes, per span, at the `W` floor; empty means **closed**       |
+| `cost`      | its position on the ladder                                                          |
+| `fixed`     | a declared fixpoint: the query _is_ the context, so no transition is offered        |
+| `used`      | the anchors the product speaks for; an empty set declares that it voices nothing    |
+
+There is no identity field, no frontier, no producer and no count. What the
+derivation _reached_ and _spent_ belongs to the layer, which holds the structure
+and hands the law its witnesses (`contains`, `moves`). The law never probes the
+store.
 
 ## The transition
 
-`admissible(state, continuation, query, W)` returns the witnesses the step pays
-in, or `null`; `advance(state, continuation, witnesses)` is the only transition.
-The remainder is consumed only by a declared move, and only by the material that
-move CARRIES: `carries` admits by ENGAGEMENT and consumes nothing, a move
-consumes what its window proves. Whole-span draining was refuted by `test/110`,
-the window alone by `test/138`. The state is BORN owing what its product does
-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. A transition is only ever `advance`: a fusion the law refuses is not
-taken (there is no hand-built fallback).
+`admissible(state, continuation, query, W)` returns the witnesses a step pays
+in, or `null`. `advance(state, continuation, witnesses)` is the only transition.
+No state is built by hand anywhere else (`test/137.7`).
+
+- **A state is born owing** everything its product does not carry.
+- **`carries` admits by engagement and consumes nothing.** Only a declared move
+  consumes, and only the material its window proves. Both shortcuts were
+  refuted: draining whole spans (`test/110`) and trusting the window alone
+  (`test/138`).
+- **A step the question did not name pays from what it still owes.** Naming is
+  the evidence law (`evidence.md`).
+- **The law owns no search, so it cannot prevent a cycle.** That belongs to the
+  layer, which holds the structure. A fusion the law refuses is simply not
+  taken, and 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
-
-`moves + PASS · unaccountedBytes` is computed in ONE place (`pipeline.ts`,
-`weigh`). A mechanism reports `moves` and `accounted` — what it did — and never
-a price; `cover` reports its chart derivation's work.
-
-## 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
-   same law off an item: identity is its `key`, continuation the rule's
-   existence, progress the frontier advancing, closure the goal test, `fix` is
-   `fixed`.
-2. **Closure by the query's position in the graph is not a term of the unit** —
-   `reason`'s echo guards stop 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.
+`closeOver(state, query, W, layers)` closes a derivation layer by layer. A layer
+(`ClosureLayer`) is a named offer with its own instrumentation. Layers are
+phases: each runs to its own end, in order, and is never revisited.
+
+- **"Not fixed" is checked first.** A fixed state admits no transition, so no
+  layer is entered.
+- **Engagement is the layer's.** A layer with nothing to offer a state
+  (`engages`) is not entered, and pays no offer and no meter phase.
+- **The pipeline's post-grounding stage is this engine,** with two layers. The
+  walk (`walkLayer`) absorbs forward or pivots. The fusion (`fusionLayer`) makes
+  one composed transition, and engages only while the derivation is open.
+
+## What the law decides, and what it does not
+
+- **The offer of a hop is a consequence.** The chart offers the corpus's
+  continuations under the read cap, each a move priced `STEP`, and the search
+  decides (`test/112`).
+- **The depth of a join is a consequence.** A join consumes the shortest tail
+  prefix that names a learnt key leading somewhere, and chains until the tail is
+  consumed (`test/108`). It is priced only for the facts the lightest derivation
+  stands on, never for everything the exploration reached (`test/150`).
+- **A gap's reach is not a consequence everywhere.** In alignment it is: the
+  walk goes outward with no cap. Recognition's interior pass is bounded at
+  `W⁴ + 2r`, because exact unbounded reach would need a whole-stream index the
+  store does not have.
+
+Three limits were proved and deliberately left out:
+
+1. **The chart cannot evaluate accounting.** Carrying it per item was measured
+   and rejected, so the chart reads the law off its items: identity is the key,
+   continuation is a rule existing, closure is the goal test.
+2. **Closure by the query's position in the graph is the layer's, not the
+   unit's.** The echo guards stop with the remainder non-empty, and recall's
+   reverse tiers close with nothing accounted.
+3. **The extension is not priced into the market.** Only the winner is closed,
+   because pricing every candidate's closure has not been measured
+   (`test/136.2`).
 
 ## Layering
 
-Imports `../bytes.js` only, and sits below `graph-search.ts`, `match.ts`,
-`rationale.ts` and `pipeline.ts`. The span algebra lives here too — the law's
-vocabulary, not the tracer's.
+`derivation.ts` imports only `../bytes.js` and sits below `graph-search.ts`,
+`match.ts`, `rationale.ts` and `pipeline.ts`. The span algebra
+(`unexplainedSpans` and its relatives) lives here as the law's vocabulary.
 
 ## Pins
 
-- `test/133`–`137` — the law's home, readings, refusal, limits.
-- `test/138` — a cycle cannot close it, a carried move can.
-- `test/139` — carrying is ENGAGEMENT, not explanation.
-- `test/140` — irrelevant supply changes nothing.
+- `test/133`–`137` — the law's home, its readings, refusal and limits.
+- `test/138`, `test/139` — a cycle cannot close a derivation, and a carried move
+  can; carrying is engagement, not explanation.
 - `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.
+- `test/149` — the engine: "not fixed" first, layers as phases, engagement, and
+  no layer sequenced by hand.
+- `test/150`, `test/151` — the join prices only what the derivation stands on,
+  and a hub's degree costs nothing.

package/docs/architecture/commonality.md

@@ -1,54 +1,63 @@
-# Three Measures of Commonality
+# Commonality — What Is Shared, Relative to Whom
 
-Sema needs "what is shared" in three populations: corpus-global (how widely a
-structure is reused), weave-local (what a local cohort of overlapping forms
-agrees on), and container-local (how many containers hold a byte window).
-Different data, different formulas, never conflated.
+> **Law:** every judgement of relevance cuts a population into what it shares
+> (frame, scaffolding) and what varies (filler, the discriminating part). The
+> cut is always read over a named population. Sema uses three populations, with
+> three measures, and never substitutes one for another.
 
-## Corpus-global — `reachOf` + `dominates`
+Commonality and discrimination are the two sides of one cut, and the cut has no
+absolute answer. `the importance of` is frame among the essay prompts aligned to
+a question and filler across the corpus. Reading one population's cut with
+another population's measure was refuted every time it was tried (`test/17`, and
+the container-as-hub saturation in `saturation.md`).
 
-_Defined in `src/mind/traverse.ts` + `src/geometry.ts`; used by climb,
-containment, IDF pooling._
+## The three populations
 
-For a node id, `reachOf(id, N)` counts how many learnt contexts contain it
-(capped graph walks, memoised per response in `sharedReachMemo`).
-`dominates(reach, N)` asks whether that reach is above the corpus-determined
-majority threshold (`geometry.ts`, over `N`). Minority reach discriminates (a
-filler), majority reach is scaffolding. Powers the climb, edge following and
-vote pooling.
+**Corpus contexts: how widely a node is used.**
 
-## Weave-local — `depth[]` + `MIN_WEAVE` + `dominates`
+- Measure: `reachOf(id, N)`, the learnt contexts its containment and edge climb
+  reaches, capped and memoized in `sharedReachMemo`.
+- Cut: `dominates(reach, N)`. A majority is scaffolding, and a minority
+  discriminates. The climb reads the graded form of the same cut, weighing a
+  region by `ln(N/c)`.
+- Read by the consensus climb, `confluence`'s gate and edge following.
 
-_Defined and gated in `src/mind/mechanisms/cast.ts` (`depth[]` from the shared
-weave, `MIN_WEAVE`); used by CAST._
+**The cohort: the structures aligned to this question.**
 
-For an alignment weave, `depth[i]` counts how many aligned structures cover byte
-`i` of the query; `MIN_WEAVE = 2` requires agreement beyond a pair (pairs are
-ambiguous with insertions), and `dominates(depth[i], aligned)` a majority of the
-cohort:
+- Measure: `depth[i]`, the number of distinct structures in the weave that cover
+  byte `i`. They are counted as distinct, never by weight.
+- Cut: `frame(i) ⇔ depth[i] > MIN_WEAVE ∧ dominates(depth[i], aligned)`, with
+  `MIN_WEAVE = 2`, because a pair is ambiguous when insertions are possible.
+- Read by CAST (`cast.ts`).
 
-```
-frame(i) ⇔ depth[i] > MIN_WEAVE ∧ dominates(depth[i], aligned)
-```
+**Places: where a window occurs.**
 
-This powers CAST's frame gate — what the cohort shares vs what differentiates
-one member — and never consults corpus reach.
+- Measure: `containersSlice(id, 0, bound + 1).length`, the window's containers.
+- Cut: `0` anchors nothing, and `≥ 2` marks the window as reused. Above the hub
+  bound, the window is scaffolding.
+- Read by the bridge and by attention, which anchor on the rarest window first,
+  and by the scaffolding readings (`scaffoldExtents`,
+  `allWindowsAreScaffolding`).
 
-The three answer different questions over different populations; CAST's frame
-must not be replaced by a reach check, and the climb must not be driven by weave
-depth.
+**Scaffolding is nobody's evidence and nobody's debt.** A window in more than
+`√N` places explains nothing, because every fact holds it. So a step cannot pay
+the question by restating `is`, and a cover span made only of scaffolding is not
+accounted (`evidence.md`).
 
-## Container-local — the window's rarity
+`hubWindows` floors that bound at `chainReach(W) = W²`. Inside one deposit's
+fold, a window is already contained by up to that many chunks and branches. On a
+store of a few facts, `√N` alone would call every window scaffolding, which
+measures fold structure, not commonness (`test/22`).
 
-_Defined in `src/mind/bridge.ts` (`containersSlice(id, 0, bound + 1).length`);
-used by the bridge, and by attention's anchoring._
-
-`rarity` counts how many containers hold a byte window: zero anchors nothing,
-two or more marks it REUSED (`winReused`), and the bridge sorts its anchors by
-it, so the rarest leads. Purpose: choosing what to anchor on.
+Two limits bound every cut. Below lies chance: one pair, or a resemblance under
+`3/√D`, cannot be told from accident. Above lies ubiquity: what everyone holds
+discriminates nothing and abstracts nothing.
 
 ## Pins
 
-- `test/17` — weave-local frame / `MIN_WEAVE` / `dominates` vs corpus-global
-  reach.
+- `test/17` — the weave-local frame, `MIN_WEAVE` and `dominates`, against corpus
+  reach (the reorder probe).
 - `test/34` — containment and reach-driven disambiguation.
+- `test/73` — a question made only of scaffolding is abstained from by the
+  bridge.
+- `test/22` — the hub floor on small stores.