@hviana/sema 0.9.3 → 0.9.5

package/docs/mechanisms/cast.md

@@ -1,80 +1,85 @@
-# CAST — Counterfactual Transfer via Weave
-
-Counterfactual transfer over the query's **weave**: when byte-string evidence
-from multiple independently-learnt structures aligns to genuinely different
-query spans, CAST transfers structure between them (substitution, redirection,
-analogical comparison). One `alignGraded` weave, multiple schemas; each firing
-schema yields its own candidate and `think`'s single weight comparison picks.
-
-## Matcher
-
-`alignGraded` over the current query bytes: literal W-gram runs first, then
-halo-matched `pre.rec.sites`. The product is `pre.weave()` — `points[]` (each
-with graded `runs[]`) and a per-query-byte `depth[]` (how many structures cover
-that byte). CAST's single-vs-multi test is measured from those runs: a second
-point must add ≥ one perception quantum of coverage the widest does not.
-
-## Gate — weave-local discriminative frame
-
-Two derived components, both from the weave itself (no tuned threshold):
-
-1. **MIN_WEAVE = 2** — CAST needs ≥ 2 points to form a weave. Frame requires
-   _more_ than the minimum: `depth[i] > MIN_WEAVE`, i.e. ≥ 3 structures agree on
-   the byte. With only the minimum pair no byte is frame.
-
-2. **Half-dominance** — `dominates(n, total)` (> half scaffolding no longer
-   discriminates). Per byte:
-   `frame(i) ⇔ depth[i] > MIN_WEAVE ∧ dominates(depth[i], aligned)`. Per run:
-   `usable(r) ⇔ ¬dominates(framedCount(qs,qe), runLen)`.
-
-`depth` counts **distinct structures**, not accumulated weight — a byte covered
-by the same structure twice still has depth 1. Counting weight instead lets
-shared frame (" describe it", "the importance of") survive as content and makes
-substitution fire on reordered single-fact queries. The split is 29/42 vs 6/42
-when wrong.
-
-This frame gate is **weave-local** ("what the aligned structures share among
-themselves"), not corpus-local (`reachOf` + `dominates` IDF). A phrase common to
-the aligned exemplars is frame here even when it reaches a corpus minority. Do
-not replace it with the structural IDF — refuted on the `test/17` reorder probe.
-The gate does not use `frameSlots` and therefore **does not consume frame
-slots** — it is not the cohort-local `frameSlots` voice gate.
-
-Other admission gates (query ≥ 2 quanta, ≥ 2 ranked anchors, weave touches a
-committed attention root, genuinely woven — not every run restating a recognised
-site) are structural competence checks; see `cast.ts`.
+# CAST — Carry Structure Between Woven Forms
+
+When independently learnt structures align to genuinely different spans of the
+question, CAST (counterfactual transfer) carries structure from one to another
+(`src/mind/mechanisms/cast.ts`). One weave serves three schemas. Each schema
+that fires yields its own candidate, and the market's single comparison picks.
+
+## Matcher — the weave
+
+`pre.weave()` is `alignGraded` over the question: literal `W`-gram runs, then
+halo-matched sites and the climb's proposals. It produces `points[]`, each with
+graded `runs[]`, and `depth[]`, the number of distinct structures that cover
+each byte. A second point counts only if it adds at least one perception quantum
+of coverage that the widest point lacks.
+
+## Gate — the cohort's frame
+
+Frame is what the cohort of aligned structures shares (`commonality.md`):
+
+```
+frame(i)  ⇔ depth[i] > MIN_WEAVE ∧ dominates(depth[i], aligned)     MIN_WEAVE = 2
+usable(r) ⇔ ¬dominates(framedCount(qs, qe), runLen)
+```
+
+- **More than a pair must agree.** A pair is ambiguous when insertions are
+  possible, so with only two points no byte is frame.
+- **`depth` counts distinct structures, never weight.** Counting weight lets a
+  shared frame such as `describe it` survive as content, and makes substitution
+  fire on reordered single-fact questions (the measured split was 29/42 against
+  6/42).
+- **The cohort reading cannot be replaced by corpus reach.** A phrase common to
+  the aligned exemplars is frame here even when it is rare in the corpus
+  (`test/17`).
+
+Further competence checks:
+
+- the question is at least two quanta long;
+- there are at least two ranked anchors;
+- the weave touches a committed point of attention;
+- the weave is genuinely woven, not every run restating a recognised site.
+
+## Schemas
+
+- **Substitution.** A subject the question supplies takes the seat of a
+  displaced structure. The filler is what the subject contributes before the
+  seat, clipped at the seat, so the result does not depend on the weave's
+  elimination order. The substitution must actually displace something.
+- **Redirection.** The question names a substitute by quoting it from its own
+  opening bytes (`…were Lyon?` against `Lyon is a city in France`), and names it
+  after what it displaces. A substitute that is a fragment answering other
+  questions is refused: `ong)?`, the tail of every `… (… Song)?` question, once
+  voiced a stranger's birthplace.
+- **Comparison.** The dominant is seated against one analog, reached through
+  `seatOfNode` and corroborated by `analogyStrength` (halo company). Two guards
+  apply:
+  - the question must evidence the analog with a window of its own, not inside
+    the dominant's runs and not scaffolding;
+  - the dominant must not be a co-instance of the question (`evidence.md`).
+
+  Without them, a bare question was glued onto the answer, and once Shakira's
+  birthplace was set against `John Lennon`.
 
 ## Cost
 
-**2·STEP** (`STEP + STEP`): one projection per transfer act that the taken
-branch performs (halo-mediated analogy adds `CONCEPT`). Weight is
-`moves + PASS·unaccountedBytes` as usual; `accounted` is schema-specific — only
-the two points that schema actually transferred between.
-
-## Investment discipline
-
-Floor is `2·STEP`. Before touching the shared expensive analyses
-(`pre.attention()` climb, `pre.weave()`), check `worthRunning(2*STEP)` and
-return the uninvested bound when it already loses. Never compute a shared
-analysis just to discard it.
+Each transfer act costs `STEP + STEP`, plus `CONCEPT` for a halo-mediated
+analogy. `accounted` covers only the points that schema actually transferred
+between. The floor is `2·STEP`. Before first touching the climb or the weave,
+the floor asks `worthRunning(2·STEP)` and returns its uninvested bound if it
+would lose (`mechanism-market.md`).
 
 ## Provenance
 
-`cast` — the answer came from counterfactual transfer (substitution,
-redirection, or analogical comparison), not from a literal continuation.
+`cast`.
 
 ## Pins
 
-- **test/17 intelligence** — reordered single-fact must not trigger
-  substitution; the weave-local frame (depth as distinct-structure count +
-  half-dominance) is what suppresses it.
-- **test/29 counterfactual** — B/C families pin substitution / redirection /
-  comparison and their seat displacements.
-- **test/43 seat** — `seatOfNode` direction (establishing reverse vs forward vs
-  fallback) that the schemas displace through.
-
-## Source
-
-`src/mind/mechanisms/cast.ts` (`counterfactualTransfer`, `seatOfNode`,
-`MIN_WEAVE`, `weave.depth`), `src/mind/match.ts` (`alignGraded`, `project`),
-`src/geometry.ts` (`dominates`), `src/mind/graph-search.ts` (`STEP`).
+- `test/17` — a reordered single fact does not trigger substitution; it pins the
+  cohort frame.
+- `test/29` — substitution, redirection and comparison, and the displacement of
+  their seats. C3: a further hop inside a comparison's seat waits to be asked.
+- `test/43` — the direction of `seatOfNode`.
+- `test/47`, `test/50` — comparison coverage, the analog consensus floor and the
+  shared guards.
+- `test/154.7`, `test/155.9` — a comparison needs two named things, and never
+  takes a co-instance as its dominant.

package/docs/mechanisms/confluence.md

@@ -1,43 +1,36 @@
-# Confluence — Multi-Condition Meeting Point
+# Confluence — Where Independent Conditions Meet
 
-Conjunctive queries whose answer lives in no single fact, only where independent
-evidence streams intersect. Each condition reaches its own exemplar set; the
-entity satisfying all lives at their meeting point.
+Some questions state several conditions, and their answer lives in no single
+fact, only where the conditions intersect. Each condition reaches its own stored
+contexts, and the thing that satisfies all of them sits at their meeting point
+(`src/mind/mechanisms/confluence.ts`, `confluenceJoin`).
 
-Source: `src/mind/mechanisms/confluence.ts` (`confluenceJoin`,
-`confluenceMechanism`).
+## Matcher — streams from the climb
 
-## Matcher
+The streams are the consensus climb's ranked anchors (`pre.attention()`,
+`crossRegionVotes`), each bound by identity to a discriminating span of the
+question. Two streams are independent when their spans are disjoint. The meet is
+a set intersection by content-addressed window identity (`windowsOf`): a window
+present in both anchors and absent from the question.
 
