@hviana/sema 0.9.1 → 0.9.3

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

@@ -7,6 +7,7 @@ import type { MindConfig } from "../config.js";
 import type { Meter } from "../meter.js";
 import type { GraphSearch, Leaf, Seg, Site } from "./graph-search.js";
 import type { Rationale } from "./rationale.js";
+import type { WindowIndex } from "./evidence.js";
 import type { ContentFold, Grid } from "../geometry.js";
 /** One {@link MindContext._depositTrees} entry — see that field's doc.
  *
@@ -370,6 +371,17 @@ export interface MindContext extends GraphSearchHost {
      *  ordinary respond() and for the first turn of a conversation. */
     currentTurnStart: number;
     _edgeGuide: Vec | null;
+    /** The question currently being answered, as the material `chooseNext`'s
+     *  exact tier witnesses a continuation's establishing contexts against —
+     *  its bytes (canonical when the response's canon preserves offsets) and
+     *  their window index.  Set and cleared with `_edgeGuide`.  `points` are the
+     *  anchors the response's consensus climb scored, once it has climbed —
+     *  the proposals the exact tier reads co-instances from. */
+    _edgeAsked: {
+        bytes: Uint8Array;
+        index: WindowIndex;
+        points?: readonly number[];
+    } | null;
     _edgeChoice: Map<number, number>;
     _prevSeen: Set<number> | null;
     /** Session cache of node-id → perceived gist, for candidate scoring

package/docs/INDEX.md

@@ -19,24 +19,25 @@ proof in `test/` (pins that fail when the law is broken).
 | Change vector search        | `docs/architecture/exact-vs-approximate.md` + `docs/architecture/bounded-reads.md` | Scores propose, bytes dispose; ANN is bounded by `hubBound`                           |
 | Profile or bound work       | `docs/architecture/meter.md` + `docs/architecture/bounded-reads.md`                | `meter.ts` is write-only; counters are product, phases are hints                      |
 
-## Architecture laws (14)
+## Architecture laws (15)
 
-| Law | File                                        | Summary                                                                                                                                                | Pins                                         |
-| --- | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------- |
-| 1   | `docs/architecture/determinism.md`          | No `Math.random`/`Date.now` in behaviour; seed-derived randomness; corpus-determined tie-breaks                                                        | `test/20`                                    |
-| 2   | `docs/architecture/thresholds.md`           | Every decision cutoff derived in `geometry.ts` over D/W/N; no tunable knobs                                                                            | `test/40`, `test/64`                         |
-| 3   | `docs/architecture/exact-vs-approximate.md` | Vector scores rank only; identity via content-addressed lookup; five graded ladders                                                                    | `test/51`                                    |
-| 4   | `docs/architecture/cost-model.md`           | Single ladder `MICRO`/`STEP`/`CONCEPT`/`PASS`; weight `moves + PASS·unaccounted`; `STEP`-grade compare                                                 | `test/04`, `test/55`                         |
-| 5   | `docs/architecture/match-project.md`        | Shared `match.ts` family (`locate`/`alignGraded`/`frameSlots`/`project`); voicing gates belong to consumers                                            | `test/24`, `test/76`                         |
-| 6   | `docs/architecture/mechanism-market.md`     | `PipelineMechanism` (`floor`/`run`/`parse`); admissible-floor pruning, investment discipline, run-ahead bounds                                         | `test/01`, `test/04`, `test/153`             |
-| 7   | `docs/architecture/commonality.md`          | Three: global (`reachOf`+`dominates`), weave-local (`depth[]`), window rarity                                                                          | `test/17`, `test/34`                         |
-| 8   | `docs/architecture/bounded-reads.md`        | No per-query read grows with N; `hubBound=√N` enforced at store via LIMIT/probe/prefix caps                                                            | `test/77`, `test/90`                         |
-| 9   | `docs/architecture/store.md`                | `AbstractStore` owns dedup/indexing/batch; `store-sqlite.ts` is thin wrappers; canon index optional                                                    | `test/08`                                    |
-| 10  | `docs/architecture/fold-contract.md`        | `perceiveDeposit` and `perceive` agree; the read side names a branch as `intern` does; `contentLevels` is single boundary rule; no W/offset dependence | `test/59`, `test/63`, `test/148`, `test/152` |
-| 11  | `docs/architecture/memoization.md`          | `Precomputed` is per-response lazy cache (promise-cached async); `beginResponse`/`endResponse` lifecycle                                               | `test/42`                                    |
-| 12  | `docs/architecture/saturation.md`           | Every walk names a deciding saturation beside its cap; cap is safety net, not decision                                                                 | `test/27`, `test/16`                         |
-| 13  | `docs/architecture/meter.md`                | `meter.ts` is write-only work accounting; counts are exact, phases nest                                                                                | `test/55`                                    |
-| 14  | `docs/architecture/closure.md`              | A derivation is closed when its structure accounts for the question's remainder; every transition asks that law, one engine walks the layers           | `test/133`–`151`                             |
+| Law | File                                        | Summary                                                                                                                                                                                                                                                                                                                                                  | Pins                                         |
+| --- | ------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- |
+| 1   | `docs/architecture/determinism.md`          | No `Math.random`/`Date.now` in behaviour; seed-derived randomness; corpus-determined tie-breaks                                                                                                                                                                                                                                                          | `test/20`                                    |
+| 2   | `docs/architecture/thresholds.md`           | Every decision cutoff derived in `geometry.ts` over D/W/N; no tunable knobs                                                                                                                                                                                                                                                                              | `test/40`, `test/64`                         |
+| 3   | `docs/architecture/exact-vs-approximate.md` | Vector scores rank only; identity via content-addressed lookup; six graded ladders                                                                                                                                                                                                                                                                       | `test/51`                                    |
+| 4   | `docs/architecture/cost-model.md`           | Single ladder `MICRO`/`STEP`/`CONCEPT`/`PASS`; weight `moves + PASS·unaccounted`; `STEP`-grade compare                                                                                                                                                                                                                                                   | `test/04`, `test/55`                         |
+| 5   | `docs/architecture/match-project.md`        | Shared `match.ts` family (`locate`/`alignGraded`/`frameSlots`/`project`); voicing gates belong to consumers                                                                                                                                                                                                                                              | `test/24`, `test/76`                         |
+| 6   | `docs/architecture/mechanism-market.md`     | `PipelineMechanism` (`floor`/`run`/`parse`); admissible-floor pruning, investment discipline, run-ahead bounds                                                                                                                                                                                                                                           | `test/01`, `test/04`, `test/153`             |
+| 7   | `docs/architecture/commonality.md`          | Three: global (`reachOf`+`dominates`), weave-local (`depth[]`), window rarity                                                                                                                                                                                                                                                                            | `test/17`, `test/34`                         |
+| 8   | `docs/architecture/bounded-reads.md`        | No per-query read grows with N; `hubBound=√N` enforced at store via LIMIT/probe/prefix caps                                                                                                                                                                                                                                                              | `test/77`, `test/90`                         |
+| 9   | `docs/architecture/store.md`                | `AbstractStore` owns dedup/indexing/batch; `store-sqlite.ts` is thin wrappers; canon index optional                                                                                                                                                                                                                                                      | `test/08`                                    |
+| 10  | `docs/architecture/fold-contract.md`        | `perceiveDeposit` and `perceive` agree; the read side names a branch as `intern` does; `contentLevels` is single boundary rule; no W/offset dependence                                                                                                                                                                                                   | `test/59`, `test/63`, `test/148`, `test/152` |
+| 11  | `docs/architecture/memoization.md`          | `Precomputed` is per-response lazy cache (promise-cached async); `beginResponse`/`endResponse` lifecycle                                                                                                                                                                                                                                                 | `test/42`                                    |
+| 12  | `docs/architecture/saturation.md`           | Every walk names a deciding saturation beside its cap; cap is safety net, not decision                                                                                                                                                                                                                                                                   | `test/27`, `test/16`                         |
+| 13  | `docs/architecture/meter.md`                | `meter.ts` is write-only work accounting; counts are exact, phases nest                                                                                                                                                                                                                                                                                  | `test/55`                                    |
+| 14  | `docs/architecture/closure.md`              | A derivation is closed when its structure accounts for the question's remainder; every transition asks that law, one engine walks the layers                                                                                                                                                                                                             | `test/133`–`151`                             |
+| 15  | `docs/architecture/evidence.md`             | A stored form is identified when the material at hand (question ∪ the node a derivation stands on) witnesses every byte of it, order-free; the question NAMES a continuation through its establishing context, or through another instance of its frame (a co-instance, never voiced as the answer); a step it did not name pays from what is still owed | `test/154`, `test/155`                       |
 
 ## Mechanisms (8)
 

package/docs/INVARIANTS.md

@@ -16,3 +16,4 @@
 | 12 | Meter contracts                      | `src/meter.ts:Meter,PhaseCost,time` `src/mind/pipeline-mechanism.ts:Precomputed.shared`                                                                                | `test/55`                      | `meter.md`                |
 | 13 | Saturation                           | `traverse.ts:edgeAncestors,types.ts:SaturationReason` `src/mind/junction.ts:junctionContainersFrom` `src/mind/resonance.ts:pivotInto`                                  | `test/27` `test/16`            | `saturation.md`           |
 | 14 | Closure                              | `src/mind/derivation.ts:admissible,advance,closeOver`                                                                                                                  | `test/133`–`151`               | `closure.md`              |
+| 15 | Witnessed evidence                   | `src/mind/evidence.ts:witness,windowIndex` `src/mind/traverse.ts:chooseNext,askedEvidence,namedContinuations,answersOtherQuestions,coInstanceFiller,scaffoldExtents`   | `test/154`, `test/155`         | `evidence.md`             |

package/docs/architecture/evidence.md

@@ -0,0 +1,256 @@
+# 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 form witnessed in every
+> byte but one contiguous span of content is ANOTHER INSTANCE of the same
+> question: it says what the question's relation is, never what it asks about. 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. The
+form's own unwitnessed bytes come back as its `residue`.
+
+## 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.
+
+An establishing context is a DEPOSITED context: a predecessor with structural
+parents or containers is a span interned inside bigger forms, and it inherits
+their edges. Witnessing such a fragment named every fact it is a piece of (the
+fragment `born?` named nine strangers' birthplaces on the 2Wiki fixture with
+one-hop questions), so it never counts — the same structural predicate
+`pivotInto` reads.
+
+## Another instance of the question — `coInstanceFiller`, `byCoInstance`
+
+The question rarely spells the relation the way the corpus does.
+`When was the
+director of film Jinpa born?` reaches `Pema Tseden`, whose fact is
+established by `Pema Tseden date of birth`: no window joins `born` to
+`date of birth`, so nothing is witnessed. What joins them is another instance of
+the question.
+
+A **co-instance** is a stored context that shares the question's FRAME, its
+opening and its close byte for byte under the response's equivalence, around ONE
+different filler, and whose filler is a thing the corpus knows: a stored context
+with continuations of its own. `Where was Peter Jackson born?`, read against
+`Where was the director of film Beat Girl born?`, shares `Where was` and `born?`
+and leaves `Peter Jackson`. Three conditions make the reading exact, and each
+was measured necessary:
+
+- **Order.** A frame is not a bag of windows. Read order-free,
+  `Lyon is a city in France` passes for an instance of
+  `what if the capital of France were Lyon?`, which NAMES Lyon, and a
+  coincidental window inside a filler splits it.
+- **The filler is an entity.**
+  `Explain how photosynthesis converts sunlight
+  into chemical energy.` shares
+  a frame with `Explain how photosynthesis
+  works.`, but its slot holds a
+  description of the frame's own subject, and it answers the question. The
+  filler is the longest stored context opening where the slot opens (up to one
+  window earlier: the `T` of `Taika` can sit in the question's `as t`).
+- **The frame is unsaid.** Every frame window must be held by the material, so
+  on the walk a frame a product already said cannot name a second step.
+  `Who is the father of …?` names the second hop of
+  `Who is the father of the director of film Beat Girl?` and not the
+  grandfather. Scaffolding windows are exempt, because they are nobody's
+  evidence (`is` in `Which country Leo Mittler is from?`).
+
+The co-instance's continuation is established by other contexts too
+(`Peter Jackson place of birth`), and the one holding the filler spells the
+relation the corpus's way: a RELATION FRAME, `` · `place of birth`. A frame
+counts only where two co-instances spell it alike. One alignment agrees with
+nothing, which is the bar `reference` holds a frame to (`MIN_INSTANCES`). The
+exact tier's second reading (`byCoInstance`, run only when no establishing
+context is witnessed outright) puts the node the derivation stands on in each
+frame and looks the result up by content: `Edmond T. Gréville place of birth`
+exists, so its continuation is named. Neither the equivalence nor the frame is
+stored as a unit, and nothing is approximate.
+
+**The proposals are the consensus climb's.** The climb already scores the stored
+forms the question's regions reach, and the co-instances are among its points.
+Its scored anchors are published on the question when it runs, and the tier
+reads the `chainReach(W)` most corroborated of them. It climbs nothing of its
+own. A first version climbed every question window itself and cost the 116-query
+battery +16% climb visits for zero namings. Two consequences follow, both
+pinned:
+
+- A pick made before the climb read less evidence than one made after, so the
+  response's pick memo is cleared when the points arrive. Traced and untraced
+  responses agree.
+- Recall's argument binding, which runs before the climb, asks for it first when
+  the argument has several continuations and the question names none outright.
+  That is exactly where the choice would otherwise be blind.
+
+A question the corpus holds verbatim is its own instance and reads no frames.
+Frames are read once per question (and once per walk material), and every node
+pays only the exact lookups.
+
+The same reading refuses the co-instance as an ANSWER, because its own
+continuation speaks of its own filler. Recall's consensus-anchor tier does not
+ground it: `Where was the performer of song God (John Lennon Song) born?`
+elected `Where was Nicki Minaj (Nicki Minaj Song) born?`. Fusion does not fuse
+it as a further topic. A CAST comparison does not take it as its dominant: it
+set `Where was Shakira (Shakira Song) born?` against `John Lennon` and voiced
+Shakira's birthplace.
+
+## Arguments the question holds under the response's equivalence
+
+Recognition matches bytes and the query fold's own boundaries. 2Wiki title-cases
+its questions (`… of film Man At Bath work at?` for the stored `Man at Bath`),
+and a title inside a question lines up with none of the fold's cuts. When
+recall's argument binding finds no recognised argument, the stored forms the
+consensus climb reaches become candidates if the question holds them under the
+response's equivalence (`canonHeldPoints`: canonical containment,
+offset-preserving, so the span is the question's own). The approximate climb
+proposes and exact containment decides. This is read after the clean-resonance
+tier, so a near-identical question pays no climb for it. The canonical-form
+index it relies on is the one the trainer builds after training
+(`buildCanonIndex`, progress.ts).
+
+A fragment that answers other questions is no argument and no independent piece
+of the question either. It is set aside BEFORE the binding looks for one maximal
+argument, so `director` no longer cancels `Man at Bath`. The same predicate
+gates CAST's redirection: the substitute `ong)?`, the tail of every
+`… (… Song)?` question, voiced a stranger's birthplace.
+
+## 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. No grounding owns the next step: a CAST grounding used to move through any term inside its answer, unasked (`Who is the director of The Jerk?` walked on to Carl Reiner's citizenship). |
+| `answersOtherQuestions` (traverse.ts) — cover sites and recall's argument binding | 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. Recall's binding read the same fragment (`director`) and voiced the most-poured stranger's fact.                                                                                                              |
+| `byCoInstance` (traverse.ts)                                                      | The exact tier's second reading: the relation read off another instance of the question, transferred to the node by an exact substitution.                                                                                                                                                                                                                                                                                                                                       |
+| Recall's consensus anchor, fusion roots                                           | A co-instance of the question is never voiced as its answer, nor fused as a further topic.                                                                                                                                                                                                                                                                                                                                                                                       |
+| CAST comparison (mechanisms/cast.ts)                                              | A comparison voices two structures, so the question must evidence the analog with a window of its own: neither inside the dominant's runs nor scaffolding. `father of Frederick II?` evidenced `Peter III of Aragon father` only with `father` and `of`, and the comparison glued that bare question onto the answer.                                                                                                                                                            |
+
+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
+
+2Wiki held-out fixture: the evidence triples of 300 validation rows, deposited
+as `wiki2.ts` does, with the canonical-form index built as the trainer builds
+it, and asked the rows' own composed questions. Same evidence "plus instances":
+261 one-hop questions about OTHER entities, built from other validation rows by
+replacing the first hop's phrase with its referent
+(`Where was the director of film X born?` → `Where was Óskar Jónasson born?`)
+and answered with the second hop's fact. No test entity has one.
+
+| Compositional correct (of 133) | Witnessing only (655b192) | Final |
+| ------------------------------ | ------------------------- | ----- |
+| Fixture                        | 52                        | 56    |
+| Plus instances                 | 41                        | 89    |
+
+The first hop is now right on 114 and 109 of the 133. Of the first hops still
+wrong, most name the entity differently from the corpus (`Clara Novello` for
+`Clara Anastasia Novello`). That is an alias, which no byte reading recovers.
+
+Removing CAST's unasked step cost six right answers on the fixture without
+instances: second hops that were right paraphrases taken without evidence
+(`work at`, `is from`, `When was … born`). The same licence produced the Carl
+Reiner extension on the trained store. Without an instance, nothing names those
+relations, and the chain stops at the first hop. The answers gained plus
+instances are those relations: `born` → place of birth, `Why did … die` → cause
+of death, `study`/`graduate from` → educated at, `work at` → employer, `is from`
+→ country of citizenship.
+
+The inference count stays low. Two hops of `father` from a question that says
+`father` once, as in `paternal grandfather`, are not composed: the store holds
+no evidence that `grandfather` composes `father` twice.
+
+On the 31.7M-node store's 116-query battery, two dialogue answers changed
+(neither was correct before). The deterministic read counters rose about 4%
+(`bytesRead`, `ancestorVisits`, `edgeProbes`), with ANN queries up 1%. CPU on
+this workstation varies by ±15% between back-to-back runs of one build, and
+paired runs read 163 s against 152 s and 171 s, then 223 s against 203 s under
+outside load. The co-instance tier read 190 forms over the battery and named
+nothing there: on that store a frame's windows are scaffolding, and the one-hop
+questions it would need are not in the corpus.
+
+## 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, in the cover and in recall's argument binding. A
+  comparison needs two things named. An argument held only under the response's
+  equivalence binds. Each assertion was verified by mutation.
+- `test/155` — the relation read off another instance of the frame; absent
+  without two instances that agree; refused for a partly shared frame; never
+  voiced as the answer; a frame a product already said names no further step; a
+  description in the slot is no other instance; traced and untraced responses
+  agree; fusion does not fuse a co-instance, nor does a comparison take one as
+  its dominant. Verified by mutation.
+- `test/76` — a fact the corpus files under an instance's filler is no carriage:
+  `reference` does not construct one for a new referent.
+- `test/29` C3 — a further hop inside a comparison's seat waits to be asked.
+- Unpinned, measured only at fixture scale. Excluding fragments from
+  establishing contexts is worth 16 answers on the fixture with one-hop
+  questions. Refusing a fragment as CAST's redirection substitute is worth four.
+  Fragments with inherited edges appear only at that scale.

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/jsr.json

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

package/package.json

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

package/src/meter.ts

@@ -265,6 +265,25 @@ export class Meter {
   /** Times the reasoner pivoted on a span its answer contains and stepped
    *  across that fact. */
   pivotSteps = 0;