-`crossRegionVotes` tiers over the consensus climb (`pre.attention()` ranked
-anchors). Streams are anchors bound by identity to disjoint discriminative query
-spans; two streams are independent when their `cover` spans are disjoint. The
-meet is set intersection by content-addressed identity (`windowsOf` /
-`findBranch` window ids): present in both anchors, absent from the query.
+## Gate — corpus-global commonality
 
-## Gate
-
-Corpus-global IDF, not weave-local. A window's `reachOf(ctx, wid, N, memo)`
-(`edgeAncestors` contexts-reached via `sharedReachMemo`) is gated by
-`dominates(reach, N)` (`geometry.ts` half-dominance, `reach*2 > N`). Majority
-reach is scaffolding and never binds a constraint nor survives the meet;
-minority reach is filler/entity. Single-window meets and sub-`2W` spans are
-refused.
+A window's `reachOf` is gated by `dominates(reach, N)` (`commonality.md`). A
+window reached by a majority of contexts is scaffolding: it never binds a
+condition and never survives the meet. A minority reach is a filler, an entity.
+A meet on a single window, or a span shorter than `2W`, is refused.
 
 ## Cost
 
-One currency (`mind/graph-search.ts`): `STEP=1`, `CONCEPT=10`, `PASS=1000`/byte.
-`moves = STEP·slots + CONCEPT` (floor `3·STEP`: two constraints + meet). Weight
-`moves + PASS·unaccounted` compared at `STEP` grade (`pipeline.ts:think`).
+`3·STEP`: two conditions and the meet. That is also its floor, so the climb is
+never touched unless `worthRunning(3·STEP)` holds (`mechanism-market.md`).
 
 ## Provenance
 
-`join` — confluence is the mechanism that OWNS this provenance
-(`src/mind/mechanisms/confluence.ts` sets it when the independent evidence
-streams meet at one anchor). It is not cover's: cover reports `cover` for every
-derivation it wins (see `docs/mechanisms/cover.md`).
+`join`, which belongs to this mechanism alone.
 
 ## Pins
 
-`test/32-confluence.test.mjs` — two-constraint intersection, order invariance,
-empty-intersection honesty, cross-domain relational joins.
+- `test/32` — two-condition intersection, invariance to the order of the
+  conditions, honest silence on an empty intersection, and relational joins
+  across domains.

package/docs/mechanisms/cover.md

@@ -1,73 +1,65 @@
-# Cover — Lightest Derivation over the Query
-
-Cover is graph search. Its axioms are the query's own decomposition and its goal
-is the cheapest cover of the query's bytes. It runs first so a computed-backed
-cover becomes a near-zero-cost incumbent.
-
-## Matcher — `locate` / recognition sites (`src/mind/recognition.ts`)
-
-Sites are spans of the query that name a node already in the store. Cover
-consumes them directly; any site whose bytes overlap a computed span is masked
-(computation always wins).
-
-## Projection — edges + conceptHop (`src/mind/match.ts`, `src/mind/graph-search.ts`)
-
-- `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` / `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`)
-
-A site participates only if it leads somewhere: it bears an edge (`hasNext`) or
-a halo (`hasHalo`). Forms that lead nowhere contribute nothing to any derivation
-and are filtered during recognition.
-
-## Cost (`src/mind/graph-search.ts`)
-
-| Symbol    | Value       | Rule                                            |
-| --------- | ----------- | ----------------------------------------------- |
-| `STEP`    | 1           | per edge hop                                    |
-| `CONCEPT` | 10          | abandoning a chain / synonym hop                |
-| `PASS`    | 1000 / byte | each unaccounted byte                           |
-| `MICRO`   | 1e-3        | per-byte A* heuristic (`h = (len-right)*MICRO`) |
-
-The cover reports `moves` (its derivation's discrete work) and `accounted`; the
-ladder prices both.
-
-## Licensed premises (`src/mind/mechanisms/cover.ts`, `Licence` in `graph-search.ts`)
-
-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.
+# Cover — Compose the Question From What It Contains
+
+`cover` answers by graph search. Its axioms are the question's own recognised
+sites, and its goal is the lightest derivation that covers the question's bytes
+and follows their continuations (`src/mind/mechanisms/cover.ts`, `GraphSearch`).
+It runs first: a cover backed by a computation becomes an incumbent near zero
+cost, and prunes the rest of the market through the ordinary floor check
+(`mechanism-market.md`).
+
+## Matcher — recognition sites
+
+Sites are the spans of the question that name a stored form (`recognition.ts`).
+Any site that overlaps a computed span is masked: computation always wins,
+enforced by masking rather than by price (`cost-model.md`).
+
+## Gates
+
+- **The site must lead somewhere.** It has a continuation or a halo
+  (`leadsSomewhere`).
+- **A fragment needs to be asked.** A site that answers other questions
+  (`answersOtherQuestions`: inside other forms, several continuations, a window
+  of the question outside it) is dropped unless the question names one of its
+  continuations. Otherwise the cover accounted the fragment's bytes as explained
+  by a stranger's answer (`unaskedFragments`).
+- **Scaffolding accounts for nothing.** A span made only of hub windows
+  (`scaffoldSpans`) is not accounted (`evidence.md`).
+
+## Projection
+
+- **Continuation edges.** `formRules` follow continuation edges at `STEP` per
+  hop, forking over continuations up to the hub bound. The continuation chosen
+  is `guidedFirst`'s: first one the question names, then distributional support,
+  then the first inserted (`determinism.md`).
+- **Concept hops.** A form with no edge of its own may borrow a halo sibling's
+  continuation, at `CONCEPT`.
+- **Dominance.** A span's cheapest completion dominates the rest, so a hub's
+  degree generates no work in the chart (`cost-model.md`).
+
+## Premises resolved where the search reaches them
+
+The synchronous search cannot run the async reads that two of its rules need: a
+concept target, which is a halo lookup, and a learnt connector between two
+answers, which is a `bridge`. So `offerConcepts` and `offerConnectors` offer the
+keys up front, cheaply. The search then asks for a key only when it reaches it:
+a connector when a splice's two premises meet, and a concept target when the
+form asking for it is popped.
+
+A cover that asked is provisional. `cover.run` grants the asked keys and covers
+again, until a cover asks for nothing. That final cover is the one that
+resolving every key in advance would have produced. Joins licensed by rounds
+that asked for nothing are kept across re-covers.
 
 ## Provenance
 
-`cover` for every cover derivation — including the fusion/recomposition steps
-(`fuse`/`recompose`) that name a deeper learned form. (`join` is NOT cover's:
-that provenance belongs to the CONFLUENCE mechanism, which reports it when
-independent evidence streams meet at one anchor — see
-`docs/mechanisms/confluence.md`.)
+`cover`, including fusion and recomposition steps that name a deeper learnt
+form. `join` belongs to `confluence`, not to `cover`.
 
 ## Pins
 
-- `test/09-edges.test.mjs` — edge following and hop semantics
-- `test/19-nd.test.mjs` — form rules and multi-hop chains
+- `test/09` — edge following and hop semantics.
+- `test/19` — 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)
+  them; dominance.
+- `test/154` — a fragment voices none of its continuations unless the question
+  names one.