+  /** `chooseNext` picks the question NAMED — a continuation one of whose own
+   *  establishing contexts the question (plus the node) wholly witnesses
+   *  (traverse.ts, the exact tier). */
+  askedContinuations = 0;
+  /** Predecessor rows that exact tier read, against its shared √N budget. */
+  askedPredecessorReads = 0;
+  /** Times the tier abstained on a read it could not trust: the continuations
+   *  came back at the √N cap, or its predecessor budget ran out before every
+   *  continuation was asked about — the distributional ladder decided. */
+  askedReadsSaturated = 0;
+  /** Picks named by a CO-INSTANCE of the question — another instance of its
+   *  frame whose continuation carries the relation over to this node by an
+   *  exact substitution (traverse.ts, `byCoInstance`). */
+  coInstanceNamings = 0;
+  /** Proposed co-instances that tier read and witnessed. */
+  coInstanceReads = 0;
+  /** Cover sites dropped as FRAGMENTS whose several continuations the question
+   *  names none of (mechanisms/cover.ts). */
+  unaskedFragments = 0;
   /** Canon probes REFUSED because the canon budget ran out — the one thing the
    *  budget does that nothing could see.  The budget itself is derived
    *  (`bytes.length · chainReach(W)²`, recognition.ts), and the cheap exact route

package/src/mind/evidence.ts

@@ -0,0 +1,125 @@
+// evidence.ts — what of a stored form the material at hand WITNESSES.
+//
+// A stored form is WITNESSED by some material when every one of its bytes lies
+// inside a W-window that occurs literally in that material — in any order, at
+// any place.  It is the order-free reading of correspondence (`alignRuns` is
+// its run-producing sibling, `junctionContainersFrom(…, unordered)` its
+// container-finding one): a learnt form is evidenced by bytes that hold all of
+// its windows, whichever way the asker happened to arrange them.
+//
+// The material is a LIST of sources because what a derivation has at hand is
+// more than the question: the node it stands on is material too.  A trained
+// question `Edmond T. Gréville place of death` is in neither the asker's
+// `Where was the place of death of the director of film Beat Girl?` nor the
+// fact `The director of Beat Girl is Edmond T. Gréville.` the first hop reached
+// — and both together hold every byte of it.  The witness records which source
+// held each window, so a consumer can tell the question's share (what the asker
+// SAID about the form) from what the derivation itself brought.
+//
+// Exact, deterministic and linear: one window index per source, one probe per
+// window of the form.  Below one window a byte agreement is chance (the floor
+// identityBar, attestedQ and the site test all draw), so a form shorter than W
+// is never witnessed.
+//
+// Layering: bytes only — importable from traverse.ts and everything above it.
+
+import { latin1 } from "../bytes.js";
+
+/** Where each W-window of one source first occurs.  Built once per source and
+ *  reused across every form asked against it. */
+export type WindowIndex = Map<string, number>;
+
+export function windowIndex(bytes: Uint8Array, W: number): WindowIndex {
+  const index: WindowIndex = new Map();
+  for (let o = 0; o + W <= bytes.length; o++) {
+    const key = latin1(bytes.subarray(o, o + W));
+    if (!index.has(key)) index.set(key, o);
+  }
+  return index;
+}
+
+/** The windows of `index` (over `bytes`) that `spoken` does not hold — what
+ *  of the question no product of the derivation has restated yet.  The keys
+ *  keep their positions in `bytes`, so a witnessing span still names the
+ *  asker's bytes. */
+export function unspoken(
+  index: WindowIndex,
+  spoken: ReadonlyArray<WindowIndex>,
+): WindowIndex {
+  const out: WindowIndex = new Map();
+  for (const [key, at] of index) {
+    if (!spoken.some((s) => s.has(key))) out.set(key, at);
+  }
+  return out;
+}
+
+/** How a form is witnessed by a list of sources. */
+export interface Witnessing {
+  /** Every byte of the form lies in a window some source holds. */
+  complete: boolean;
+  /** The windows SOURCE 0 alone supplied — windows no later source holds — as
+   *  merged spans of source 0.  With the question as source 0, this is what the
+   *  asker said about the form that the derivation did not already have. */
+  spans: Array<[number, number]>;
+  /** Bytes of source 0 inside `spans`. */
+  bytes: number;
+  /** The form's own bytes no source witnesses, as merged spans of the FORM —
+   *  empty exactly when `complete`.  ONE residue span is the shape of a
+   *  co-instance: the same frame around a different filler (`When was Peter
+   *  Jackson born?` read against `When was the director of film Jinpa
+   *  born?` leaves `Peter Jackson`). */
+  residue: Array<[number, number]>;
+}
+
+/** Witness `form` against `sources` (their window indexes, same order).  A
+ *  window is credited to the LAST source holding it — so source 0 is credited
+ *  only with what nothing else at hand supplies. */
+export function witness(
+  form: Uint8Array,
+  indexes: ReadonlyArray<WindowIndex>,
+  W: number,
+): Witnessing {
+  if (form.length < W || indexes.length === 0) {
+    return {
+      complete: false,
+      spans: [],
+      bytes: 0,
+      residue: form.length > 0 ? [[0, form.length]] : [],
+    };
+  }
+  const covered = new Uint8Array(form.length);
+  const own: Array<[number, number]> = [];
+  for (let o = 0; o + W <= form.length; o++) {
+    const key = latin1(form.subarray(o, o + W));
+    let at = -1;
+    let from = -1;
+    for (let s = indexes.length - 1; s >= 0; s--) {
+      const p = indexes[s].get(key);
+      if (p !== undefined) {
+        at = p;
+        from = s;
+        break;
+      }
+    }
+    if (from < 0) continue;
+    covered.fill(1, o, o + W);
+    if (from === 0) own.push([at, at + W]);
+  }
+  const residue: Array<[number, number]> = [];
+  for (let i = 0; i < form.length; i++) {
+    if (covered[i]) continue;
+    const last = residue[residue.length - 1];
+    if (last !== undefined && last[1] === i) last[1] = i + 1;
+    else residue.push([i, i + 1]);
+  }
+  own.sort((a, b) => a[0] - b[0]);
+  const spans: Array<[number, number]> = [];
+  for (const [s, e] of own) {
+    const last = spans[spans.length - 1];
+    if (last !== undefined && s <= last[1]) last[1] = Math.max(last[1], e);
+    else spans.push([s, e]);
+  }
+  let bytes = 0;
+  for (const [s, e] of spans) bytes += e - s;
+  return { complete: residue.length === 0, spans, bytes, residue };
+}