package/docs/mechanisms/extraction.md

@@ -1,53 +1,49 @@
-# Extraction — Skill-Framed Span Read-out
+# Extraction — Read a Span Between Located Frames
 
-Extraction transfers a learnt span-in-context skill to an unseen query. A skill
-exemplar is a stored fact whose answer is a span of its context (or of its
-pieces); extraction locates the exemplar's framing bytes in the query and reads
-what sits between them.
+Extraction transfers a learnt skill of the form "the answer is a span of the
+context" to a question it has never seen. A **skill exemplar** is a stored fact
+whose answer appears inside its own context. Extraction finds the exemplar's
+framing bytes in the question and reads what sits between them
+(`src/mind/mechanisms/extraction.ts`).
 
-## Matcher — `skillExemplar` / `isSpanShaped` / `containsSpan` (`src/mind/match.ts`)
+## Matcher — span-shaped exemplars
 
-An exemplar is span-shaped when its answer embeds in order. `isSpanShaped` is
-the open reading (sparse subsequence, any gaps) for acceptance; `containsSpan`
-is the strict reading (contiguous run, or a resolved node) that fusion gates on,
-extraction decomposes with `answerRunsInContext` (greedy longest runs).
-Candidates are ranked anchors from `climbAttentionAll`
-(`Precomputed.spanShapedOf`), tried up to `pre.k`; sub-quantum (`< W`) or
-unanchored results are skipped.
+The candidates are the climb's ranked anchors, tried up to `pre.k`
+(`Precomputed.spanShapedOf`, `skillExemplar`). An exemplar qualifies when its
+answer embeds in its context in order:
 
-## Projection — read between located frames (`src/mind/mechanisms/extraction.ts`)
+- **`isSpanShaped`** is the open reading, a sparse subsequence. Extraction
+  accepts on it.
+- **`answerRunsInContext`** decomposes the answer into its pieces within the
+  context, taking the longest runs greedily. Fusion gates on the strict reading,
+  `containsSpan`, instead.
 
-`answerRunsInContext` splits the exemplar answer into pieces within its context.
-For each piece, the `W`-bounded pre-frame (and post-frame or next-piece
-pre-frame) is `locate`d in the query at recognition sites. Located frames define
-`start`/`end`; the bytes `query[start:end]` are read out. Multi-piece skills
-concatenate reads in order.
+## Projection — locate the frames, read between them
 
-## Gate — both borders located to account (`src/mind/mechanisms/extraction.ts`)
+For each piece, the bytes just before it (and just after it, or before the next
+piece), bounded at `W`, are located in the question (`locate`). The located
+frames fix the read's start and end. Multi-piece skills concatenate their reads
+in order. Results shorter than one quantum are skipped.
 
-Frames are evidence only when `locate` succeeds. An unanchored read (no frame
-located, `accounted === []`) is discarded — not an extraction. An open-ended
-read (only one border located) stays unaccounted.
+## Gate and accounting — both borders, or nothing
 
-## Cost (`src/mind/graph-search.ts`)
+- **No frame located** (`accounted = []`): the read is discarded. That is
+  silence, not extraction.
+- **A located frame is always evidence.**
+- **The span read between frames is accounted only when both of its borders were
+  located.** An open-ended read stays priced at `PASS` per byte, so a bounded
+  extraction outweighs an echo that merely sets things side by side.
 
-Mechanism weight is `moves + PASS * unaccounted_bytes` with
-`moves = CONCEPT + STEP * accounted.length`. Comparison is at `STEP` grade, then
-scaffolding, then list order.
+## Cost
 
-## Selective accounting
-
-Frames are always accounted when located. The read span between them is
-accounted only when bounded on both sides (`preBounded && postBounded`);
-otherwise it is PASS-priced like uncovered bytes, so a correct bounded
-extraction can outweigh an echoing juxtaposition.
+`moves = CONCEPT + STEP · accounted.length`, with a floor of `CONCEPT + STEP`.
+The floor checks `worthRunning` before touching the climb.
 
 ## Provenance
 
-`extract` (single-piece) or synthesised multi-piece read.
+`extract`.
 
 ## Pins
 
-- `test/00-extract.test.mjs` — skill transfer across values and relations
-- `test/68-extraction-unanchored.test.mjs` — unanchored gate (empty accounted is
-  silence)
+- `test/00` — skill transfer across values and relations.
+- `test/68` — an unanchored read is silence.

package/docs/mechanisms/prefix-completion.md

@@ -1,54 +1,51 @@
-# Prefix Completion — Literal Opening of One Trained Form
+# Prefix Completion — Complete a Known Beginning
 
-The query is a proper prefix of exactly one trained form. That form is voiced
-whole; nothing is invented.
+When the question is a proper prefix of exactly one trained form, that form is
+voiced whole and nothing is invented
+(`src/mind/mechanisms/prefix-completion.ts`).
 
-## Gate — exactly one opener
+## Supply — one union, decided once
 
-A candidate is a form whose bytes literally open with the query (every query
-byte matched in order from offset zero). Grounding requires **exactly one
-distinct continuation** over the candidate set:
+Resonance cannot rank a proper prefix. On the trained store, the cosine between
+a prefix and its form falls from 0.96 at one truncated byte to 0.62 at three,
+against a reach bar of 0.875. So the candidates come from two supplies:
 
-- **Candidates** = `formsOpenedBy` (content-addressed window index) ∪ memoised
-  `resonance` top-k — evaluated as one union so an exact-index ambiguity cannot
-  be hidden by the approximate tier.
-- **Distinctness** is by continuation bytes, not form id.
-- **Zero or ≥2 distinct continuations → refuse** (the prefix trap).
+- **`formsOpenedBy`** (`traverse.ts`) reads the write side's window index, which
+  is position-invariant, and climbs containment and then parents to the deposits
+  a prefix opens. It is bounded by `hubBound`.
+- **The response's top-`k` resonance.**
 
-## Cost (`src/mind/graph-search.ts`)
+The two are concatenated, and the guards decide once over the union. A chain
+that tried one supply and then the other would let the approximate tier override
+an ambiguity the exact one found.
 
-| Symbol | Value | Rule                                              |
-| ------ | ----- | ------------------------------------------------- |
-| `STEP` | 1     | maximal claim: every query byte literally matched |
+## Guards
 
-`floor` returns `STEP`; `run` returns one candidate with `moves = STEP`,
-`accounted = [[0, query.length]]`, `bytes = form`.
+1. **Literal opening.** Every byte of the question matches the form in order
+   from offset 0.
+2. **Exactly one distinct continuation**, compared by bytes, not by form id.
+   Zero or two or more means refusal: that is the prefix trap.
+3. **Readable.** If any candidate saturates its capped `bytesPrefix` read, none
+   is licensed.
+4. **At least one window.** A continuation shorter than `W` cannot be voiced,
+   and counts as disagreement.
 
-## `complete` flag
+## Cost
 
-The result carries `complete` semantics: the grounded bytes are a trained form
-reached by identity. Post-grounding (`reason` → `fuse`) must not extend them.
+`STEP`, with `accounted = [[0, query.length]]`, since every byte is literally
+matched. The result is **not** `complete`: the form may carry more beyond the
+remainder this step voiced. The floor checks `worthRunning(STEP)` before either
+supply is touched, and returns `null` when the question leaves no room for a
+continuation within the phrase cap.
 
-## Guards (from `src/mind/mechanisms/prefix-completion.ts`)
+The mechanism is registered after `recall`, so an exact self-match wins ties.
 
-1. **Unreadable veto** — a saturating `bytesPrefix` read is a standing
-   disagreement; if any candidate saturates, none is licensed.
-2. **One grouping window** — continuation must be ≥ `W` (`maxGroup`);
-   sub-quantum tails are unvoiceable and also count as disagreement.
-3. **Uniqueness** — as above.
+## Provenance
 
-Structural pre-check (`floor`): `query.length * W < query.length + W` → `null`
-(no room for a perceivable continuation).
-
-## Where it runs
-
-Last grounding mechanism in `defaultMechanisms` (`mind/pipeline.ts`); registered
-after recall so an exact self-match (`IDENTITY`) wins ties. Shares
-`formsOpenedBy` (`mind/traverse.ts`) and `Precomputed.resonance()`.
+`prefix`.
 
 ## Pins
 
-- `test/70-prefix-completion.test.mjs` — literal prefix, ambiguity, sub-quantum,
-  saturating-read veto, determinism.
-- `test/72-prefix-candidate-supply.test.mjs` — `formsOpenedBy` ∪ `resonance`
-  union supply; resonance alone cannot rank a proper prefix.
+- `test/70` — a literal prefix, ambiguity, a sub-quantum tail, the veto on a
+  saturating read, and determinism.
+- `test/72` — the union supply; resonance alone cannot rank a proper prefix.