feat(ask): add served ASK artifact adapter

Adds the Stage 2 served ASK artifact adapter and adapter-only tests.

- Validates Q1-D DeliveredQuestion artifacts before ASK eligibility
- Uses ask_serving_enabled as a default-dark gate
- Uses the disclosure bus disposition mapping
- Fails closed to fallback surface/disposition on invalid artifacts
- Does not wire chat/runtime, telemetry, TurnEvent, ChatResponse, CLAIMS, or metrics
- Does not retire Q1B_ASK_CARVE_OUT or flip proposal_allowed

.github/workflows/contemplation.yml

@@ -0,0 +1,103 @@
+name: contemplation
+
+# ADR-0155 — CI-driven contemplation runner.
+#
+# Runs `core demo learning-arc --json` on a schedule, writes the
+# report to contemplation/runs/, and opens a PR against main for
+# operator review.  Never commits to main directly.  Soft-killed
+# by repo variable CONTEMPLATION_ENABLED (set to "true" to enable).
+
+on:
+  schedule:
+    # 09:00 UTC = 01:00 PST.  Nightly.  Adjust cadence per ADR-0155
+    # budget table; do not exceed 3000 Linux minutes/month on Pro.
+    - cron: '0 9 * * *'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pull-requests: write
+
+concurrency:
+  group: contemplation
+  cancel-in-progress: false
+
+jobs:
+  contemplate:
+    name: engine-authored proposal cycle
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    # Soft kill switch — set repo var CONTEMPLATION_ENABLED=true to enable.
+    # Empty / unset = workflow exits without consuming meaningful minutes.
+    if: ${{ vars.CONTEMPLATION_ENABLED == 'true' }}
+
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: set up uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: '3.11'
+          enable-cache: true
+
+      - name: install dependencies
+        run: uv pip install -e ".[dev]" pyyaml
+
+      - name: run contemplation cycle
+        id: run
+        env:
+          PYTHONPATH: ${{ github.workspace }}
+        run: |
+          set -euo pipefail
+          mkdir -p contemplation/runs
+          STAMP=$(date -u +%Y-%m-%dT%H%M%SZ)
+          OUTPUT="contemplation/runs/${STAMP}.json"
+          uv run core demo learning-arc --json > "${OUTPUT}"
+          echo "output=${OUTPUT}" >> "${GITHUB_OUTPUT}"
+          echo "stamp=${STAMP}" >> "${GITHUB_OUTPUT}"
+          echo "## Contemplation report ${STAMP}" >> "${GITHUB_STEP_SUMMARY}"
+          # Operator-facing summary — top-level keys only, full report in PR.
+          uv run python -c "
+          import json, sys
+          r = json.load(open('${OUTPUT}'))
+          for k, v in r.items():
+              print(f'- **{k}**: {type(v).__name__}')
+          " >> "${GITHUB_STEP_SUMMARY}"
+
+      - name: open PR for operator review
+        uses: peter-evans/create-pull-request@v7
+        with:
+          commit-message: |
+            chore(contemplation): CI run ${{ steps.run.outputs.stamp }}
+
+            Engine-authored contemplation cycle.  Operator review
+            required before any corpus mutation.  ADR-0155.
+          branch: contemplation/${{ steps.run.outputs.stamp }}
+          base: main
+          title: 'contemplation: CI run ${{ steps.run.outputs.stamp }}'
+          body: |
+            Automated contemplation cycle per ADR-0155.
+
+            **Report:** `${{ steps.run.outputs.output }}`
+
+            **Trust boundary:** this PR proposes only the report
+            file under `contemplation/runs/`.  No corpus, pack, or
+            engine_state mutation.  Operator review is the
+            ratification gate.
+
+            Merge to accept (becomes part of the audit trail).
+            Close to reject.
+
+            Determinism check: this report's `proposal_id` and
+            `trace_hash` fields must byte-match a local
+            `core demo learning-arc --json` at the same commit SHA.
+            If they diverge, the workflow runner-class invariant
+            has broken — investigate before merging.
+          labels: |
+            contemplation
+            ci-authored
+          add-paths: |
+            contemplation/runs/

.github/workflows/full-pytest.yml

@@ -0,0 +1,65 @@
+name: full-pytest
+
+# Post-merge validation — runs the full pytest suite on every push to main.
+# PRs are gated by the faster smoke workflow (smoke.yml); this catches
+# anything outside the smoke suite within minutes of merge.
+#
+# Quarantined tests are excluded via the conftest.py QUARANTINE registry.
+# The intent is a ratchet: once a test is removed from the registry it
+# must keep passing on this gate.
+#
+# See:
+#   conftest.py — the QUARANTINE registry (one entry per quarantined test)
+#   docs/test-debt-quarantine.md — cluster diagnoses + removal policy
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: full-pytest-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  pytest:
+    name: full pytest (-m "not quarantine" -n 2)
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: set up uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: '3.11'
+          enable-cache: true
+
+      - name: install dependencies
+        run: |
+          uv pip install -e ".[dev]" pyyaml
+
+      - name: pytest (parallel, quarantine excluded)
+        env:
+          PYTHONPATH: ${{ github.workspace }}
+          CORE_SHOWCASE_SKIP_BUDGET: "1"
+        run: |
+          uv run pytest -m "not quarantine" -n 2 --tb=short -q --maxfail=10
+
+      - name: report quarantine size (informational)
+        if: always()
+        env:
+          PYTHONPATH: ${{ github.workspace }}
+        run: |
+          uv run python -c "
+          import sys
+          sys.path.insert(0, '.')
+          from conftest import QUARANTINE
+          print(f'::notice title=Quarantine size::{len(QUARANTINE)} tests currently quarantined. Goal: shrink this number.')
+          "

.github/workflows/lane-shas.yml

@@ -25,7 +25,7 @@ jobs:
   verify:
     name: verify pinned lane SHAs
     runs-on: ubuntu-latest
-    timeout-minutes: 12
+    timeout-minutes: 20
 
     steps:
       - name: checkout

.github/workflows/ratify-proposal.yml

@@ -0,0 +1,129 @@
+name: ratify-proposal
+
+# ADR-0155 / ADR-0057 — operator ratification gate for engine-authored proposals.
+#
+# Triggered manually via GitHub Actions UI (or GitHub mobile app):
+#   Actions → ratify-proposal → Run workflow
+#
+# Inputs
+#   proposal_id   SHA-256 hex from the contemplation run JSON
+#                 (scenes[2].detail.proposal_id)
+#   review_date   YYYY-MM-DD; defaults to today (UTC)
+#   operator_note optional free-text note written to the proposal log
+#
+# What it does
+#   1. Runs `core teaching review <proposal_id> --accept --review-date <date>`
+#   2. Commits the updated corpus + proposal log directly to main
+#   3. Posts a job summary with the accepted chain_id
+#
+# Trust boundary
+#   Only `accept_proposal` is invoked — the same codepath as local CLI.
+#   Pre-conditions enforced by ProposalLog: proposal must exist, be pending,
+#   and carry replay_equivalent=True.  No other files are written.
+#
+# Soft kill switch
+#   Disabled unless repo variable CONTEMPLATION_ENABLED=true (shared with
+#   the contemplation workflow; one knob disables the whole learning arc).
+
+on:
+  workflow_dispatch:
+    inputs:
+      proposal_id:
+        description: 'proposal_id from the contemplation run JSON (scenes[2].detail.proposal_id)'
+        required: true
+        type: string
+      review_date:
+        description: 'Review date (YYYY-MM-DD) — leave blank to use today UTC'
+        required: false
+        type: string
+        default: ''
+      operator_note:
+        description: 'Optional note recorded in the proposal log'
+        required: false
+        type: string
+        default: ''
+
+permissions:
+  contents: write
+
+concurrency:
+  group: ratify-proposal
+  cancel-in-progress: false
+
+jobs:
+  ratify:
+    name: accept proposal ${{ inputs.proposal_id }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    if: ${{ vars.CONTEMPLATION_ENABLED == 'true' }}
+
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: set up uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: '3.11'
+          enable-cache: true
+
+      - name: install dependencies
+        run: uv pip install -e ".[dev]"
+
+      - name: resolve review date
+        id: date
+        run: |
+          if [ -n "${{ inputs.review_date }}" ]; then
+            echo "date=${{ inputs.review_date }}" >> "${GITHUB_OUTPUT}"
+          else
+            echo "date=$(date -u +%Y-%m-%d)" >> "${GITHUB_OUTPUT}"
+          fi
+
+      - name: accept proposal
+        id: accept
+        env:
+          PYTHONPATH: ${{ github.workspace }}
+        run: |
+          set -euo pipefail
+          NOTE_FLAG=""
+          if [ -n "${{ inputs.operator_note }}" ]; then
+            NOTE_FLAG="--note ${{ inputs.operator_note }}"
+          fi
+          OUTPUT=$(uv run core teaching review "${{ inputs.proposal_id }}" \
+            --accept \
+            --review-date "${{ steps.date.outputs.date }}" \
+            ${NOTE_FLAG})
+          echo "${OUTPUT}"
+          # Extract chain_id from "accepted; appended chain_id = <id>"
+          CHAIN_ID=$(echo "${OUTPUT}" | sed 's/accepted; appended chain_id = //')
+          echo "chain_id=${CHAIN_ID}" >> "${GITHUB_OUTPUT}"
+
+      - name: commit ratification
+        run: |
+          git config user.name  "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add \
+            teaching/cognition_chains/cognition_chains_v1.jsonl \
+            teaching/proposals/proposals.jsonl
+          git commit -m "ratify(teaching): accept proposal ${{ inputs.proposal_id }}
+
+chain_id: ${{ steps.accept.outputs.chain_id }}
+review_date: ${{ steps.date.outputs.date }}
+operator: ${{ github.actor }}
+ADR-0057 / ADR-0155"
+          git push origin main
+
+      - name: job summary
+        run: |
+          echo "## Proposal ratified" >> "${GITHUB_STEP_SUMMARY}"
+          echo "" >> "${GITHUB_STEP_SUMMARY}"
+          echo "| Field | Value |" >> "${GITHUB_STEP_SUMMARY}"
+          echo "|---|---|" >> "${GITHUB_STEP_SUMMARY}"
+          echo "| proposal_id | \`${{ inputs.proposal_id }}\` |" >> "${GITHUB_STEP_SUMMARY}"
+          echo "| chain_id | \`${{ steps.accept.outputs.chain_id }}\` |" >> "${GITHUB_STEP_SUMMARY}"
+          echo "| review_date | ${{ steps.date.outputs.date }} |" >> "${GITHUB_STEP_SUMMARY}"
+          echo "| operator | ${{ github.actor }} |" >> "${GITHUB_STEP_SUMMARY}"
+          echo "" >> "${GITHUB_STEP_SUMMARY}"
+          echo "Chain appended to \`teaching/cognition_chains/cognition_chains_v1.jsonl\`." >> "${GITHUB_STEP_SUMMARY}"

.github/workflows/smoke.yml

@@ -0,0 +1,58 @@
+name: smoke
+
+# Fast PR gate — runs the smoke suite on every PR push.
+# Covers: chat runtime, pipeline, architectural invariants, audio sensorium
+# (tests/test_audio_*.py — compiler/eval-gates/mount/CRDT-merge/teachers, ~3s),
+# and identity falsifiability (tests/test_pack_measurements_phase2.py, ADR-0043
+# — ratified packs diverge directionally; pack-invariant refusal floor; no
+# fabrication).  The falsifiability lane adds ~4 min but blocks-on-regression.
+#
+# Full pytest runs post-merge to main (see full-pytest.yml).
+# Regressions caught here block the PR; anything outside the smoke
+# suite is caught on main within minutes of merge.
+
+on:
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: smoke-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  smoke:
+    name: smoke (-m "not quarantine")
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: set up uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: '3.11'
+          enable-cache: true
+
+      - name: install dependencies
+        run: |
+          uv pip install -e ".[dev]" pyyaml
+
+      - name: pytest smoke suite
+        env:
+          PYTHONPATH: ${{ github.workspace }}
+        run: |
+          uv run pytest -m "not quarantine" --tb=short -q \
+            tests/test_chat_runtime.py \
+            tests/test_achat.py \
+            tests/test_runtime_config.py \
+            tests/test_cognitive_turn_pipeline.py \
+            tests/test_architectural_invariants.py \
+            tests/test_audio_*.py \
+            tests/test_pack_measurements_phase2.py

.gitignore

@@ -25,6 +25,10 @@ frontier_wave1.json
 # Claude Code local session artifacts (per-developer, never tracked)
 .claude/
 
+# Local macro->micro system map — a per-developer NAVIGATION INDEX (like an IDE
+# symbol index), NOT a project artifact. Regenerated on demand; never tracked.
+.system-map/
+
 # Runnable audit-passed showcases (ADR-0112 + ADR-0113) are generated on
 # demand from the signed claim + on-disk lane result files. The inputs
 # are committed; the renders are not.
@@ -36,3 +40,14 @@ evals/expert_demos/
 evals/gsm8k_math/holdouts/v1/cases.jsonl
 evals/gsm8k_math/holdouts/v1/cases_plaintext.jsonl
 evals/gsm8k_math/holdouts/v1/cases-train*
+
+# ADR-0172 W3 — math-contemplation proposals are generated on demand; the
+# directory skeleton (.gitkeep) is committed, the generated JSONL is not.
+teaching/math_proposals/proposals.jsonl
+
+# ADR-0146 — engine_state/ is per-session mutable checkpoint state; only the
+# module itself (engine_state/__init__.py) is tracked. Runtime-generated files
+# are not source artifacts.
+engine_state/manifest.json
+engine_state/recognizers.jsonl
+engine_state/discovery_candidates.jsonl

CLAIMS.md

@@ -21,7 +21,7 @@ status predicate evaluates to `reasoning-capable` with no open gaps.
 | Domain | Status | ADR | Packs | Open gaps |
 | --- | --- | --- | --- | --- |
 | `philosophy_theology` | reasoning-capable | ADR-0085 | 2 | 0 |
-| `mathematics_logic` | expert | ADR-0097 | 1 | 0 |
+| `mathematics_logic` | audit-passed | ADR-0097 | 1 | 0 |
 | `physics` | audit-passed | ADR-0100 | 1 | 0 |
 | `systems_software` | audit-passed | ADR-0101 | 1 | 0 |
 | `hebrew_greek_textual_reasoning` | reasoning-capable | ADR-0102 | 4 | 0 |
@@ -38,9 +38,11 @@ is a CI failure (`.github/workflows/lane-shas.yml`).
 | ADR-0093 | `domain_contract_validation` | All ratified packs satisfy the 9 ADR-0091 contract predicates | `evals/domain_contract_validation/results/v1_dev.json` | `98ace04e3f02bbc5a8ad655bb6593c3f1ee64cb67014f1122fe6c3c85f48d22f` |
 | ADR-0095 | `miner_loop_closure` | Miner-sourced proposals route through single reviewed teaching path | `evals/miner_loop_closure/results/v1_dev.json` | `9f071733abe7dcacf759f928548ce738fb639af3fd6e4c621a651b306d7e77ce` |
 | ADR-0096 | `fabrication_control_summary` | Phantom endpoints / cross-pack non-bridges / sibling collapses refuse | `evals/fabrication_control/results/v1_summary.json` | `01e1b6b711141f2b4a14551d7df3ea482d8d6dd7b364a25c509f4f8d08cda8a8` |
-| ADR-0098 | `demo_composition` | Demos compose from shipped modules; no parallel mechanism | `evals/demo_composition/results/v1_dev.json` | `403be13bd666389bdf1caa1b97382753e531ad72686c5237f64a5e23bc702ac4` |
-| ADR-0099 | `public_demo` | Public showcase runs deterministically under 30s; all claims supported | `evals/public_demo/results/v1_dev.json` | `acd51d0c17948030aa2843309a3729c6f825959e2e0cbbc477e07de8269268a4` |
+| ADR-0098 | `demo_composition` | Demos compose from shipped modules; no parallel mechanism | `evals/demo_composition/results/v1_dev.json` | `3a3d09f3a87462737e615c2dd3481b9e13e5ff8fadee0043c37873494ded556d` |
+| ADR-0099 | `public_demo` | Public showcase runs deterministically under 30s; all claims supported | `evals/public_demo/results/v1_dev.json` | `e323adb35ea17987991395424c603ff93bca08c11bc2713bd9f6338e86bb269f` |
 | ADR-0104 | `curriculum_loop_closure` | Curriculum-sourced proposals route through single reviewed teaching path | `evals/curriculum_loop_closure/results/v1_dev.json` | `b46d56b2d209172cc3ffaf3776dc8dcfe55093f13587c5cb67372be6dfa23e8d` |
+| ADR-0131 | `math_teaching_corpus_v1` | Math teaching corpus replays deterministically; all chains pass exit criterion (correct_rate=1.0, wrong=0) | `evals/math_teaching_corpus/v1/report.json` | `eaf160d145da29f9050ede8d58bf111b0f651dd40aeae9201857d0b97e014dd4` |
+| ADR-0206 | `deductive_logic_v1` | Propositional entailment scored against an independent truth-table oracle; dev+holdout+external 716/716 correct, wrong=0, refused=0 | `evals/deductive_logic/report.json` | `97a230949016e38d5e3f37a69e4245b320575ee70e5af92ff7607f7b05f74b5f` |
 
 ## Verification
 

CLAUDE.md

@@ -58,6 +58,16 @@ Allowed sites:
 - `ingest/gate.py` for raw input injection.
 - `language_packs/compiler.py` and vocabulary construction.
 - `algebra/versor.py` for algebra-owned sandwich closure.
+- `sensorium/*/canonical.py` and pack-governed modality compiler construction
+  boundaries for pinned signal canonicalization and quantization.
+- `session/context.py` for session-scoped **semantic anchoring** of the field
+  toward the session concept-attractor (the anchor pull, hemisphere
+  consistency).  Allowed ONLY because every such op (1) preserves
+  `versor_condition` BY CONSTRUCTION — composed from `rotor_power` /
+  `word_transition_rotor` / `versor_apply` on the Spin manifold, never a
+  post-hoc `unitize`/grade-projection — AND (2) carries semantic meaning in
+  the cognitive model.  An op that needs a post-hoc closure repair (the
+  rejected `_slerp_toward`) fails clause (1) and stays forbidden.
 
 Forbidden sites:
 
@@ -70,6 +80,15 @@ Do not add drift repair, grade projection, watchdogs, timers, hot-path
 normalizers, or monitoring functions whose only purpose is to repair another
 function.
 
+**The bright line — semantic anchoring vs. drift repair.**  An op is *semantic
+anchoring* (allowed at the sites above) iff it preserves `versor_condition` by
+construction AND expresses a relation in the cognitive model.  It is *drift
+repair* (forbidden) iff its purpose is to restore a numerical invariant a prior
+function should have preserved.  Closure of field transitions is owned solely
+by `algebra/versor.py` (`_close_applied_versor`); no other site may "fix" it.
+Naming must not disguise the distinction: an op that anchors semantically must
+not be named or documented as a "drift fix".
+
 CGA null vectors are not unit versors.  Preserve null vectors as null vectors.
 
 ## Core Primitives
@@ -104,6 +123,23 @@ runtime path.  Vault recall is exact and deterministic.
 - `calibration/*` — bounded replay-based calibration.
 - `docs/runtime_contracts.md` — response, telemetry, memory, identity, and testing contracts.
 
+### GSM8K math comprehension substrate (sealed; serving `7/43/0`, wrong=0 — moves only via ratified PRs)
+
+- `core/reliability_gate/` — calibrated-learning ledger + gate (ADR-0175): `ClassTally` counts, `conservative_floor` (one-sided Wilson, N_MIN=10), θ ceilings.
+- `generate/derivation/` — the comprehension composer: `extract.py` (lexeme quantity extraction, EX-1/4/5 + function-word unit filter), `clauses.py` (GB-1 segmentation), `compose.py` (GB-2a list-sum + GB-3a clause-scoped referent guard), `accumulate.py` (GB-3b.1 single-referent gain/loss chaining), `goal_residual.py` (ADR-0207 R4 goal-residual production), `multistep.py`/`search.py` (bounded search), `verify.py` (the wrong=0 self-verification gate: grounding ∧ cue ∧ unit ∧ completeness ∧ uniqueness).
+- `generate/cue_precision/` — `(cue, op, unit_shape)` reliability ledger + trainer (ADR-0177 CP-1/CP-2a); inert (consulted by no serving/gate path yet).
+- `evals/gsm8k_math/` — `train_sample/` (real GSM8K dev sample, currently 7 correct / 43 refused / 0 wrong), `practice/` (sealed attempt-and-eliminate lane + ADR-0163-F additive set), `confusers/` (ADR-0163-F2 discrimination probe — scored by `wrong→0` + pair-consistency, NOT flip-count).
+- `scripts/verify_lane_shas.py`, `scripts/generate_claims.py --check` — the serving-frozen gate (pinned eval-lane SHAs + `CLAIMS.md`).
+
+### Sensorium / modality compiler substrate (parallel, afferent gates; no broad capability claim)
+
+- `sensorium/compiler/` — shared compiler law for content-addressed afferent compilation units, canonical deltas, local arenas, and trace-safe merge hashes.
+- `sensorium/audio/` + `sensorium/adapters/audio.py` — `audio_core_v1`, deterministic audio compiler substrate, gate closed by default.
+- `sensorium/vision/` + `sensorium/adapters/vision.py` — `vision_core_v1`, tile-first deterministic visual compiler substrate over synthetic eval fixtures, gate closed by default.
+- `sensorium/environment/` — ADR-0208 observation-frame contract for bundles of already-compiled afferent units; not late fusion and not a mutable world model.
+- `sensorium/sensorimotor/` + `sensorium/adapters/sensorimotor.py` — ADR-0209 afferent proprioception/contact/action-result evidence substrate; no decode path.
+- `sensorium/registry.py::decode*` + `AuthorityToken` / `EfferentGate` — ADR-0198 fail-closed efferent governance path. This is not a ratified motor decoder or actuator interface; no real action emission is claimed.
+
 ## Efficiency and Performance Doctrine
 
 Performance is part of correctness for this project because slow feedback hides
@@ -207,6 +243,61 @@ Manifest checksums must hash the bytes actually written to disk:
 checksum = hashlib.sha256(Path(lexicon_path).read_bytes()).hexdigest()
 ```
 
+## Documentation Discipline
+
+ADRs, session docs, audit artifacts, and handoff briefs stay as Markdown
+(GitHub-flavored).  Plain-text artifacts are diffable, greppable, and
+readable by every agent in the dispatch pipeline.
+
+Within Markdown, two GitHub-rendered features are sanctioned and otherwise
+sparingly used:
+
+- Mermaid fenced blocks (` ```mermaid `) when a state machine, sequence,
+  or dependency graph genuinely communicates more than prose.  Inline,
+  not in a sidecar file.
+- `<details>` / `<summary>` collapsibles to fold long proofs, large
+  tables, or generated logs without losing single-file context.
+
+Out of scope:
+
+- Standalone HTML artifacts with embedded CSS / inline SVG / sidebar
+  navigation.  The "open in browser" model breaks `git diff`, breaks
+  determinism (CSS regen ordering, SVG element ordering), and breaks
+  cross-agent legibility.
+- Dashboards, status pages, or visualizers as a substitute for a
+  pinned data artifact.  If a visualization is load-bearing, the
+  underlying data must live in a deterministic JSON/JSONL/Markdown
+  artifact first; any rendering is a read-only view of that artifact.
+
+Diagrams go inside the doc that needs them.  Specs do not become
+single-file applications.
+
+## Schema-Defined Proof Obligations
+
+When a schema, type, or struct exists for the sole purpose of naming a
+structural property the architecture claims to hold
+(``HolonomyAlignmentCase``, ``RoundTripFilter``, the various ``Result``
+discriminants), the obligation is real only when an executing test can
+**meaningfully fail** under the violations it is written to catch.
+
+A test that passes under conditions that bypass the obligation it
+nominally proves is decoration, not proof.  Before treating a schema
+type as a verified property:
+
+1. Identify the violations the schema is written to catch.
+2. Confirm an existing test would fail if exactly one of those
+   violations were silently introduced (e.g. by mutating a weight,
+   skipping a step, swapping a fallback).
+3. If no such test exists, the obligation is asserted but not proven —
+   record the gap in a follow-up doc rather than treating the schema
+   as load-bearing.
+
+This rule generalises the wrong=0 invariant.  ``wrong == 0`` holds
+because the admissibility gate, the round-trip filter, and the
+multi-branch disagreement check are all wired to fail loudly when
+violated.  The same discipline applies to every other "this design
+guarantees X" claim in the codebase.
+
 ## Validation Through CLI
 
 Use CLI lanes instead of ad hoc pytest fragments:
@@ -238,6 +329,106 @@ Current near-term sequence:
 Avoid broad docs-first churn, dashboard work, or large infrastructure unless it
 unlocks one of these steps.
 
+The afferent sensorium/modalities arc (ADR-0013 -> 0181/0197/0208/0209; ADR-0198
+reserves the efferent/motor half) is a **sanctioned parallel track** — not part
+of the near-term sequence above and not licensed to displace it.  It is disjoint
+from the GSM8K serving path (no `generate.derivation` / `core.reliability_gate`
+import), so it cannot regress the serving metric; its efferent half stays gated
+behind ADR-0198's fail-closed boundary and a dedicated motor governance ADR
+(ratified afferent ADRs carry `Accepted (ratified ...)`; ADR-0198 stays a
+partially-implemented spike).
+
+## Lookback Review Discipline
+
+Multi-PR architectural work accumulates latent defects when each PR
+is reviewed only against its own acceptance criteria.  A hazard
+introduced in PR N can sit dormant until PR N+2 exercises it — by
+which point the substrate is harder to fix and three PRs are
+implicated rather than one.
+
+**Mandatory lookback review** is triggered at three points:
+
+1. **Before starting the next phase of a multi-phase ADR.**  Before
+   any code on Phase N+1, audit Phase N's shipped substrate.  Check
+   for: ADR-doc vs implementation drift, untested predicate paths,
+   wrong=0 hazard surfaces, cross-phase trace/event/rank consistency,
+   things the ADR says that didn't actually ship.
+
+2. **Before merging a stacked PR sequence into main.**  When 2+ PRs
+   stack (PR #420 stacked on #416, PR #423 stacked on #420), the
+   review-each-PR-individually pattern misses cross-PR consistency
+   issues.  Audit the whole stack as one unit before any merge.
+
+3. **After any 3+ PR sequence on the same module or architectural
+   surface.**  When work concentrates on one area, regression risk
+   compounds.  Audit before claiming the surface is "stable" or
+   "ready for the next layer."
+
+**What a lookback review covers** (template — adjust per scope):
+
+- **Documentation drift.**  Does what shipped match what the ADR / brief
+  said would ship?  Signature differences, scope reductions, missing
+  pieces — flag them.
+- **Test coverage gaps.**  Run the test suite under coverage.  For every
+  predicate/branch in a closed-set contract (like
+  `VALID_PREDICATE_NAMES`), confirm at least one test asserts the
+  specific elimination/admission path.  Vacuous tests (assertions
+  that pass under broken impl) are coverage gaps.
+- **Parity gaps.**  When a new implementation claims byte-equivalence
+  with an existing one, exercise BOTH on the same inputs and confirm
+  identical outputs — including failure modes, not just success.
+- **wrong=0 hazard surface.**  Every new code path: under what input
+  conditions could it admit a candidate the prior path would have
+  refused?  Trace upstream to confirm no input class can trigger it.
+  If a class CAN trigger it, build the defensive refusal NOW, before
+  the next phase makes it load-bearing.
+- **Cross-PR consistency.**  Trace event shapes, rank handling,
+  determinism contracts, dataclass invariants — do they compose
+  cleanly across PRs?
+- **Honest LOC accounting.**  Did this phase net add or net remove
+  lines?  ADR claims of "removes ~N lines" only count post-collapse;
+  intermediate phases that ADD substrate before removal happens
+  should be called out.
+
+**Output.**  The review produces a structured report with findings
+categorized as: solid, gaps (no risk), drift (need amendment), and
+hazards (live wrong=0 risks).  Hazards require a fix-before-next-phase
+decision.
+
+**Cost.**  A lookback review on a 3-PR substrate typically takes
+20-40 minutes of focused tool calls.  Skipping it costs more: every
+PR built on an undetected hazard becomes implicated when the hazard
+fires, and the fix has to land across multiple PRs instead of one.
+
+## Architectural Scan Exclusions
+
+The invariant tests in `tests/test_architectural_invariants.py` perform
+full source-tree walks to enforce structural claims (INV-02, INV-21,
+INV-24).  These scans **must** exclude `.claude/` from traversal.
+
+**Why this matters:** Agent operators (Claude Code, Codex, Gemini) create
+worktrees under `.claude/worktrees/`.  Those worktrees contain full copies
+of the source tree — including `vault/`, `chat/`, `generate/`, etc. — and
+will trip every structural invariant that scans for forbidden callsites.
+The failures are silent killers: the tests report real-looking violations
+against files that aren't in the live codebase, poisoning the smoke suite
+and masking actual regressions.
+
+**Maintained exclusion sets** (keep `.claude` in both):
+
+```python
+# INV-02  os.walk exclusion (test_normalize_not_called_outside_gate)
+{".git", ".venv", "__pycache__", ".pytest_cache", ".hypothesis", ".claude"}
+
+# INV-21 / INV-24  rglob exclusion (EXCLUDED_DIRS)
+{"tests", "evals", "benchmarks", "scripts", "docs",
+ "core-rs", ".venv", "__pycache__", ".claude"}
+```
+
+If you add a new source-tree scan to the invariant suite, add `.claude`
+to its exclusion set before the first commit.  Never rely on worktrees
+being pruned — they can persist across sessions and CI runs.
+
 ## PR Checklist
 
 Before opening or merging, answer:

COMMERCIAL_LICENSE.md

@@ -0,0 +1,66 @@
+# CORE Commercial License
+
+**Copyright (c) 2026 Josh Shay / ACB Content**
+
+## When You Need a Commercial License
+
+A Commercial License is required if you intend to:
+
+- Use CORE or any of its components — **including but not limited to**:
+  - the versor engine and Cl(4,1) algebra substrate
+  - the vault memory system and exact CGA recall
+  - the ingest gate (the single normalization site)
+  - the admissibility gate and Forward Semantic Control chain
+  - the holonomy encoder
+  - the epistemic teaching loop (ADR-0055..0057): reviewed
+    TeachingChainProposal, replay-equivalence gate, supersession path
+  - the contemplation loop and decomposer (ADR-0080, ADR-0172)
+  - the math-domain ratification handlers (ADR-0167..0169): LexicalClaim,
+    FrameClaim, CompositionClaim
+  - the composition-pattern registry and registry-driven injector
+    (frame_registry, composition_registry, recognizer-anchor injection)
+  - the audit-as-teaching-evidence corridor (MathReaderRefusalEvidence,
+    proposal/ratification adapters)
+  - the identity and safety pack subsystems (ADR-0027..0029)
+  - the language-pack compiler and verified manifest checksums
+  - the Logos articulation subsystem and the three-language vocabulary
+    manifold (English / Hebrew / Koine Greek)
+  - the Rust algebra backend and any future Rust parity surfaces
+  - any derived or successor implementation of the above
+
+  in a product or service that generates revenue
+- Deploy CORE in a production environment operated by or for a commercial entity
+- Integrate CORE's architecture or derived implementations into proprietary
+  software
+- Offer CORE-based capabilities as a hosted or managed service (SaaS, API, etc.)
+- Use CORE as a research foundation in work owned by or assigned to a
+  for-profit organization
+
+The enumerated subsystems above are illustrative, not limiting. Any module,
+data artifact, ADR-ratified contract, or architectural pattern shipped under
+this repository is covered. New subsystems added in future releases are
+covered automatically under the same terms.
+
+Academic and non-profit research institutions are covered under the standard
+LICENSE and do not require a Commercial License, provided the work is not
+assigned to or funded by a for-profit entity.
+
+## What a Commercial License Grants
+
+- The right to use, integrate, and deploy CORE and its components in commercial
+  products and services
+- The right to keep derivative works proprietary
+- A direct relationship with the author for support, architectural guidance,
+  and ongoing development collaboration
+- Terms are negotiated per engagement — there is no fixed fee structure,
+  as the appropriate arrangement depends on the nature and scale of use
+
+## Contact
+
+All commercial licensing inquiries:
+
+**Josh Shay / ACB Content**
+shayj292@gmail.com
+
+Include a brief description of the intended use. All inquiries are responded
+to directly by the author.

HANDOFF-gpt55-2026-06-03.md

@@ -0,0 +1,49 @@
+# HANDOFF gpt55 2026-06-03
+
+Branch: `codex/ntimes-completeness-guard`
+
+Final commit SHA: reported in the thread final after commit creation.
+
+## File Status
+
+| file | path | status | purpose | ready-to-merge |
+|---|---|---|---|---|
+| recognizer anchor injector | `generate/recognizer_anchor_inject.py` | FINAL | Refusal-only guard preventing no-reference `<N> times ...` comparative multipliers from being injected as `CandidateInitial(value=N, unit="times")`. | Y |
+| completeness guard tests | `tests/test_candidate_graph_completeness_guard.py` | FINAL | Pins the §9 hard negative matrix, with solve/refusal controls. | Y |
+| question-layer gap survey | `docs/analysis/question-layer-gap-survey.md` | FINAL | Canonical audited 44-refusal partition and backlog interpretation. | Y |
+| solver operation coverage | `docs/analysis/solver-operation-coverage.md` | FINAL | Canonical read-only audit of existing solver op coverage and representation gaps. | Y |
+| composition capability scope | `docs/analysis/composition-capability-scope.md` | FINAL | Canonical execution-lane v2 scope for ADR-0174 Phase 5b emission/representation and §9 guard precondition. | Y |
+| comprehension primitive inventory | `docs/analysis/comprehension-primitive-inventory.md` | FINAL | Canonical consolidated inventory and cross-subject leverage map from the execution lane. | Y |
+| handoff | `HANDOFF-gpt55-2026-06-03.md` | FINAL | Merge/readiness manifest for this thread. | Y |
+
+## Validation
+
+Completed on branch `codex/ntimes-completeness-guard`:
+
+- `uv run python -m pytest tests/test_candidate_graph_completeness_guard.py -q`
+  - `21 passed`
+- `uv run python -m pytest tests/test_adr_0131_G2_comparatives.py tests/test_adr_0131_G2a_comparative_verb_widening.py -q`
+  - `30 passed`
+- `uv run python -m pytest tests/test_aggregate_total_question_forms.py tests/test_discrete_count_open_noun_class.py tests/test_adr_0163_d2_discrete_count_injection.py -q`
+  - `59 passed`
+- Train-sample probe through `generate.math_candidate_graph.parse_and_solve`
+  - `6 correct / 44 refused / 0 wrong`
+  - `refused_nonzero_count = 0`
+  - admitted IDs: `0003`, `0014`, `0018`, `0021`, `0024`, `0042`
+
+## New Since Last Message
+
+- Broadened the §9 guard from phrase-specific `times as many|more` matching to the structural captured shape: cardinal immediately followed by `times` inside the discrete-count injector.
+- Added no-reference hard negatives for `3 times the number of apples` and `3 times the apples`.
+- Added explicit safe-refusal controls for no-reference `twice`, no-reference `double`, and case 605.
+- Added canonical execution-lane `composition-capability-scope.md`.
+- Added canonical execution-lane `comprehension-primitive-inventory.md`.
+- Added this handoff manifest.
+
+## Not Done / WIP
+
+- No 5b emission/representation slice was implemented.
+- No <=20-case validation sub-corpus was authored.
+- No solver operation kinds or binding-graph node types were added.
+- No serving/eval/claims-ledger files were changed.
+- Superseded `0001` / `0002` / `0003` patch files from the Opus handoff directory were not committed.

LICENSE

@@ -0,0 +1,57 @@
+CORE Non-Commercial License
+Version 1.0, 2026
+
+Copyright (c) 2026 Josh Shay / ACB Content
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of this software and associated documentation files (the
+"Software"), to use, copy, modify, merge, publish, and distribute the Software,
+subject to the following conditions:
+
+1. NON-COMMERCIAL USE ONLY
+
+   This license permits use solely for non-commercial purposes, including but
+   not limited to: personal projects, academic research, educational use,
+   non-profit work, and open-source contributions. Any use that directly or
+   indirectly generates revenue, is embedded in a commercial product or service,
+   or is deployed in a production environment operated for commercial gain
+   requires a separate Commercial License. See COMMERCIAL_LICENSE.md.
+
+2. ATTRIBUTION
+
+   All copies, modifications, or distributions of the Software, in whole or in
+   part, must retain this copyright notice, this list of conditions, and the
+   following attribution in any documentation, publications, or derivative works:
+
+       Based on CORE (Continuous Orthogonal Resonance Engine)
+       by Josh Shay / ACB Content — https://github.com/assetoverflow/core
+
+3. SHARE-ALIKE
+
+   Any modified version of the Software distributed under this license must be
+   released under these same terms. You may not impose additional restrictions
+   on recipients' exercise of the rights granted herein.
+
+4. NO SUBLICENSING
+
+   You may not sublicense the Software. Any party wishing to use the Software
+   under terms other than those stated here must obtain a license directly from
+   the copyright holder.
+
+5. NO WARRANTY
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING
+   FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+   IN THE SOFTWARE.
+
+6. TERMINATION
+
+   This license is automatically terminated if you violate any of its terms.
+   Upon termination, you must destroy all copies of the Software in your
+   possession.
+
+For commercial licensing inquiries: shayj292@gmail.com

README.md

@@ -27,6 +27,20 @@ When facing a design decision, the world offers two visible options: use what al
 
 ---
 
+## Native Substrate Direction — Python, Rust, Zig
+
+CORE is not moving toward a wholesale Zig rewrite. The architecture is moving toward a stricter native-substrate boundary:
+
+- **Python** remains the semantic source of truth: cognition runtime, teaching/review workflows, pack ratification, eval harnesses, and Workbench/operator tooling.
+- **Rust** remains the incumbent native algebra backend: Cl(4,1) products, versor operations, CGA inner product, exact recall, and diffusion surfaces already proven by parity gates.
+- **Zig** is a candidate material for the next native substrate layer: Delta-CRDT arenas/deltas/merge kernels, deterministic modality compilers such as `audio_core_v1`, stable C ABI surfaces, edge-native ingestion, and selected exact recall challenge kernels only after parity and benchmark proof.
+
+The rule is component law, not language preference. Zig may enter where explicit allocation, deterministic buffer ownership, C ABI clarity, and edge-native deployment materially strengthen CORE. Zig must not replace review-gated semantics, introduce approximate recall, hide repair in native code, or turn teacher/shadow models into substrate.
+
+Decision package: [`docs/zig/README.md`](docs/zig/README.md). Adoption gates: [`docs/zig/adoption-gates.md`](docs/zig/adoption-gates.md).
+
+---
+
 ## The Truth-Seeking Schema
 
 Co-equal with the algebraic substrate. CORE's epistemic schema is a foundational architectural commitment: every claim that enters the runtime field carries a typed position in a revision graph (`SPECULATIVE`, `COHERENT`, `CONTESTED`, `FALSIFIED`); coherence — not source authority — is the only admission signal; no claim is ever locked, even when COHERENT; identity cannot be rewritten by content; and exactly one mutation path admits knowledge, enforced by a CI-level architectural-invariant test.
@@ -64,7 +78,40 @@ English establishes the operational base. Hebrew and Koine Greek bring the hidde
 ```bash
 pip install -e ".[dev]"
 pytest tests/test_versor_closure.py        # the core invariant — must pass first
-pytest tests/                              # full suite (~4 minutes, 1099 tests)
+pytest tests/                              # full suite (~8,337 tests; some pre-existing reds — see docs/test-debt-quarantine.md)
+```
+
+### Watch the flywheel turn — one command
+
+For a public-facing reproduction of the core thesis, in **four
+falsifiable scenes**:
+
+```bash
+core demo flywheel
+```
+
+This runs end-to-end on the canonical pack:
+
+1. **Ratify** — `apply_composition_claim()` writes a reviewed JSONL
+   artifact; RAT-1's `compile_pack` regenerates the runtime
+   `compositions.jsonl` + updates the manifest checksum.
+2. **Load** — `composition_registry` reads the new entry on the next
+   runtime turn.
+3. **Solve** — a real problem (`"Lilibeth fills 6 baskets where each
+   basket holds 50 strawberries. How many strawberries does Lilibeth
+   have?"`) admits via the matcher → injector → admission chain and
+   produces `answer=300`.
+4. **Hazard** — case 0050 (the `wrong=0` canary) remains refused —
+   no SAFE composition category can convert it from refused to
+   wrong.
+
+Every scene is byte-deterministic; the canonical pack is read-only
+throughout; the demo mutates only a synthetic test pack in a
+tempdir. See [`evals/flywheel_demo/run_tour.py`](evals/flywheel_demo/run_tour.py).
+
+```bash
+core teaching coverage --use-reader        # per-shape histogram + hazard pin status
+core teaching coverage --use-reader --delta  # diff vs HEAD's committed report.json
 ```
 
 ### CLI
@@ -261,11 +308,16 @@ ADR-0114a's 10 anti-overfitting proof obligations are all discharged for the
 it does not confabulate. The zero-confabulation property holds against the external
 benchmark.
 
-**ADR-0120 (first `expert` promotion contract) is the next gate.** It will set the
-numeric expert threshold and ε, require all 10 ADR-0114a obligations as hard gates,
-and sign the first `expert_claims` entry — or defer honestly if the correct_rate
-gate is not yet met. **No domain is at `expert` today.** That status string remains
-reserved namespace.
+**ADR-0120 (the first `expert` promotion contract) has since been built and
+exercised.** On 2026-05-23 `mathematics_logic` was signed and briefly promoted to
+`expert` — then **auto-reverted to `audit-passed`** when its evidence bundle
+drifted: a *non-gating* GSM8K coverage metric moved, which changed the
+evidence-derived digest and invalidated the signature. That revert is the
+contract's fail-closed property working as designed — CORE revoked its own expert
+claim rather than carry a stale one. **No domain is at `expert` today**, and when
+`expert` is held at all it rests on CORE-authored lanes, not external GSM8K. Full
+record: [ADR-0200](docs/decisions/ADR-0200-expert-claim-reconciliation.md) and
+[`docs/claims_ledger.md`](docs/claims_ledger.md).
 
 To run the GSM8K math eval lane:
 

algebra/__init__.py

@@ -1,5 +1,19 @@
 from .cl41 import geometric_product, reverse, grade_project, scalar_part, norm_squared, basis_vector
 from .versor import versor_apply, normalize_to_versor, versor_condition
-from .cga import cga_inner, outer_product, is_null, null_project, embed_point
+from .cga import (
+    EMBED_EXACT_MAX,
+    cga_inner,
+    outer_product,
+    is_null,
+    null_project,
+    embed_point,
+    read_scalar_e1,
+    blade_grade,
+    blade_norm,
+    graded_wedge,
+    is_incident,
+    dual,
+    meet,
+)
 from .holonomy import holonomy_encode, holonomy_similarity
 from .rotor import word_transition_rotor

algebra/cga.py

@@ -19,13 +19,34 @@ No cosine similarity. No L2 norm. No approximate indexing.
 """
 
 import numpy as np
-from .cl41 import geometric_product, scalar_part, basis_vector, N_COMPONENTS
+from .cl41 import (
+    geometric_product,
+    grade_project,
+    reverse,
+    scalar_part,
+    N_COMPONENTS,
+)
+
+# The unit pseudoscalar I5 = e1 e2 e3 e4 e5 (the grade-5 blade, component 31).
+# In Cl(4,1) with signature (+,+,+,+,-), I5^2 = -1, so I5^{-1} = -I5. Used by
+# ``dual`` / ``meet``. Module-level singleton; never mutated.
+_PSEUDOSCALAR_INDEX = 31
+_I5 = np.zeros(N_COMPONENTS, dtype=np.float64)
+_I5[_PSEUDOSCALAR_INDEX] = 1.0
 
 # Basis-vector component indices for e4/e5 inside the grade-1 block.
 # component 1=e1, 2=e2, 3=e3, 4=e4, 5=e5.
 _E4_IDX = 4
 _E5_IDX = 5
 
+# Pinned magnitude ceiling for f64-exact embedding + read-back (Phase 0A).
+# Below this bound, ``embed_point(..., dtype=np.float64)`` round-trips integer
+# coordinates exactly through ``read_scalar_e1`` and the conformal distance metric
+# stays exact (proven in tests/test_cga_f64_exactness.py). The field-reasoner reader
+# REFUSES any quantity whose magnitude exceeds this bound; the refusal lives in the
+# reader — this module only states the bound. Generous vs GSM8K (quantities ~< 1e5).
+EMBED_EXACT_MAX: int = 1_000_000
+
 
 def cga_inner(X: np.ndarray, Y: np.ndarray) -> float:
     """
@@ -38,10 +59,19 @@ def cga_inner(X: np.ndarray, Y: np.ndarray) -> float:
 
 
 def outer_product(X: np.ndarray, Y: np.ndarray) -> np.ndarray:
-    """
-    Outer (wedge) product: X ^ Y.
-    For a prompt versor X_p and response versor X_r,
-    X_p ^ X_r is a grade-2 object encoding their geometric relationship.
+    """The antisymmetric (commutator) product ``0.5 * (XY - YX)``.
+
+    HONEST CONTRACT: this equals the grade-raising wedge ``X ^ Y`` **only when both
+    operands are grade 1** (vectors). For higher-grade operands it is the *commutator*
+    (Lie bracket), which is NOT the wedge — in particular it does NOT build a k-blade
+    by repeated application (a bivector commuted with a vector collapses the grade-3
+    part to grade 1). Existing callers use the result as an opaque, deterministic
+    relationship feature (folded into a scalar via :func:`cga_inner`), where the
+    commutator is well-defined regardless; none read it by grade.
+
+    For the true grade-raising exterior product (lines/planes/incidence) use
+    :func:`graded_wedge`. (Renamed contract only — behaviour is unchanged, so every
+    current caller is byte-identical.)
     """
     XY = geometric_product(X, Y)
     YX = geometric_product(Y, X)
@@ -62,18 +92,25 @@ def null_project(X: np.ndarray) -> np.ndarray:
     return embed_point(euclidean)
 
 
-def embed_point(x: np.ndarray) -> np.ndarray:
+def embed_point(x: np.ndarray, *, dtype: "np.typing.DTypeLike" = np.float32) -> np.ndarray:
     """
     Embed a Euclidean point x in R^3 into the CGA null cone.
 
     X = x + n_o + 0.5|x|^2 n_inf,
     where n_o = 0.5(e5-e4), n_inf = e4+e5.
+
+    ``dtype`` defaults to ``float32`` so every existing caller is byte-unchanged.
+    The field-reasoner reader passes ``dtype=np.float64`` to get an exact embedding:
+    ``geometric_product`` already preserves float64 (``np.result_type``), so the
+    only thing that forced f32 was this construction. f32 silently collapses the
+    ``n_o`` weight past ~1e4 (the ``0.5|x|^2`` terms lose the ``±1``); f64 keeps it
+    exact up to :data:`EMBED_EXACT_MAX` (see tests/test_cga_f64_exactness.py).
     """
-    x = np.asarray(x, dtype=np.float32)
+    x = np.asarray(x, dtype=dtype)
     assert len(x) == 3, "embed_point expects a 3D vector"
 
     x_sq = float(np.dot(x, x))
-    result = np.zeros(N_COMPONENTS, dtype=np.float32)
+    result = np.zeros(N_COMPONENTS, dtype=dtype)
     result[1:4] = x
 
     # n_o + 0.5|x|^2 n_inf
@@ -82,3 +119,108 @@ def embed_point(x: np.ndarray) -> np.ndarray:
     result[_E4_IDX] = 0.5 * (x_sq - 1.0)
     result[_E5_IDX] = 0.5 * (x_sq + 1.0)
     return result
+
+
+def read_scalar_e1(X: np.ndarray) -> float:
+    """Projective dehomogenization on the e1 axis — the exact, weight-invariant
+    read-back of a scalar coordinate from a (possibly dilated) conformal point.
+
+    A point at coordinate ``v`` on the e1 number line embeds as
+    ``X = v*e1 + n_o + 0.5 v^2 n_inf``; a uniform conformal dilation by ``k``
+    scales the whole null vector. The coordinate is recovered as
+    ``e1_coefficient / n_o_weight`` where the n_o weight is ``X[e5] - X[e4]``
+    (== 1 for an un-dilated point), so any dilation weight divides out. This is
+    the correct read-back for weight-changing operators; a raw distance-from-origin
+    is wrong for them.
+
+    Raises ``ValueError`` on a degenerate (zero) n_o weight — a point at infinity
+    or an f32 weight-collapse — rather than returning a silently wrong value.
+    """
+    no_weight = float(X[_E5_IDX] - X[_E4_IDX])
+    if no_weight == 0.0:
+        raise ValueError(
+            "read_scalar_e1: degenerate n_o weight (point at infinity or f32 collapse)"
+        )
+    return float(X[1]) / no_weight
+
+
+# ---------------------------------------------------------------------------
+# Incidence algebra — the corrected grade-raising wedge, dual, and meet.
+# These let the inner product operate on RELATIONS among entities (lines, planes,
+# incidence) rather than only pairwise point distance. Built only from the existing
+# Cl(4,1) primitives (geometric_product, grade_project) + the pseudoscalar; they add
+# no normalization, no approximation, and leave the versor_condition path untouched
+# (flats are null-cone outer products, not unit versors).
+# ---------------------------------------------------------------------------
+
+_MAX_GRADE = 5  # Cl(4,1): grades 0..5
+
+
+def blade_grade(X: np.ndarray) -> int:
+    """The single grade of a homogeneous blade. Raises if X is zero or grade-mixed.
+
+    Grade is detected by EXACT nonzero (no tolerance): integer-coordinate embeddings
+    produce exact integer blades in float64, so a grade block is exactly 0 or not.
+    """
+    grades = [k for k in range(_MAX_GRADE + 1) if np.any(grade_project(X, k))]
+    if len(grades) != 1:
+        raise ValueError(f"not a homogeneous blade: nonzero grades {grades}")
+    return grades[0]
+
+
+def graded_wedge(X: np.ndarray, Y: np.ndarray) -> np.ndarray:
+    """The true grade-raising exterior product ``X ^ Y`` for homogeneous blades.
+
+    ``X ^ Y = <X Y>_{grade(X)+grade(Y)}`` — the top-grade part of the geometric
+    product. Unlike :func:`outer_product` (the commutator) this composes correctly:
+    ``graded_wedge(graded_wedge(P, Q), n_inf)`` builds the grade-3 line P^Q^n_inf,
+    and so on. If the grades sum past the pseudoscalar (>5) the wedge is identically
+    zero. For two grade-1 vectors it agrees with :func:`outer_product` exactly.
+    """
+    gx, gy = blade_grade(X), blade_grade(Y)
+    if gx + gy > _MAX_GRADE:
+        return np.zeros(N_COMPONENTS, dtype=geometric_product(X, Y).dtype)
+    return grade_project(geometric_product(X, Y), gx + gy)
+
+
+def blade_norm(X: np.ndarray) -> float:
+    """Reversion norm ``sqrt(|<X reverse(X)>_0|)`` — zero iff X is the zero blade."""
+    return float(np.sqrt(abs(scalar_part(geometric_product(X, reverse(X))))))
+
+
+def is_incident(point: np.ndarray, flat: np.ndarray) -> bool:
+    """Exact incidence test: is ``point`` on ``flat`` (a line/plane OPNS blade)?
+
+    True iff ``point ^ flat == 0`` EXACTLY (every component zero) — no float
+    tolerance to admit (the wrong=0 discipline: a near-incident point is REFUSED,
+    not admitted). Exact for integer-coordinate points within ``EMBED_EXACT_MAX``.
+    """
+    return not bool(np.any(graded_wedge(point, flat)))
+
+
+def dual(X: np.ndarray) -> np.ndarray:
+    """Pseudoscalar dual ``X * I5^{-1}`` (``I5^{-1} = -I5`` since ``I5^2 = -1``).
+
+    Maps a grade-k blade to grade ``5-k``. Involutive up to sign:
+    ``dual(dual(X)) == -X``.
+    """
+    return geometric_product(X, -_I5)
+
+
+def meet(A: np.ndarray, B: np.ndarray) -> np.ndarray:
+    """The meet (intersection) ``dual(dual(A) ^ dual(B))`` of two homogeneous blades.
+
+    Correct for operands in GENERAL POSITION whose join spans the space — e.g. two
+    non-parallel planes meet in their intersection line. The grade of the result is
+    ``grade(A)+grade(B)-5``.
+
+    HONEST ENVELOPE: this full-pseudoscalar meet DEGENERATES for operands that share
+    a proper subspace (e.g. two coplanar lines, two parallel planes): the inner wedge
+    ``dual(A) ^ dual(B)`` is then identically zero, so ``meet`` returns the **zero
+    multivector** — a detectable signal of "no transversal meet", never a silently
+    wrong value. The general intersection of such operands (e.g. the point where two
+    coplanar lines cross) requires the *join-relative* meet, which is deliberately
+    NOT implemented here; the caller MUST check ``blade_norm(result) == 0`` and treat
+    zero as degenerate/refuse rather than as a geometric object.
+    """
+    return dual(graded_wedge(dual(A), dual(B)))

algebra/versor.py

@@ -82,14 +82,37 @@ def unitize_versor(v: np.ndarray) -> np.ndarray:
 
 
 def normalize_to_versor(v: np.ndarray) -> np.ndarray:
+    """Encode v as a closed versor for the ingest-gate boundary.
+
+    Issue #300: certain ordinary English token combinations
+    (declarative-with-quantity + transfer + "How many" question)
+    produced a residue that ``unitize_versor`` resolved without raising
+    but whose ``versor_condition`` cleared the `bad_residue` heuristic
+    while still landing just above the gate's 1e-6 threshold
+    (observed: 1.02e-06 -- 2.12e-06).  The gate's downstream check
+    then crashed.
+
+    Mirror the strict-closure pattern in ``_runtime_closed`` /
+    ``_close_applied_versor``: if unitization succeeded but the
+    result still fails the public ``versor_condition <
+    _RUNTIME_CLOSURE_TOLERANCE`` contract, project through the
+    deterministic construction map instead of returning the drifted
+    candidate.  Threshold stays at 1e-6 (CLAUDE.md non-negotiable);
+    the construction-boundary is where the drift is repaired, not
+    the gate.
+    """
     dtype = _array_dtype(v)
     try:
-        return unitize_versor(v)
+        candidate = unitize_versor(v)
     except ValueError as exc:
         if "bad_residue" not in str(exc):
             raise
         return _seed_to_rotor(v, dtype)
 
+    if versor_condition(candidate) >= _RUNTIME_CLOSURE_TOLERANCE:
+        return _seed_to_rotor(v, dtype)
+    return candidate
+
 
 def construction_seed_versor(v: np.ndarray) -> np.ndarray:
     """Map a raw construction seed into the closed versor manifold."""

benchmarks/articulation.py

@@ -270,12 +270,16 @@ def bench_determinism(runs: int = 20) -> tuple[list[DeterminismCase], bool]:
 def bench_footprint(
     turns: int = 200,
     sample_every: int = 25,
+    warmup_turns: int = 0,
 ) -> tuple[list[FootprintSample], int, int, int, float]:
-    """Drive a single ChatRuntime through ``turns`` cold-start prompts
-    and sample RSS every ``sample_every`` turns.
+    """Drive a single ChatRuntime through ``turns`` prompts and sample
+    RSS every ``sample_every`` turns.
 
     Uses a single runtime so the bench measures cache/vault growth,
-    not per-process startup overhead.
+    not per-process startup overhead.  Pass ``warmup_turns`` to drive
+    the runtime through lazy initialisation before the measurement
+    window opens (useful for short test runs where cold-start allocation
+    would otherwise dominate the per-turn delta).
     """
     import psutil
     from chat.runtime import ChatRuntime
@@ -283,12 +287,15 @@ def bench_footprint(
     proc = psutil.Process()
     rt = ChatRuntime()
 
+    prompts = [p for _, p in INTENT_PROBE_PROMPTS]
+    n = len(prompts)
+    for w in range(warmup_turns):
+        rt.chat(prompts[w % n])
+
     samples: list[FootprintSample] = []
     start = proc.memory_info().rss
     samples.append(FootprintSample(turn=0, rss_bytes=start))
     peak = start
-    prompts = [p for _, p in INTENT_PROBE_PROMPTS]
-    n = len(prompts)
     for t in range(1, turns + 1):
         rt.chat(prompts[t % n])
         if t % sample_every == 0 or t == turns:

chat/pack_resolver.py

@@ -50,6 +50,14 @@ DEFAULT_RESOLVABLE_PACK_IDS: tuple[str, ...] = (
     "en_core_spatial_v1",
     "en_core_causation_v1",
     "en_core_polarity_v1",
+    # Foundation-curriculum syntax substrate.  Mounted AFTER the
+    # high-frequency content packs so it is purely additive: every lemma
+    # it owns is disjoint from earlier mounted packs.  Two colliders were
+    # renamed at authoring time so syntax never steals prior resolution
+    # (`agent`→`agent_role`, owned by en_core_meta_v1; `comparison`→
+    # `comparison_relation`, owned by en_core_cognition_v1).  `negation`
+    # is kept bare: no *mounted* pack owned it, so syntax now grounds it.
+    "en_core_syntax_v1",
     "en_core_relations_v1",
     "en_core_relations_v2",
     # ADR-0073c — synthetic English anchor lemmas for cross-lang collapse.

chat/telemetry.py

@@ -256,6 +256,75 @@ def format_correction_event_jsonl(correction_result, **kwargs) -> str:
     return json.dumps(payload, sort_keys=True, separators=(",", ":"))
 
 
+# ---------- ADR-0158 — reboot-event serializer ----------
+
+
+def serialize_reboot_event(
+    *,
+    restored_turn_count: int,
+    stored_revision: str,
+    current_revision: str,
+    recognizers_count: int,
+    candidates_count: int,
+    timestamp: str | None = None,
+) -> dict[str, object]:
+    """Produce a JSON-safe audit dict for an engine-state reboot recovery.
+
+    Written to the telemetry JSONL when ``ChatRuntime`` loads an existing
+    checkpoint at startup (L10 scope §Sub-question 3).  Lets future audit
+    reconstruct when this engine instance lost and regained its lifetime.
+
+    ``revision_matched`` is True iff both revisions are known and equal,
+    indicating the checkpoint was written by the same code that is running.
+    False means the operator should verify the loaded state is still valid
+    (the W-023 ``RuntimeWarning`` will already have fired).
+
+    Trust boundary: no surface text or tokens; metadata only.
+    """
+    revision_matched = bool(
+        stored_revision not in ("unknown", "")
+        and current_revision not in ("unknown", "")
+        and stored_revision == current_revision
+    )
+    out: dict[str, object] = {
+        "type": "reboot",
+        "restored_turn_count": int(restored_turn_count),
+        "stored_revision": str(stored_revision),
+        "current_revision": str(current_revision),
+        "revision_matched": revision_matched,
+        "recognizers_count": int(recognizers_count),
+        "candidates_count": int(candidates_count),
+    }
+    if timestamp is not None:
+        out["timestamp"] = str(timestamp)
+    return out
+
+
+def format_reboot_event_jsonl(
+    *,
+    restored_turn_count: int,
+    stored_revision: str,
+    current_revision: str,
+    recognizers_count: int,
+    candidates_count: int,
+    timestamp: str | None = None,
+) -> str:
+    """Serialize a reboot event as one deterministic JSONL line.
+
+    ``"type": "reboot"`` discriminates this line from turn and correction
+    events at consume time without changing the sink contract.
+    """
+    payload = serialize_reboot_event(
+        restored_turn_count=restored_turn_count,
+        stored_revision=stored_revision,
+        current_revision=current_revision,
+        recognizers_count=recognizers_count,
+        candidates_count=candidates_count,
+        timestamp=timestamp,
+    )
+    return json.dumps(payload, sort_keys=True, separators=(",", ":"))
+
+
 # ---------- sink protocol ----------
 
 
@@ -404,8 +473,10 @@ __all__ = [
     "JsonlFileSink",
     "TurnEventSink",
     "format_correction_event_jsonl",
+    "format_reboot_event_jsonl",
     "format_turn_event_jsonl",
     "format_verdict_summary",
     "serialize_correction_event",
+    "serialize_reboot_event",
     "serialize_turn_event",
 ]

conftest.py

@@ -0,0 +1,64 @@
+"""Project-root conftest — quarantine registry for known-failing tests.
+
+The QUARANTINE set lists test IDs that are pre-existing failures
+predating the substrate-liveness audit work (verified via bisect
+against c1a1b7a, the commit immediately before the first W-* PR
+of 2026-05-24). The CI gate at .github/workflows/full-pytest.yml
+runs ``pytest -m "not quarantine"`` so these failures do not block
+PRs, but the suite is a ratchet: a quarantined test removed from
+this set must pass on its own merits.
+
+See docs/test-debt-quarantine.md for cluster diagnoses, removal
+policy, and the per-test rationale.
+
+To remove a test from quarantine:
+  1. Land a PR that makes the test pass.
+  2. Delete its entry from QUARANTINE in the same PR.
+  3. The full-pytest CI gate will now require it to keep passing.
+
+Adding a test to QUARANTINE is strongly discouraged. If a new
+failure surfaces, the right default is to fix it in the PR that
+caused it — not to quarantine. The set should only shrink.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+import engine_state
+
+
+@pytest.fixture(autouse=True)
+def _isolate_engine_state_default(tmp_path_factory, monkeypatch):
+    """Isolate the default engine-state checkpoint dir per test.
+
+    A bare ``ChatRuntime()`` (no ``engine_state_path``) falls back to
+    ``engine_state._DEFAULT_DIR`` — the shared repo ``engine_state/`` directory.
+    Tests must not share that mutable dir: one test's checkpoint (recognizers,
+    candidates, the stamped engine-identity, and — under resume mode — the lived
+    session_state) leaks into another test's fresh-state assumptions (and, since
+    L11, raises spurious identity-continuity-break warnings when a later test
+    boots under a different identity over the same dir). Point the default at a
+    fresh per-test temp dir. Tests passing an explicit ``engine_state_path`` are
+    unaffected; within one test, repeated ``ChatRuntime()`` share this dir.
+    """
+    isolated = tmp_path_factory.mktemp("engine_state_default")
+    monkeypatch.setattr(engine_state, "_DEFAULT_DIR", isolated)
+
+
+QUARANTINE: frozenset[str] = frozenset()
+
+
+def pytest_collection_modifyitems(config, items):
+    """Stamp the quarantine marker on any test whose nodeid is listed
+    in QUARANTINE.  Tests not in the set are unaffected.
+
+    The CI gate runs ``pytest -m "not quarantine"`` so quarantined
+    tests are silently skipped in CI.  Local ``pytest`` runs include
+    them by default (still useful for debugging individual fixes).
+    """
+    _ = config  # pluggy hook signature requires the name `config`; not used here
+    quarantine_marker = pytest.mark.quarantine
+    for item in items:
+        if item.nodeid in QUARANTINE:
+            item.add_marker(quarantine_marker)

contemplation/runs/.gitkeep

@@ -0,0 +1,2 @@
+# CI-authored contemplation reports land here via ADR-0155.
+# Operator review of each PR is the ratification gate.

contemplation/runs/2026-05-26T015527Z.json

@@ -0,0 +1,100 @@
+{
+  "active_corpus_byte_identical": true,
+  "after": {
+    "grounding_source": "teaching",
+    "surface": "narrative \u2014 teaching-grounded (cognition_chains_v1): rhetoric.narrative; language.discourse. narrative reveals meaning (cognition.meaning). No session evidence yet."
+  },
+  "all_claims_supported": true,
+  "before": {
+    "grounding_source": "none",
+    "surface": "I don't know \u2014 insufficient grounding for that yet."
+  },
+  "cold_subject": "narrative",
+  "engine_connective": "reveals",
+  "engine_object": "meaning",
+  "learning_arc_closed": true,
+  "prompt": "Why does narrative exist?",
+  "scenes": [
+    {
+      "claim": "No (narrative, cause) chain in corpus \u2014 runtime returns disclosure.  Checkpoint enriches and persists the candidate.",
+      "detail": {
+        "candidates_persisted": 1,
+        "grounding_source": "none",
+        "prompt": "Why does narrative exist?",
+        "surface": "I don't know \u2014 insufficient grounding for that yet."
+      },
+      "scene": "S1_cold_session"
+    },
+    {
+      "claim": "contemplate() structured the candidate autonomously: sub_questions enumerate corpus-derived chain candidates.  The (narrative, cause, reveals, meaning) chain was engine-identified.",
+      "detail": {
+        "candidate_id": "2795ac86bb692389ba816024c30e9928b3d92de11267d3fe34511a7ab286b8e8",
+        "claim_domain": "factual",
+        "engine_chain": {
+          "connective": "reveals",
+          "intent": "cause",
+          "object": "meaning",
+          "subject": "narrative"
+        },
+        "engine_chain_found": true,
+        "engine_derived_chains_count": 15,
+        "polarity": "undetermined",
+        "sub_questions_count": 15
+      },
+      "scene": "S2_checkpoint_enrichment"
+    },
+    {
+      "claim": "Connective and object were engine-derived from corpus decomposition.  source.kind='contemplation'.  Replay gate passed.  State: pending.",
+      "detail": {
+        "proposal_id": "05e167163c1f22c1d8eb8f5418ae795d",
+        "proposed_chain": {
+          "connective": "reveals",
+          "intent": "cause",
+          "object": "meaning",
+          "subject": "narrative"
+        },
+        "replay_evidence": {
+          "baseline": {
+            "intent_accuracy": 1.0,
+            "surface_groundedness": 1.0,
+            "term_capture_rate": 1.0,
+            "versor_closure_rate": 1.0
+          },
+          "candidate": {
+            "intent_accuracy": 1.0,
+            "surface_groundedness": 1.0,
+            "term_capture_rate": 1.0,
+            "versor_closure_rate": 1.0
+          },
+          "regressed_metrics": [],
+          "replay_equivalent": true
+        },
+        "source_kind": "contemplation",
+        "state": "pending"
+      },
+      "scene": "S3_engine_authored_proposal"
+    },
+    {
+      "claim": "accept_proposal is the sole corpus-write surface.  Transient path leaves active corpus byte-identical.",
+      "detail": {
+        "active_corpus_byte_identical": true,
+        "chain_id": "cause_narrative_reveals_meaning",
+        "transient_corpus": "/tmp/learning_arc_demo_6qskpe29/cognition_chains_v1.jsonl",
+        "transient_lines_after": 23,
+        "transient_lines_before": 22
+      },
+      "scene": "S4_operator_ratifies"
+    },
+    {
+      "claim": "Same prompt now produces a deterministic teaching-grounded surface containing the engine-authored chain's subject / connective / object.",
+      "detail": {
+        "contains_connective_reveals": true,
+        "contains_object_meaning": true,
+        "contains_subject": true,
+        "grounding_source": "teaching",
+        "surface": "narrative \u2014 teaching-grounded (cognition_chains_v1): rhetoric.narrative; language.discourse. narrative reveals meaning (cognition.meaning). No session evidence yet."
+      },
+      "scene": "S5_grounded_session"
+    }
+  ]
+}

contemplation/runs/2026-05-26T103018Z.json

@@ -0,0 +1,100 @@
+{
+  "active_corpus_byte_identical": true,
+  "after": {
+    "grounding_source": "teaching",
+    "surface": "narrative \u2014 teaching-grounded (cognition_chains_v1): rhetoric.narrative; language.discourse. narrative reveals meaning (cognition.meaning). No session evidence yet."
+  },
+  "all_claims_supported": true,
+  "before": {
+    "grounding_source": "none",
+    "surface": "I don't know \u2014 insufficient grounding for that yet."
+  },
+  "cold_subject": "narrative",
+  "engine_connective": "reveals",
+  "engine_object": "meaning",
+  "learning_arc_closed": true,
+  "prompt": "Why does narrative exist?",
+  "scenes": [
+    {
+      "claim": "No (narrative, cause) chain in corpus \u2014 runtime returns disclosure.  Checkpoint enriches and persists the candidate.",
+      "detail": {
+        "candidates_persisted": 1,
+        "grounding_source": "none",
+        "prompt": "Why does narrative exist?",
+        "surface": "I don't know \u2014 insufficient grounding for that yet."
+      },
+      "scene": "S1_cold_session"
+    },
+    {
+      "claim": "contemplate() structured the candidate autonomously: sub_questions enumerate corpus-derived chain candidates.  The (narrative, cause, reveals, meaning) chain was engine-identified.",
+      "detail": {
+        "candidate_id": "2795ac86bb692389ba816024c30e9928b3d92de11267d3fe34511a7ab286b8e8",
+        "claim_domain": "factual",
+        "engine_chain": {
+          "connective": "reveals",
+          "intent": "cause",
+          "object": "meaning",
+          "subject": "narrative"
+        },
+        "engine_chain_found": true,
+        "engine_derived_chains_count": 15,
+        "polarity": "undetermined",
+        "sub_questions_count": 15
+      },
+      "scene": "S2_checkpoint_enrichment"
+    },
+    {
+      "claim": "Connective and object were engine-derived from corpus decomposition.  source.kind='contemplation'.  Replay gate passed.  State: pending.",
+      "detail": {
+        "proposal_id": "05e167163c1f22c1d8eb8f5418ae795d",
+        "proposed_chain": {
+          "connective": "reveals",
+          "intent": "cause",
+          "object": "meaning",
+          "subject": "narrative"
+        },
+        "replay_evidence": {
+          "baseline": {
+            "intent_accuracy": 1.0,
+            "surface_groundedness": 1.0,
+            "term_capture_rate": 1.0,
+            "versor_closure_rate": 1.0
+          },
+          "candidate": {
+            "intent_accuracy": 1.0,
+            "surface_groundedness": 1.0,
+            "term_capture_rate": 1.0,
+            "versor_closure_rate": 1.0
+          },
+          "regressed_metrics": [],
+          "replay_equivalent": true
+        },
+        "source_kind": "contemplation",
+        "state": "pending"
+      },
+      "scene": "S3_engine_authored_proposal"
+    },
+    {
+      "claim": "accept_proposal is the sole corpus-write surface.  Transient path leaves active corpus byte-identical.",
+      "detail": {
+        "active_corpus_byte_identical": true,
+        "chain_id": "cause_narrative_reveals_meaning",
+        "transient_corpus": "/tmp/learning_arc_demo_z8x_pn39/cognition_chains_v1.jsonl",
+        "transient_lines_after": 23,
+        "transient_lines_before": 22
+      },
+      "scene": "S4_operator_ratifies"
+    },
+    {
+      "claim": "Same prompt now produces a deterministic teaching-grounded surface containing the engine-authored chain's subject / connective / object.",
+      "detail": {
+        "contains_connective_reveals": true,
+        "contains_object_meaning": true,
+        "contains_subject": true,
+        "grounding_source": "teaching",
+        "surface": "narrative \u2014 teaching-grounded (cognition_chains_v1): rhetoric.narrative; language.discourse. narrative reveals meaning (cognition.meaning). No session evidence yet."
+      },
+      "scene": "S5_grounded_session"
+    }
+  ]
+}

core-rs/src/vault.rs

@@ -9,7 +9,9 @@
 //! The CGA inner product in Cl(4,1) is structurally diagonal with
 //! ±1 metric values, so per-versor scoring collapses to
 //!
-//!     sum_i metric[i] * v[i] * q[i]
+//! ```text
+//! sum_i metric[i] * v[i] * q[i]
+//! ```
 //!
 //! which is 32 multiplies + 32 adds, not the 1024-op full
 //! geometric_product the reference scalar path computes.  Bit-
@@ -150,3 +152,205 @@ pub fn vault_reproject_parallel(versors: &[[f32; 32]]) -> Vec<[f32; 32]> {
     use crate::cga::null_project_raw;
     versors.par_iter().map(|v| null_project_raw(v)).collect()
 }
+
+// ===========================================================================
+// Delta-CRDT substrate (ADR-0180 §2.1 / §2.2)
+// ===========================================================================
+//
+// `LocalArena` is the thread-local, share-nothing write cache each modality
+// adapter accumulates into (ADR-0180 §2.1). It never touches global state, so
+// it needs no locks: concurrency safety comes from each thread owning its own
+// arena, not from synchronisation.
+//
+// `SemilatticeDelta` is the join-semilattice contract (ADR-0180 §2.2): the
+// merge of deltas is commutative, associative, and idempotent. The Merge
+// Kernel folds deltas into a single content-addressed, deduplicated, totally
+// ordered set — the order-invariant state the Vault consumes. Ordering is by
+// content (the versor's IEEE-754 bit pattern + provenance bytes), never
+// arrival order, per the §2.2 content-addressed-tiebreak amendment
+// (2026-05-29). That is precisely what makes
+// `hash(Sequential_Ingest) == hash(Concurrent_CRDT_Ingest)` (§4.3) reachable:
+// the merged state cannot depend on the order deltas arrived in.
+//
+// This is the pure-CPU Rust substrate (§1.5.5); no MLX/UMA handshake and no
+// Python binding land here — those are downstream (ADR-0180 §4.1 item 2, and
+// ADR-0181 PR-5 respectively).
+
+use std::cmp::Ordering;
+
+/// One write accumulated into an arena: a Cl(4,1) versor plus opaque
+/// provenance bytes. Provenance is part of the content key, so two writes of
+/// the same versor under different provenance are distinct semilattice
+/// elements (both retained); two byte-identical writes collapse (the
+/// idempotence leg of the join semilattice, ADR-0180 §2.2).
+#[derive(Clone, Debug)]
+pub struct ArenaEntry {
+    pub versor: [f32; 32],
+    pub provenance: Vec<u8>,
+}
+
+impl ArenaEntry {
+    pub fn new(versor: [f32; 32], provenance: Vec<u8>) -> Self {
+        Self { versor, provenance }
+    }
+}
+
+/// Total, arrival-independent content order over arena entries.
+///
+/// f32 has no total `Ord` (NaN is unordered), so we compare the raw IEEE-754
+/// bit patterns — which is exactly what "content-addressed" means here:
+/// byte-identical versors sort together and deduplicate, and `-0.0`/`+0.0`
+/// (distinct bytes) are treated as distinct content, as a byte-addressed merge
+/// requires. Ties on the versor fall through to the provenance bytes, giving a
+/// total order (ADR-0180 §2.2 amendment, mirroring ADR-0181 §2.2's merge key).
+fn content_cmp(a: &ArenaEntry, b: &ArenaEntry) -> Ordering {
+    for i in 0..32 {
+        let o = a.versor[i].to_bits().cmp(&b.versor[i].to_bits());
+        if o != Ordering::Equal {
+            return o;
+        }
+    }
+    a.provenance.cmp(&b.provenance)
+}
+
+#[inline]
+fn content_eq(a: &ArenaEntry, b: &ArenaEntry) -> bool {
+    content_cmp(a, b) == Ordering::Equal
+}
+
+/// A snapshot of newly-ingested entries (ADR-0180 §2.2). A `Delta` is always
+/// held in content-addressed order with byte-identical duplicates removed, so
+/// it is a canonical join-semilattice element regardless of the order its
+/// entries were inserted in.
+#[derive(Clone, Debug, Default)]
+pub struct Delta {
+    entries: Vec<ArenaEntry>,
+}
+
+impl Delta {
+    /// Canonicalise an arbitrary entry list into a Delta: sort by content,
+    /// drop byte-identical duplicates. `sort_by` is stable, but the dedup key
+    /// is the *whole* content, so stability is immaterial to the result.
+    pub fn from_entries(mut entries: Vec<ArenaEntry>) -> Self {
+        entries.sort_by(content_cmp);
+        entries.dedup_by(|a, b| content_eq(a, b));
+        Self { entries }
+    }
+
+    pub fn entries(&self) -> &[ArenaEntry] {
+        &self.entries
+    }
+
+    pub fn len(&self) -> usize {
+        self.entries.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.entries.is_empty()
+    }
+
+    /// Canonical little-endian serialization of this Delta — the cross-language
+    /// G1 contract (ADR-0180 / ADR-0196). Byte-for-byte identical to the
+    /// Python reference `vault.crdt.canonical_bytes`; parity is pinned by
+    /// `tests/test_crdt_hash_parity.rs`. Layout:
+    ///
+    /// ```text
+    /// u64   entry_count
+    /// per entry (canonical order):
+    ///   32 x f32   versor components (IEEE-754, little-endian, 4 bytes each)
+    ///   u64        provenance_length
+    ///   bytes      provenance
+    /// ```
+    pub fn canonical_bytes(&self) -> Vec<u8> {
+        let mut out = Vec::new();
+        out.extend_from_slice(&(self.entries.len() as u64).to_le_bytes());
+        for entry in &self.entries {
+            for component in &entry.versor {
+                out.extend_from_slice(&component.to_le_bytes());
+            }
+            out.extend_from_slice(&(entry.provenance.len() as u64).to_le_bytes());
+            out.extend_from_slice(&entry.provenance);
+        }
+        out
+    }
+}
+
+/// The join-semilattice contract for Delta-CRDT state (ADR-0180 §2.2).
+///
+/// Implementors must satisfy, with content-addressed equality (`content_cmp`):
+///   * commutativity   `a.join(b) == b.join(a)`
+///   * associativity   `a.join(b).join(c) == a.join(b.join(c))`
+///   * idempotence     `a.join(a) == a`
+///
+/// These are exercised as failable tests in `tests/test_arena.rs`; if `join`
+/// ever orders by arrival instead of content, or stops deduplicating, those
+/// tests fail loudly (CLAUDE.md §Schema-Defined Proof Obligations).
+pub trait SemilatticeDelta: Sized {
+    fn join(&self, other: &Self) -> Self;
+}
+
+impl SemilatticeDelta for Delta {
+    fn join(&self, other: &Self) -> Self {
+        let mut merged =
+            Vec::with_capacity(self.entries.len() + other.entries.len());
+        merged.extend_from_slice(&self.entries);
+        merged.extend_from_slice(&other.entries);
+        Delta::from_entries(merged)
+    }
+}
+
+/// Thread-local, share-nothing write cache for one modality adapter
+/// (ADR-0180 §2.1). Adapters push entries here lock-free; nothing is ever
+/// written to global state from an arena. `snapshot` emits the order-invariant
+/// `Delta` the Merge Kernel folds.
+#[derive(Clone, Debug, Default)]
+pub struct LocalArena {
+    entries: Vec<ArenaEntry>,
+}
+
+impl LocalArena {
+    pub fn new() -> Self {
+        Self {
+            entries: Vec::new(),
+        }
+    }
+
+    /// Lock-free local write. Push order is irrelevant: `snapshot`
+    /// canonicalises into content-addressed order.
+    pub fn push(&mut self, versor: [f32; 32], provenance: Vec<u8>) {
+        self.entries.push(ArenaEntry::new(versor, provenance));
+    }
+
+    pub fn len(&self) -> usize {
+        self.entries.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.entries.is_empty()
+    }
+
+    /// Emit a canonical Delta of everything accumulated so far. Does not drain
+    /// the arena — flush/GC policy is the Merge Kernel's concern, not the
+    /// arena's.
+    pub fn snapshot(&self) -> Delta {
+        Delta::from_entries(self.entries.clone())
+    }
+}
+
+/// The Merge Kernel (ADR-0180 §2.2): fold a batch of deltas into a single
+/// content-addressed, deduplicated, totally ordered entry set. The result is
+/// invariant under any permutation of `deltas` (commutativity + associativity)
+/// and under duplicate deltas (idempotence) — the property §4.3's
+/// `hash(Sequential) == hash(Concurrent)` proof rides on.
+///
+/// Implemented as a single canonicalisation of the union rather than a
+/// `fold(join)` chain; `tests/test_arena.rs` pins that the two are
+/// content-equal, so the cheap path can never silently diverge from the
+/// semilattice fold it stands in for.
+pub fn merge_kernel(deltas: &[Delta]) -> Delta {
+    let mut all = Vec::new();
+    for d in deltas {
+        all.extend_from_slice(&d.entries);
+    }
+    Delta::from_entries(all)
+}

core-rs/tests/fixtures/crdt_parity_expected.rs

@@ -0,0 +1,13 @@
+// @generated by tests/fixtures/crdt/_generate.py — DO NOT EDIT.
+// Expected canonical_bytes hex per case (mirrors merge_fixtures.json):
+// the Python-canonical Delta-CRDT G1 contract (ADR-0180 / ADR-0196)
+// the Rust substrate must reproduce byte-for-byte.
+// (include!d mid-module, so plain // comments — not //! — are required.)
+
+pub const EXPECTED_CANONICAL_BYTES_HEX: &[(&str, &str)] = &[
+    ("single_entry", "01000000000000000000803f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000061"),
+    ("dedup_within_delta", "01000000000000000000803f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000061"),
+    ("distinct_provenance_retained", "0200000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000006c656674000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005000000000000007269676874"),
+    ("three_delta_merge", "0400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000071000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000006d000000000000404000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000007a0000803f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000061"),
+    ("signed_zero_distinct", "020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000700000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000070"),
+];

core-rs/tests/test_arena.rs

@@ -0,0 +1,175 @@
+//! Delta-CRDT substrate proof obligations (ADR-0180 §2.1 / §2.2).
+//!
+//! Each test is written to FAIL LOUDLY under the specific violation it names
+//! (CLAUDE.md §Schema-Defined Proof Obligations): a schema/trait is only a
+//! proven property when a test would break if the property were silently
+//! removed. The map:
+//!
+//!   * commutativity / associativity / idempotence — the three join-semilattice
+//!     legs ADR-0180 §2.2 claims `Delta::join` satisfies.
+//!   * permutation-invariant `merge_kernel` — the load-bearing property §4.3's
+//!     `hash(Sequential) == hash(Concurrent)` rides on. Fails if `from_entries`
+//!     stops sorting (i.e. orders by arrival).
+//!   * distinct-provenance retention — guards the dedup from collapsing on the
+//!     versor alone, which would silently drop epistemic state (a wrong=0-style
+//!     data-loss hazard at the merge layer).
+
+use core_rs::vault::{merge_kernel, ArenaEntry, Delta, LocalArena, SemilatticeDelta};
+
+/// Deterministic distinct versor per seed.
+fn versor(seed: u8) -> [f32; 32] {
+    let mut v = [0f32; 32];
+    for (i, slot) in v.iter_mut().enumerate() {
+        *slot = (seed as f32) * 0.5 + (i as f32) * 0.125;
+    }
+    v
+}
+
+fn entry(seed: u8, prov: &str) -> ArenaEntry {
+    ArenaEntry::new(versor(seed), prov.as_bytes().to_vec())
+}
+
+/// Canonical, comparable view of a Delta: (versor bits, provenance) per entry,
+/// in the Delta's own order. Two Deltas are content-equal iff these match,
+/// including order — so this also pins that ordering is content-addressed.
+fn keys(d: &Delta) -> Vec<([u32; 32], Vec<u8>)> {
+    d.entries()
+        .iter()
+        .map(|e| {
+            let mut bits = [0u32; 32];
+            for (i, b) in bits.iter_mut().enumerate() {
+                *b = e.versor[i].to_bits();
+            }
+            (bits, e.provenance.clone())
+        })
+        .collect()
+}
+
+fn delta(entries: Vec<ArenaEntry>) -> Delta {
+    Delta::from_entries(entries)
+}
+
+// --- the three join-semilattice legs (ADR-0180 §2.2) ----------------------
+
+#[test]
+fn join_is_commutative() {
+    let a = delta(vec![entry(1, "p1"), entry(3, "p3")]);
+    let b = delta(vec![entry(2, "p2"), entry(3, "p3")]);
+    // Fails if join carries arrival order: a-first vs b-first would differ.
+    assert_eq!(keys(&a.join(&b)), keys(&b.join(&a)));
+}
+
+#[test]
+fn join_is_associative() {
+    let a = delta(vec![entry(1, "p1")]);
+    let b = delta(vec![entry(2, "p2")]);
+    let c = delta(vec![entry(3, "p3")]);
+    assert_eq!(keys(&a.join(&b).join(&c)), keys(&a.join(&b.join(&c))));
+}
+
+#[test]
+fn join_is_idempotent() {
+    let a = delta(vec![entry(1, "p1"), entry(2, "p2")]);
+    // a ∘ a == a — fails if dedup is removed (length would double).
+    let joined = a.join(&a);
+    assert_eq!(keys(&joined), keys(&a));
+    assert_eq!(joined.len(), 2);
+}
+
+// --- the load-bearing property for §4.3 -----------------------------------
+
+#[test]
+fn merge_kernel_is_permutation_invariant() {
+    let d0 = delta(vec![entry(5, "a"), entry(1, "b")]);
+    let d1 = delta(vec![entry(3, "c")]);
+    let d2 = delta(vec![entry(9, "d"), entry(2, "e"), entry(7, "f")]);
+
+    let forward = merge_kernel(&[d0.clone(), d1.clone(), d2.clone()]);
+    let reversed = merge_kernel(&[d2.clone(), d1.clone(), d0.clone()]);
+    let shuffled = merge_kernel(&[d1.clone(), d0.clone(), d2.clone()]);
+
+    // hash(Sequential) == hash(Concurrent): merged state is independent of the
+    // order deltas arrived in. Fails the instant `from_entries` orders by
+    // arrival instead of content.
+    assert_eq!(keys(&forward), keys(&reversed));
+    assert_eq!(keys(&forward), keys(&shuffled));
+}
+
+#[test]
+fn merge_kernel_dedups_duplicate_deltas() {
+    let d = delta(vec![entry(4, "x"), entry(6, "y")]);
+    // Re-ingesting the same delta is a no-op (idempotence at the kernel).
+    let once = merge_kernel(&[d.clone()]);
+    let twice = merge_kernel(&[d.clone(), d.clone()]);
+    assert_eq!(keys(&once), keys(&twice));
+    assert_eq!(twice.len(), 2);
+}
+
+#[test]
+fn merge_kernel_equals_semilattice_fold() {
+    let deltas = [
+        delta(vec![entry(8, "a"), entry(2, "b")]),
+        delta(vec![entry(5, "c")]),
+        delta(vec![entry(2, "b"), entry(9, "d")]), // overlaps the first delta
+    ];
+    let folded = deltas
+        .iter()
+        .fold(Delta::default(), |acc, d| acc.join(d));
+    // The cheap union-then-canonicalise path must equal the explicit
+    // semilattice fold, or the kernel has silently diverged from the trait.
+    assert_eq!(keys(&merge_kernel(&deltas)), keys(&folded));
+}
+
+// --- data-loss / over-dedup guard -----------------------------------------
+
+#[test]
+fn distinct_provenance_is_not_collapsed() {
+    // Same versor, different provenance => two distinct semilattice elements.
+    // Fails if dedup keys on the versor alone (which would drop state).
+    let same_versor = vec![entry(7, "alpha"), entry(7, "beta")];
+    let merged = delta(same_versor);
+    assert_eq!(merged.len(), 2);
+
+    // Byte-identical content (same versor + same provenance) => collapses.
+    let identical = vec![entry(7, "alpha"), entry(7, "alpha")];
+    assert_eq!(delta(identical).len(), 1);
+}
+
+#[test]
+fn merge_result_is_content_sorted() {
+    let d = merge_kernel(&[delta(vec![entry(9, "z"), entry(1, "a"), entry(5, "m")])]);
+    let ks = keys(&d);
+    let mut sorted = ks.clone();
+    sorted.sort();
+    assert_eq!(ks, sorted, "merge output must be in content-addressed order");
+}
+
+// --- LocalArena (ADR-0180 §2.1) -------------------------------------------
+
+#[test]
+fn arena_snapshot_independent_of_push_order() {
+    let mut a = LocalArena::new();
+    a.push(versor(3), b"p3".to_vec());
+    a.push(versor(1), b"p1".to_vec());
+    a.push(versor(2), b"p2".to_vec());
+
+    let mut b = LocalArena::new();
+    b.push(versor(2), b"p2".to_vec());
+    b.push(versor(3), b"p3".to_vec());
+    b.push(versor(1), b"p1".to_vec());
+
+    // Two arenas fed the same writes in different orders snapshot to the same
+    // canonical Delta (ADR-0180 §2.1: push order is irrelevant).
+    assert_eq!(keys(&a.snapshot()), keys(&b.snapshot()));
+}
+
+#[test]
+fn arena_snapshot_does_not_drain() {
+    let mut a = LocalArena::new();
+    a.push(versor(1), b"p1".to_vec());
+    let _ = a.snapshot();
+    // Flush/GC is the Merge Kernel's concern, not the arena's; snapshot must
+    // be non-destructive so a delayed merge (the §3.2 window) cannot lose it.
+    assert_eq!(a.len(), 1);
+    assert_eq!(a.snapshot().len(), 1);
+}

core-rs/tests/test_crdt_hash_parity.rs

@@ -0,0 +1,105 @@
+//! ADR-0180 / ADR-0196 gate G1 (slice ZC-0) — Rust↔Python byte-parity.
+//!
+//! Proves the Rust Delta-CRDT substrate (`core_rs::vault`) produces
+//! `canonical_bytes` identical to the Python reference `vault/crdt.py` over the
+//! shared golden corpus. Expected hex is generated *from* the Python reference
+//! (single source of truth) into `tests/fixtures/crdt_parity_expected.rs`, so
+//! the two languages cannot silently disagree. Fails loudly if the Rust
+//! serialization, content ordering, or dedup ever diverges from the locked
+//! Python contract (CLAUDE.md §Schema-Defined Proof Obligations).
+
+use core_rs::vault::{merge_kernel, ArenaEntry, Delta};
+
+include!(concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/tests/fixtures/crdt_parity_expected.rs"
+));
+
+fn v(idx: usize, val: f32) -> [f32; 32] {
+    let mut a = [0.0f32; 32];
+    a[idx] = val;
+    a
+}
+
+fn e(idx: usize, val: f32, prov: &str) -> ArenaEntry {
+    ArenaEntry::new(v(idx, val), prov.as_bytes().to_vec())
+}
+
+fn delta(entries: Vec<ArenaEntry>) -> Delta {
+    Delta::from_entries(entries)
+}
+
+fn hex(bytes: &[u8]) -> String {
+    let mut s = String::with_capacity(bytes.len() * 2);
+    for b in bytes {
+        s.push_str(&format!("{:02x}", b));
+    }
+    s
+}
+
+fn expected(name: &str) -> &'static str {
+    EXPECTED_CANONICAL_BYTES_HEX
+        .iter()
+        .find(|entry| entry.0 == name)
+        .map(|entry| entry.1)
+        .unwrap_or_else(|| panic!("no expected fixture for case {name}"))
+}
+
+fn assert_parity(name: &str, deltas: Vec<Delta>) {
+    let merged = merge_kernel(&deltas);
+    assert_eq!(hex(&merged.canonical_bytes()), expected(name), "case {name}");
+}
+
+#[test]
+fn parity_single_entry() {
+    assert_parity("single_entry", vec![delta(vec![e(0, 1.0, "a")])]);
+}
+
+#[test]
+fn parity_dedup_within_delta() {
+    assert_parity(
+        "dedup_within_delta",
+        vec![delta(vec![e(0, 1.0, "a"), e(0, 1.0, "a")])],
+    );
+}
+
+#[test]
+fn parity_distinct_provenance_retained() {
+    assert_parity(
+        "distinct_provenance_retained",
+        vec![delta(vec![e(5, 2.0, "left"), e(5, 2.0, "right")])],
+    );
+}
+
+#[test]
+fn parity_three_delta_merge() {
+    assert_parity(
+        "three_delta_merge",
+        vec![
+            delta(vec![e(1, 3.0, "z"), e(0, 1.0, "a")]),
+            delta(vec![e(2, 2.0, "m"), e(0, 1.0, "a")]),
+            delta(vec![e(10, 5.0, "q")]),
+        ],
+    );
+}
+
+#[test]
+fn parity_signed_zero_distinct() {
+    assert_parity(
+        "signed_zero_distinct",
+        vec![delta(vec![e(0, 0.0, "p"), e(0, -0.0, "p")])],
+    );
+}
+
+#[test]
+fn parity_permutation_invariant_matches_python() {
+    // Reordering input deltas must not change the merged bytes (and thus the
+    // Python-pinned hash). Mirrors the Python permutation-invariance test.
+    let d0 = delta(vec![e(1, 3.0, "z"), e(0, 1.0, "a")]);
+    let d1 = delta(vec![e(2, 2.0, "m"), e(0, 1.0, "a")]);
+    let d2 = delta(vec![e(10, 5.0, "q")]);
+    let forward = hex(&merge_kernel(&[d0.clone(), d1.clone(), d2.clone()]).canonical_bytes());
+    let reversed = hex(&merge_kernel(&[d2, d1, d0]).canonical_bytes());
+    assert_eq!(forward, reversed);
+    assert_eq!(forward, expected("three_delta_merge"));
+}

core/array_codec.py

@@ -0,0 +1,64 @@
+"""Bit-exact (de)serialization of numpy arrays for deterministic persistence.
+
+A numpy array encodes to ``{"dtype", "shape", "b64"}`` where ``b64`` is base64 of
+the array's raw bytes. This is **bit-exact**: every float round-trips with zero
+precision loss, so a restored versor keeps ``versor_condition < 1e-6`` and a
+replayed turn keeps its ``trace_hash``.
+
+NEVER serialize field arrays as decimal/JSON floats. Decimal truncates the
+mantissa and silently breaks both closure and deterministic replay — the Cl(4,1)
+float-truncation pitfall. ``dtype`` carries byte order (``'<f4'``/``'<f8'``), so
+the encoding is portable, and ``float32`` is never conflated with ``float64``.
+
+This module is a leaf: it imports only numpy + base64, so every layer (field,
+vault, session, engine_state) can use it without an import cycle.
+
+Zig-codec follow-up (tagged — NOT authorized).  This bit-exact codec is the natural
+locked **reference contract** (ADR-0196 decision rule 1) for a future Ring-1 Zig
+byte-exact serialization component: deterministic buffer ownership, stable layout, and
+edge-native build are exactly Zig's profile.  It is gated behind the G0–G8 ladder and
+is **only** worth proposing AFTER (1) persistence becomes incremental/append-only
+(O(Δ)/turn — the algorithmic fix, in Python), and (2) the edge-budget gate
+(``evals/edge_budget/``) proves the bounded per-turn codec is still the device
+bottleneck.  A Zig rewrite of today's O(n) snapshot would only speed up the wrong
+asymptotics.  See ``evals/edge_budget/contract.md``.
+"""
+
+from __future__ import annotations
+
+import base64
+from typing import Any
+
+import numpy as np
+
+
+def encode_array(arr: np.ndarray) -> dict[str, Any]:
+    """Encode a numpy array to a bit-exact, JSON-safe dict."""
+    contiguous = np.ascontiguousarray(arr)
+    return {
+        "dtype": contiguous.dtype.str,  # byte-order-aware, e.g. '<f4', '<f8', '<i4'
+        "shape": list(contiguous.shape),
+        "b64": base64.b64encode(contiguous.tobytes()).decode("ascii"),
+    }
+
+
+def decode_array(payload: dict[str, Any]) -> np.ndarray:
+    """Decode a payload produced by ``encode_array`` back to an exact array.
+
+    Returns a writable copy (``np.frombuffer`` is read-only) so the restored
+    array can be composed and mutated like a freshly-built one.
+    """
+    dtype = np.dtype(payload["dtype"])
+    raw = base64.b64decode(payload["b64"])
+    flat = np.frombuffer(raw, dtype=dtype)
+    return flat.reshape(payload["shape"]).copy()
+
+
+def encode_optional_array(arr: np.ndarray | None) -> dict[str, Any] | None:
+    """Encode an array, or return ``None`` for ``None`` (e.g. optional holonomy)."""
+    return None if arr is None else encode_array(arr)
+
+
+def decode_optional_array(payload: dict[str, Any] | None) -> np.ndarray | None:
+    """Decode an optional-array payload, or return ``None`` for ``None``."""
+    return None if payload is None else decode_array(payload)

core/cognition/explain.py

@@ -23,6 +23,7 @@ from generate.intent import IntentTag
 
 if TYPE_CHECKING:
     from core.cognition.result import CognitiveTurnResult
+    from generate.intent import DialogueIntent
 
 
 # Reverse map of generate.intent._RELATION_NORMALIZE — picks one surface
@@ -122,3 +123,39 @@ def explain(result: "CognitiveTurnResult") -> str:
     if tag is IntentTag.RECALL:
         return _explain_recall(subject)
     return ""
+
+
+def explain_from_intent(
+    intent: "DialogueIntent | None",
+    correction_text: str = "",
+) -> str:
+    """Lightweight variant for callers that have only a classified intent.
+
+    Identical dispatch to :func:`explain`; skips the full
+    ``CognitiveTurnResult`` round-trip.  ``correction_text`` is only
+    meaningful when the intent tag is ``CORRECTION``; callers may pass
+    the original user text as a reasonable approximation.
+    """
+    if intent is None:
+        return ""
+
+    tag = intent.tag
+    subject = intent.subject or ""
+
+    if tag is IntentTag.DEFINITION:
+        return _explain_definition(subject)
+    if tag is IntentTag.TRANSITIVE_QUERY:
+        return _explain_transitive_query(subject, intent.relation)
+    if tag is IntentTag.CAUSE:
+        return _explain_cause(subject)
+    if tag is IntentTag.PROCEDURE:
+        return _explain_procedure(subject)
+    if tag is IntentTag.COMPARISON:
+        return _explain_comparison(subject, intent.secondary_subject)
+    if tag is IntentTag.CORRECTION:
+        return _explain_correction(subject, correction_text)
+    if tag is IntentTag.VERIFICATION:
+        return _explain_verification(subject)
+    if tag is IntentTag.RECALL:
+        return _explain_recall(subject)
+    return ""

core/cognition/pipeline.py

@@ -22,6 +22,7 @@ from field.state import FieldState
 from core.cognition.result import CognitiveTurnResult
 from core.cognition.surface_resolution import resolve_surface
 from core.cognition.trace import compute_trace_hash, hash_admissibility_trace
+from core.reasoning.adapters import evidence_from_entailment_trace
 from generate.intent import classify_compound_intent
 from generate.intent_bridge import _is_useful_surface
 from generate.intent_ratifier import (
@@ -47,6 +48,7 @@ from generate.operators import (
     multi_relation_walk,
     transitive_walk,
 )
+from generate.proof_chain import EntailmentTrace, evaluate_entailment_with_trace
 from teaching.correction import CorrectionCandidate, extract_correction
 from teaching.epistemic import EpistemicStatus
 from teaching.review import ReviewedTeachingExample, review_correction
@@ -122,8 +124,13 @@ class CognitiveTurnPipeline:
     ) -> None:  # runtime: ChatRuntime (no import cycle)
         self.runtime = runtime
         self._last_node_id: str | None = None
-        self.teaching_store = teaching_store or TeachingStore()
-        self._recognizer = recognizer
+        self.teaching_store = teaching_store if teaching_store is not None else TeachingStore()
+        if recognizer is not None:
+            self._recognizer = recognizer
+        elif hasattr(runtime, "first_admitted_recognizer"):
+            self._recognizer = runtime.first_admitted_recognizer()
+        else:
+            self._recognizer = None
         self._prior_surface: str | None = None
         self._turn_number: int = 0
         # ADR-0021 §Articulation: subjects of prior SPECULATIVE teaching
@@ -156,6 +163,9 @@ class CognitiveTurnPipeline:
         # Admitted → wrap in EpistemicGraph for observability and optional
         # connector-grounded articulation.  Refused or absent → None.
         epistemic_graph: EpistemicGraph | None = None
+        # W-011 — recognition refusal_reason, materialized below into
+        # CognitiveTurnResult.refusal_reason when non-empty.
+        _recognition_refusal_reason: str = ""
         if self._recognizer is not None:
             _rec_outcome = recognize(self._recognizer, raw_tokens)
             if _rec_outcome.admitted:
@@ -167,6 +177,28 @@ class CognitiveTurnPipeline:
                     nodes=(_ep_node,),
                     recognizer_id=self._recognizer.teaching_set_id,
                 )
+                # ADR-0154 (W-020b) — producer-side wiring for the
+                # DerivedRecognizer registry.  When a recognizer admits a
+                # turn, capture (tokens, bundle) so the registry can
+                # derive tighter recognizers via anti-unification at the
+                # next checkpoint.  Pre-ADR-0154 the producer hook had
+                # no production caller (only tests invoked
+                # ``record_recognition_example``), so the registry
+                # could never grow from live traffic regardless of
+                # whether ``recognition_grounded_graph`` was enabled.
+                # The producer fires unconditionally; the consumer
+                # (``checkpoint_engine_state``'s derive_recognizer
+                # call) stays opt-in behind the same flag.
+                if (
+                    _rec_outcome.proposition is not None
+                    and hasattr(self.runtime, "record_recognition_example")
+                ):
+                    self.runtime.record_recognition_example(
+                        raw_tokens, _rec_outcome.proposition
+                    )
+            elif _rec_outcome.refusal_reason is not None:
+                from generate.exhaustion import RefusalReason as _ExhaustionRefusalReason
+                _recognition_refusal_reason = _ExhaustionRefusalReason.RECOGNITION_REFUSED.value
 
         # 1. LISTEN — capture pre-turn field state
         field_state_before: FieldState | None = self._capture_field_state()
@@ -274,6 +306,8 @@ class CognitiveTurnPipeline:
         ):
             compose_surface = CognitiveTurnPipeline._render_compose_surface(compose_result)
 
+        entailment_trace = self._maybe_entailment_trace(intent, triples)
+
         resolved = resolve_surface(
             canonical_surface=canonical,
             pre_decoration_surface=pre_decoration,
@@ -363,13 +397,14 @@ class CognitiveTurnPipeline:
         epistemic_status = proposal.epistemic_status.value if proposal is not None else ""
         walk_serialised = CognitiveTurnPipeline._serialize_operator(walk_result)
         compose_serialised = CognitiveTurnPipeline._serialize_operator(compose_result)
-        # Deterministic concatenation: walk record, then compose record.
-        # Empty strings are dropped so single-operator turns keep their
-        # existing trace_hash byte-for-byte.
-        operator_invocation = (
-            f"{walk_serialised}|{compose_serialised}"
-            if compose_serialised
-            else walk_serialised
+        entailment_serialised = CognitiveTurnPipeline._serialize_entailment_trace(
+            entailment_trace
+        )
+        # Deterministic concatenation: walk, compose, then entailment. Empty
+        # strings are dropped so unaffected turns keep existing trace bytes.
+        operator_invocation = "|".join(
+            s for s in (walk_serialised, compose_serialised, entailment_serialised)
+            if s
         )
         # ADR-0023 — admissibility trace + ratification provenance.
         # Comb pass 2026-05-21 — direct attribute access; the fields
@@ -390,12 +425,10 @@ class CognitiveTurnPipeline:
             else _ratification_outcome_raw
         )
         _trace_ratification_outcome = ratification_outcome
-        # ADR-0024 Phase 2 — refusal_reason flows from a future
-        # materialisation site on ChatResponse.  Empty string on every
-        # non-refused turn; folding into trace_hash is gated on
-        # non-emptiness so non-refused turns keep byte-identical hashes
-        # relative to pre-Phase-2 (CLAUDE.md determinism invariant).
-        refusal_reason = getattr(response, "refusal_reason", "") or ""
+        # ADR-0024 Phase 2 + W-011 — refusal_reason precedence:
+        # recognition wins (earlier-fail boundary) over generation.
+        _generation_refusal_reason = getattr(response, "refusal_reason", "") or ""
+        refusal_reason = _recognition_refusal_reason or _generation_refusal_reason
         trace_hash = compute_trace_hash(
             input_text=text,
             filtered_tokens=filtered_tokens,
@@ -416,6 +449,14 @@ class CognitiveTurnPipeline:
             refusal_reason=refusal_reason,
         )
 
+        # ADR-0153 (W-020a) — back-stamp the canonical trace_hash onto
+        # the runtime's most-recent TurnEvent and any DiscoveryCandidate
+        # emitted during this turn.  The runtime cannot compute
+        # trace_hash itself (the pipeline owns ``compute_trace_hash``),
+        # so candidates were previously persisted with empty
+        # ``source_turn_trace``.  See runtime.finalize_turn_trace_hash.
+        self.runtime.finalize_turn_trace_hash(trace_hash)
+
         return CognitiveTurnResult(
             input_text=text,
             input_tokens=raw_tokens,
@@ -430,6 +471,7 @@ class CognitiveTurnPipeline:
             dialogue_role=response.dialogue_role,
             identity_score=response.identity_score,
             vault_hits=response.vault_hits,
+            recall_energy_class=response.recall_energy_class,
             intent=intent,
             proposition_graph=graph,
             articulation_target=target,
@@ -653,6 +695,39 @@ class CognitiveTurnPipeline:
             relation=intent.relation,
         )
 
+    def _maybe_entailment_trace(
+        self,
+        intent,
+        triples: tuple[tuple[str, str, str], ...],
+    ) -> EntailmentTrace | None:
+        """Compile exact verification triples into propositional entailment.
+
+        Telemetry-only v1: the result is folded into ``operator_invocation`` and
+        never changes the user-facing surface. Runs only when classification
+        exposes a precise positive ``subject relation object`` shape.
+        """
+        if intent.tag is not IntentTag.VERIFICATION:
+            return None
+        if intent.negated or not intent.relation or not intent.object:
+            return None
+        head = self._proof_atom(intent.subject)
+        tail = self._proof_atom(intent.object)
+        if not head or not tail:
+            return None
+
+        relation = intent.relation.strip().lower()
+        premises: list[str] = []
+        for h, r, t in triples:
+            if r.strip().lower() != relation:
+                continue
+            h_atom = self._proof_atom(h)
+            t_atom = self._proof_atom(t)
+            if h_atom and t_atom:
+                premises.append(f"{h_atom} -> {t_atom}")
+        if not premises:
+            return None
+        return evaluate_entailment_with_trace(tuple(premises), f"{head} -> {tail}")
+
     @staticmethod
     def _render_compose_surface(compose: FrameComposeResult) -> str:
         """Render a frame-transfer composition suffix without selecting authority."""
@@ -684,6 +759,19 @@ class CognitiveTurnPipeline:
             return ""
         return json.dumps(op.as_dict(), sort_keys=True, ensure_ascii=False)
 
+    @staticmethod
+    def _serialize_entailment_trace(trace: EntailmentTrace | None) -> str:
+        if trace is None:
+            return ""
+        return f"entailment:{evidence_from_entailment_trace(trace).canonical_json()}"
+
+    @staticmethod
+    def _proof_atom(text: str) -> str:
+        parts = [p for p in _SUBJECT_SPLIT_RE.split(text.lower()) if p]
+        if not parts:
+            return ""
+        return "atom_" + "_".join(parts)
+
     @staticmethod
     def _render_walk_surface(walk: WalkResult) -> str:
         """Render a chain-aware walk suffix without selecting authority."""

core/cognition/provenance.py

@@ -14,6 +14,14 @@ failure.
 
 The Provenance object is derived from a ``CognitiveTurnResult``; it does not
 mutate the result and never invents sources.
+
+**Deployment scope (W-014):** this module is *evals-only infrastructure*.  It
+is consumed by ``evals/provenance/runner.py`` for offline audit analysis and
+by tests.  There is no live runtime caller — provenance introspection is an
+offline operation, not a per-turn runtime emission.  Promotion to runtime use
+(e.g., attaching a ``Provenance`` object to ``ChatResponse``) requires a new
+ADR if that capability is ever desired.  Confirmed by operator review
+2026-05-25 (W-014 closure).
 """
 
 from __future__ import annotations

core/cognition/result.py

@@ -54,6 +54,7 @@ class CognitiveTurnResult:
 
     # --- vault / memory ---
     vault_hits: int
+    recall_energy_class: str | None = None
 
     # --- intent / graph telemetry ---
     intent: DialogueIntent | None = None

core/comprehension_attempt/__init__.py

@@ -0,0 +1,57 @@
+"""Shared typed record of a comprehension organ's attempt at a problem (N2).
+
+The normalization layer the contemplation batch (N3 router, N4 registry, N6 pass manager) reasons
+over — uniform across the R1 and R2 setup compilers. Off-serving; imports no `evals`.
+"""
+
+from __future__ import annotations
+
+from core.comprehension_attempt.classify import (
+    classify_cmb,
+    classify_r1,
+    classify_r2,
+    classify_r3,
+    cmb_reason,
+)
+from core.comprehension_attempt.failure_family import (
+    REGISTRY,
+    FailureFamily,
+    enrich_family,
+    family_by_name,
+    family_for_reason,
+)
+from core.comprehension_attempt.model import ComprehensionAttempt, Organ, Outcome
+from core.comprehension_attempt.proposal import (
+    FailureProposal,
+    build_proposal,
+    emit_proposal,
+)
+from core.comprehension_attempt.router import (
+    RouteResult,
+    RouteStatus,
+    cmb_is_authoritative,
+    route_setup,
+)
+
+__all__ = [
+    "REGISTRY",
+    "ComprehensionAttempt",
+    "FailureFamily",
+    "FailureProposal",
+    "build_proposal",
+    "emit_proposal",
+    "Organ",
+    "Outcome",
+    "RouteResult",
+    "RouteStatus",
+    "classify_cmb",
+    "classify_r1",
+    "classify_r2",
+    "classify_r3",
+    "cmb_is_authoritative",
+    "cmb_reason",
+    "enrich_family",
+    "family_by_name",
+    "family_for_reason",
+    "route_setup",
+]

core/comprehension_attempt/classify.py

@@ -0,0 +1,159 @@
+"""Normalize R1/R2 organ output into a typed ``ComprehensionAttempt`` (N2, setup-level).
+
+`classify_r1` / `classify_r2` run their organ and report **produce-mode** setup outcomes:
+`setup_refused` (with the organ's typed reason) or `setup_correct` (an admissible setup was
+produced, with a deterministic signature). They do NOT solve, do NOT compare to gold, and import
+nothing from `evals` (signatures are computed inline) — keeping this a thin, dependency-light
+normalizer. Answer-level outcomes are reached downstream (N6) when the solver/verifier run.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from core.comprehension_attempt.model import ComprehensionAttempt
+from generate.combined_rate_comprehension.model import CombinedRateProblem
+from generate.combined_rate_comprehension.reader import read_combined_rate_problem
+from generate.constraint_comprehension.model import ConstraintProblem
+from generate.constraint_comprehension.reader import read_constraint_problem
+from generate.meaning_graph.reader import Refusal
+from generate.quantitative_comprehension import comprehend_quantitative, to_relational_metric
+from generate.rate_comprehension.model import RateProblem
+from generate.rate_comprehension.reader import read_rate_problem
+
+#: CMB reader/solver reasons that are namespaced ``cmb_*`` before the (reason-string-keyed) failure
+#: registry sees them, so a CMB boundary never inherits R2/R3's family for the SAME bare string
+#: (R3 ``rate_unit_mismatch`` is a growth surface; R2/R3 ``non_integer_solution`` carry other
+#: owners). The two ``input_shape`` reasons stay bare so they map to the cross ``input_shape``
+#: family (router hygiene). A ``cmb_``-prefixed attempt reason is also the signal that CMB
+#: *substantively* recognized the text (used by the CMB-over-R3 precedence rule in the router).
+_CMB_BARE_REASONS = frozenset({"not_combined_rate_shaped", "empty"})
+
+
+def cmb_reason(reason: str) -> str:
+    """Namespace a CMB refusal reason for the failure registry (see :data:`_CMB_BARE_REASONS`)."""
+    return reason if reason in _CMB_BARE_REASONS else f"cmb_{reason}"
+
+
+def _r1_signature(relations: list[dict[str, Any]]) -> str:
+    """Deterministic, order-independent string signature of the projected R1 relations."""
+    items: list[tuple] = []
+    for r in relations:
+        kind = r["kind"]
+        if kind == "fact":
+            items.append((kind, r["entity"], int(r["value"])))
+        elif kind in ("more_than", "fewer_than"):
+            items.append((kind, r["entity"], r["ref"], int(r["delta"])))
+        elif kind == "times_as_many":
+            items.append((kind, r["entity"], r["ref"], int(r["factor"])))
+        elif kind == "divide_by":
+            items.append((kind, r["entity"], r["ref"], int(r["divisor"])))
+        elif kind == "sum_of":
+            items.append((kind, r["entity"], tuple(sorted(r["parts"]))))
+        else:  # pragma: no cover - defensive
+            items.append(("unhandled", kind, r.get("entity", "")))
+    return repr(tuple(sorted(items, key=repr)))
+
+
+def _r2_signature(problem: ConstraintProblem) -> str:
+    """Deterministic, order-independent string signature of an R2 ConstraintProblem setup."""
+    unknowns = tuple(sorted((u.symbol, u.unit, u.domain) for u in problem.unknowns))
+    constraints: list[tuple] = []
+    for c in problem.constraints:
+        merged: dict[str, int] = {}
+        for symbol, coeff in c.lhs.terms:
+            merged[symbol] = merged.get(symbol, 0) + coeff
+        terms = tuple(sorted((s, v) for s, v in merged.items() if v != 0))
+        constraints.append((terms, c.relation, c.rhs - c.lhs.constant))
+    query = (problem.query.symbol, problem.query.unit)
+    return repr((unknowns, tuple(sorted(constraints, key=repr)), query))
+
+
+def classify_r1(text: str, *, case_id: str | None = None) -> ComprehensionAttempt:
+    """Attempt the R1 relational-arithmetic setup compiler on *text*."""
+    comp = comprehend_quantitative(text)
+    if isinstance(comp, Refusal):
+        return ComprehensionAttempt(
+            "r1_quantitative", "setup_refused", case_id=case_id, refusal_reason=comp.reason
+        )
+    projected = to_relational_metric(comp)
+    if projected is None:
+        return ComprehensionAttempt(
+            "r1_quantitative", "setup_refused", case_id=case_id, refusal_reason="unprojectable"
+        )
+    relations, _query = projected
+    return ComprehensionAttempt(
+        "r1_quantitative", "setup_correct", case_id=case_id, setup_signature=_r1_signature(relations)
+    )
+
+
+def classify_r2(text: str, *, case_id: str | None = None) -> ComprehensionAttempt:
+    """Attempt the R2 two-category constraint setup compiler on *text*."""
+    problem = read_constraint_problem(text)
+    if isinstance(problem, Refusal):
+        return ComprehensionAttempt(
+            "r2_constraints", "setup_refused", case_id=case_id, refusal_reason=problem.reason
+        )
+    return ComprehensionAttempt(
+        "r2_constraints", "setup_correct", case_id=case_id, setup_signature=_r2_signature(problem)
+    )
+
+
+def _r3_signature(problem: RateProblem) -> str:
+    """Deterministic string signature of an R3 single-rate setup."""
+    return repr(
+        (
+            (problem.rate_unit.numerator, problem.rate_unit.denominator),
+            ("rate", problem.rate),
+            ("time", problem.time),
+            ("quantity", problem.quantity),
+            problem.query,
+        )
+    )
+
+
+def classify_r3(text: str, *, case_id: str | None = None) -> ComprehensionAttempt:
+    """Attempt the R3 single-rate setup compiler on *text*."""
+    problem = read_rate_problem(text)
+    if isinstance(problem, Refusal):
+        return ComprehensionAttempt(
+            "r3_rate", "setup_refused", case_id=case_id, refusal_reason=problem.reason
+        )
+    return ComprehensionAttempt(
+        "r3_rate", "setup_correct", case_id=case_id, setup_signature=_r3_signature(problem)
+    )
+
+
+def _cmb_signature(problem: CombinedRateProblem) -> str:
+    """Deterministic string signature of an R4 combined-rate setup. The leading ``"cmb"`` tag
+    guarantees it never coincides with an R1/R2/R3 signature (cross-organ distinctness). ``sum`` is
+    commutative, so its two rates are sorted; ``difference`` keeps order (which rate is the drain)."""
+    rates = (problem.rate_a, problem.rate_b)
+    if problem.combine_mode == "sum":
+        rates = tuple(sorted(rates))
+    return repr(
+        (
+            "cmb",
+            problem.combine_mode,
+            (problem.rate_unit.numerator, problem.rate_unit.denominator),
+            rates,
+            ("time", problem.time),
+            ("quantity", problem.quantity),
+            problem.query,
+        )
+    )
+
+
+def classify_cmb(text: str, *, case_id: str | None = None) -> ComprehensionAttempt:
+    """Attempt the R4 combined-rate setup compiler on *text* (refusal reasons namespaced ``cmb_*``)."""
+    problem = read_combined_rate_problem(text)
+    if isinstance(problem, Refusal):
+        return ComprehensionAttempt(
+            "r4_combined_rate", "setup_refused", case_id=case_id, refusal_reason=cmb_reason(problem.reason)
+        )
+    return ComprehensionAttempt(
+        "r4_combined_rate", "setup_correct", case_id=case_id, setup_signature=_cmb_signature(problem)
+    )
+
+
+__all__ = ["classify_cmb", "classify_r1", "classify_r2", "classify_r3", "cmb_reason"]

core/comprehension_attempt/failure_family.py

@@ -0,0 +1,250 @@
+"""Failure-family registry (N4) — the heart of the contemplation batch.
+
+Partitions every typed organ refusal reason (R1 reader/admissibility, R2 reader/solver/
+answer-choice) into a named **failure family** that declares:
+
+- ``owner``                — which organ surfaces it (``r1`` / ``r2`` / ``cross``)
+- ``must_remain_refused``  — is this a correct wrong=0 boundary that must stay refused?
+- ``proposal_allowed``     — is this a genuine coverage gap a proposal may target?
+- ``safe_next_action``     — the human-readable next step
+- ``proposal_target``      — what artifact a proposal would suggest (e.g. ``r2_gold_fixture``)
+
+Only three families are growth surfaces (``proposal_allowed = True``): the R2 ``missing_*``
+gaps. Everything else is a correct boundary — `correct refusal != missing capability`. The
+registry is a **partition**: every reachable reason maps to exactly one family (asserted by
+test), so ``family_for_reason`` is total and unambiguous. ``answer_key_contradiction`` carries
+no refusal reason — it is reached from the answer-choice ``contradiction`` *verdict* (N6).
+
+Some R1 reasons are coarse (``unreadable_quantity_clause`` covers both the pronoun and distractor
+cases; ``admissibility_refused`` covers both ungrounded and unit-incompatible). v0 folds each to a
+single conservative family — the *action* (refuse, no proposal) is identical for the folded cases,
+so no wrong=0 signal is lost. The reserved families are forward-declared for R3 with no current
+reason mapping.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from typing import Literal
+
+from core.comprehension_attempt.model import ComprehensionAttempt
+
+Owner = Literal["r1", "r2", "r3", "r4", "cross"]
+
+
+@dataclass(frozen=True, slots=True)
+class FailureFamily:
+    """A named class of comprehension failure with its growth/refusal policy."""
+
+    name: str
+    owner: Owner
+    must_remain_refused: bool
+    proposal_allowed: bool
+    safe_next_action: str
+    proposal_target: str | None = None
+    refusal_reasons: tuple[str, ...] = ()
+
+
+#: The registry. Every reachable organ refusal reason appears in exactly one family.
+REGISTRY: tuple[FailureFamily, ...] = (
+    # --- correct wrong=0 boundaries (no proposal) ---------------------------------------- #
+    FailureFamily(
+        "input_shape", "cross", True, False,
+        "refuse — the text is not a readable problem shape",
+        refusal_reasons=(
+            "empty", "no_quantity_template", "non_digit_quantity", "non_identifier_name",
+            "unreadable_quantity_query", "invalid_binding_graph", "query_target_not_a_category",
+            "unprojectable", "category_pair_not_found", "query_target_unrecognized", "no_query",
+            "not_rate_shaped", "not_combined_rate_shaped",
+        ),
+    ),
+    FailureFamily(
+        "unsupported_clause_shape", "r1", True, False,
+        "refuse — compound/pronoun clause the template cannot isolate (subsumes "
+        "ambiguous_referent + unsupported_distractor_clause until a finer signal exists)",
+        refusal_reasons=("unreadable_quantity_clause",),
+    ),
+    FailureFamily(
+        "ungrounded_base", "r1", True, False,
+        "refuse — the asked quantity has no grounded anchor (underdetermined)",
+        refusal_reasons=("no_single_quantity_query",),
+    ),
+    FailureFamily(
+        "admissibility_incompatible", "cross", True, False,
+        "refuse — operands are ungrounded or unit-incompatible (cannot combine across dimensions)",
+        refusal_reasons=("admissibility_refused", "coefficient_unit_mismatch", "coefficient_conflict"),
+    ),
+    FailureFamily(
+        "over_determined", "r1", True, False,
+        "refuse — structurally incoherent (multiple bases / partition mismatch)",
+        refusal_reasons=(
+            "multiple_inverse_bases", "multiple_partitions",
+            "partition_query_mismatch", "partition_container_mismatch",
+        ),
+    ),
+    FailureFamily(
+        "unsupported_system_size", "r2", True, False,
+        "refuse — more than two categories; needs an n-variable solver (R3)",
+        refusal_reasons=("too_many_categories",),
+    ),
+    FailureFamily(
+        "indistinguishable_system", "r2", True, False,
+        "refuse — the system is singular/underdetermined; no unique solution",
+        refusal_reasons=("indistinguishable_weights", "query_target_unsolved", "verification_failed"),
+    ),
+    FailureFamily(
+        "non_integer_solution", "r2", True, False,
+        "refuse — no integer solution exists; never round",
+        refusal_reasons=("non_integer_solution",),
+    ),
+    FailureFamily(
+        "negative_solution", "r2", True, False,
+        "refuse — a solved count is negative; out of domain",
+        refusal_reasons=("negative_solution",),
+    ),
+    FailureFamily(
+        "answer_choice_unresolved", "r2", True, False,
+        "refuse — the proven value cannot be tied to exactly one option",
+        refusal_reasons=(
+            "no_matching_option", "ambiguous_options", "no_options",
+            "unknown_provided_label", "unparseable_option",
+        ),
+    ),
+    # --- growth surfaces (proposal allowed) ---------------------------------------------- #
+    FailureFamily(
+        "missing_total_count", "r2", False, True,
+        "propose a total-count-constraint gold fixture for review",
+        proposal_target="r2_gold_fixture", refusal_reasons=("missing_total_count",),
+    ),
+    FailureFamily(
+        "missing_weighted_total", "r2", False, True,
+        "propose a weighted-total-constraint gold fixture for review",
+        proposal_target="r2_gold_fixture", refusal_reasons=("missing_weighted_total",),
+    ),
+    # --- verdict (not a refusal) --------------------------------------------------------- #
+    FailureFamily(
+        "answer_key_contradiction", "r2", False, False,
+        "report the contradiction — the proven value disagrees with the supplied key",
+        refusal_reasons=(),
+    ),
+    # --- reserved / forward-declared for R3 (no current emitter) ------------------------- #
+    FailureFamily(
+        "missing_category_pair", "r2", False, True,
+        "RESERVED — propose a category-pair fixture once the reader distinguishes a partial "
+        "(one-category) R2 problem from non-R2 text; the raw category_pair_not_found reason is "
+        "too broad to propose against safely (it fires on any non-R2 text), so it maps to "
+        "input_shape until that split exists",
+        proposal_target="r2_gold_fixture",
+    ),
+    FailureFamily(
+        "missing_attribute_coefficient", "r2", False, True,
+        "RESERVED — propose an attribute-coefficient fixture (no emitter yet)",
+        proposal_target="r2_gold_fixture",
+    ),
+    # --- R3 single-rate organ (reachable; growth vs boundary by the anti-over-propose rule) -- #
+    FailureFamily(
+        "unsupported_rate_duration", "r3", False, True,
+        "propose a rate fixture for a recognized-but-unsupported rate feature (unit conversion / "
+        "multi-rate). GROWTH surface: rate_unit_mismatch + combined_rates are emitted ONLY after a "
+        "rate clause is recognized, so they are always rate-like — never arbitrary text.",
+        proposal_target="r3_gold_fixture",
+        refusal_reasons=("rate_unit_mismatch", "combined_rates"),
+    ),
+    FailureFamily(
+        "rate_underdetermined", "r3", True, False,
+        "refuse — a single-rate problem missing a needed value (underdetermined), like ungrounded_base",
+        refusal_reasons=("missing_rate", "missing_time", "missing_quantity"),
+    ),
+    FailureFamily(
+        "unsupported_temporal_state", "r3", True, False,
+        "refuse — elapsed clock-time is R3.x. NOT a growth surface: the clock-marker detector can "
+        "fire on non-rate text, so temporal_state is not reliably rate-like.",
+        refusal_reasons=("temporal_state",),
+    ),
+    # --- R4 combined-rate organ (reasons namespaced cmb_*; CMB owns them over R3's same-string ---- #
+    #     reasons via the CMB-over-R3 precedence rule in the router) ------------------------------ #
+    FailureFamily(
+        "cmb_unit_mismatch", "r4", True, False,
+        "refuse — the two rates' units are incompatible. must_remain_refused UNTIL a dimension "
+        "registry exists: CMB v1 cannot distinguish a convertible pair (gallons/min vs gallons/hour) "
+        "from a dimensionally-incompatible one (rooms/hour vs liters/minute), so a 'try conversion' "
+        "proposal would be wrong=0-unsafe. NOT 'forever impossible' — a convertible split is future work.",
+        refusal_reasons=("cmb_rate_unit_mismatch",),
+    ),
+    FailureFamily(
+        "cmb_combine_ambiguous", "r4", True, False,
+        "refuse — two same-unit rates but no licensed sum/difference cue. An ambiguity, not a "
+        "coverage gap: no fixture can teach which mode the text intends.",
+        refusal_reasons=("cmb_combine_mode_ambiguous",),
+    ),
+    FailureFamily(
+        "cmb_underdetermined", "r4", True, False,
+        "refuse — combined-shaped but a contributing rate is unstated (under-specified input); no "
+        "reader enhancement can infer the missing rate.",
+        refusal_reasons=("cmb_missing_second_rate",),
+    ),
+    FailureFamily(
+        "cmb_non_positive_net", "r4", True, False,
+        "refuse — non-positive net rate; a quantity/time query cannot make progress (solver boundary).",
+        refusal_reasons=("cmb_non_positive_net_rate",),
+    ),
+    FailureFamily(
+        "cmb_non_integer", "r4", True, False,
+        "refuse — no exact integer answer; never round (solver boundary, exact-integer v1).",
+        refusal_reasons=("cmb_non_integer_solution",),
+    ),
+    # --- R4 growth surfaces (proposal allowed) — emitted ONLY after positive combined recognition -- #
+    FailureFamily(
+        "cmb_unsupported_rate_count", "r4", False, True,
+        "propose a combined-rate fixture for ≥3 contributing rates (future capability)",
+        proposal_target="cmb_gold_fixture", refusal_reasons=("cmb_three_or_more_rates",),
+    ),
+    FailureFamily(
+        "cmb_unsupported_reciprocal", "r4", False, True,
+        "propose a reciprocal work-rate fixture (1/(1/a+1/b); reciprocal rates + rational arithmetic)",
+        proposal_target="cmb_gold_fixture", refusal_reasons=("cmb_reciprocal_work_rate_deferred",),
+    ),
+    FailureFamily(
+        "cmb_unsupported_clock_interval", "r4", False, True,
+        "propose a clock-interval fixture (elapsed-clock-time duration in a combined-rate problem)",
+        proposal_target="cmb_gold_fixture", refusal_reasons=("cmb_clock_interval_deferred",),
+    ),
+)
+
+_BY_NAME: dict[str, FailureFamily] = {f.name: f for f in REGISTRY}
+_BY_REASON: dict[str, FailureFamily] = {
+    reason: family for family in REGISTRY for reason in family.refusal_reasons
+}
+
+#: The verdict-derived family (no refusal reason maps to it).
+ANSWER_KEY_CONTRADICTION = _BY_NAME["answer_key_contradiction"]
+
+
+def family_for_reason(reason: str | None) -> FailureFamily | None:
+    """The single failure family a typed organ refusal reason belongs to (or ``None``)."""
+    if reason is None:
+        return None
+    return _BY_REASON.get(reason)
+
+
+def family_by_name(name: str) -> FailureFamily | None:
+    return _BY_NAME.get(name)
+
+
+def enrich_family(attempt: ComprehensionAttempt) -> ComprehensionAttempt:
+    """Return *attempt* with its ``family`` resolved from its refusal reason (or unchanged)."""
+    family = family_for_reason(attempt.refusal_reason)
+    if family is None:
+        return attempt
+    return replace(attempt, family=family.name)
+
+
+__all__ = [
+    "ANSWER_KEY_CONTRADICTION",
+    "FailureFamily",
+    "Owner",
+    "REGISTRY",
+    "enrich_family",
+    "family_by_name",
+    "family_for_reason",
+]

core/comprehension_attempt/model.py

@@ -0,0 +1,63 @@
+"""Typed, immutable record of one comprehension organ's attempt at a problem (N2).
+
+A small normalization layer over the R1 (`generate.quantitative_comprehension`) and R2
+(`generate.constraint_comprehension`) setup compilers: it turns each organ's heterogeneous
+output (a typed setup, or a typed `Refusal`) into one uniform, frozen `ComprehensionAttempt`.
+Nothing here changes reader behavior — it only *describes* an outcome so the router (N3),
+failure-family registry (N4), and contemplation pass manager (N6) can reason over both organs
+uniformly.
+
+Outcome semantics. `classify` (N2) produces **produce-mode** outcomes — what the organ did on
+its own gates, with no gold in hand: `setup_refused` (the organ refused) or `setup_correct`
+(an admissible setup was produced). The gold-relative outcomes (`setup_wrong`, `answer_wrong`)
+are representable here but are emitted only in **eval mode** by the lanes that hold gold — never
+fabricated by `classify`. `answer_*` / `contradiction` are reached when the solver / answer-choice
+verifier run downstream (N6), not at setup classification time.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+from generate.binding_graph.model import SourceSpanLink
+
+Organ = Literal["r1_quantitative", "r2_constraints", "r3_rate", "r4_combined_rate"]
+
+Outcome = Literal[
+    "setup_correct",   # an admissible setup was produced (produce-mode) / matches gold (eval-mode)
+    "setup_refused",   # the organ refused to assemble a setup
+    "setup_wrong",     # eval-mode only: produced setup diverges from gold (a wrong=0 breach)
+    "answer_correct",  # a value was produced and self-verified / matches gold
+    "answer_refused",  # setup produced but the solver/verifier refused
+    "answer_wrong",    # eval-mode only: produced value diverges from gold
+    "contradiction",   # a verified value contradicts a supplied answer key
+]
+
+
+@dataclass(frozen=True, slots=True)
+class ComprehensionAttempt:
+    """One organ's attempt at one problem. Immutable; carries the outcome, the refusal reason
+    (if any), a deterministic setup signature (for cross-organ comparison), the answer (if a
+    value was produced), and source-span evidence. ``family`` is left ``None`` by ``classify``
+    and resolved later by the N4 failure-family registry."""
+
+    organ: Organ
+    outcome: Outcome
+    case_id: str | None = None
+    refusal_reason: str | None = None
+    family: str | None = None
+    setup_signature: str | None = None
+    answer: int | None = None
+    evidence: tuple[SourceSpanLink, ...] = ()
+
+    @property
+    def is_setup_correct(self) -> bool:
+        return self.outcome == "setup_correct"
+
+    @property
+    def is_refusal(self) -> bool:
+        return self.outcome in ("setup_refused", "answer_refused")
+
+
+__all__ = ["ComprehensionAttempt", "Organ", "Outcome"]

core/comprehension_attempt/proposal.py

@@ -0,0 +1,148 @@
+"""Proposal-only failure-artifact emitter (N5) — deliberately toothless.
+
+When the contemplation pass (N6) meets a **growth-surface** failure family (``proposal_allowed
+= True``), it may emit a single content-addressed JSON artifact under
+``teaching/proposals/comprehension_failures/<hash>.json``. That artifact can *propose* a next
+fixture/rule for human review. It can do nothing else:
+
+```text
+status is always "proposal_only"
+mounted is always false
+requires_review is always true
+serving never reads these files
+no reader/test is modified
+```
+
+This routes into the existing proposal-only teaching flywheel (ADR-0055/0056/0057) — it is NOT a
+parallel correction path (CLAUDE.md teaching-safety). The alignment is
+``failure -> classification -> proposal -> review -> ratification``, never ``failure -> self-patch``.
+
+Content-addressing: the filename is ``sha256(failure_family : sha256(problem_text))`` — so the
+same failure on the same text always writes the same path (idempotent), and the raw problem text
+is **hashed, never stored**. Deterministic; no clock, no randomness.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from core.comprehension_attempt.failure_family import FailureFamily
+from core.comprehension_attempt.model import ComprehensionAttempt
+
+_PROPOSAL_STATUS = "proposal_only"
+
+
+def default_proposal_root() -> Path:
+    """``<repo>/teaching/proposals/comprehension_failures`` — the write-only proposal sink."""
+    return Path(__file__).resolve().parents[2] / "teaching" / "proposals" / "comprehension_failures"
+
+
+def _sha256(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def _attempt_to_dict(attempt: ComprehensionAttempt) -> dict[str, Any]:
+    return {
+        "organ": attempt.organ,
+        "outcome": attempt.outcome,
+        "refusal_reason": attempt.refusal_reason,
+        "family": attempt.family,
+        "setup_signature": attempt.setup_signature,
+        "answer": attempt.answer,
+    }
+
+
+@dataclass(frozen=True, slots=True)
+class FailureProposal:
+    """A proposal-only artifact. The invariant fields (``status``/``requires_review``/``mounted``)
+    are enforced in ``__post_init__`` so even a hand-constructed proposal cannot be made
+    serving-mountable."""
+
+    failure_family: str
+    problem_text_sha256: str
+    observed_attempts: tuple[dict[str, Any], ...]
+    status: str = _PROPOSAL_STATUS
+    suggested_next_fixture: None = None  # v0: always None — a human authors the fixture on review
+    requires_review: bool = True
+    mounted: bool = False
+
+    def __post_init__(self) -> None:
+        if self.status != _PROPOSAL_STATUS:
+            raise ValueError(f"proposal status must be {_PROPOSAL_STATUS!r}; got {self.status!r}")
+        if self.mounted:
+            raise ValueError("a proposal can never be mounted")
+        if not self.requires_review:
+            raise ValueError("a proposal always requires review")
+
+    def content_hash(self) -> str:
+        """Deterministic content address: same failure on same text -> same hash."""
+        return hashlib.sha256(
+            f"{self.failure_family}:{self.problem_text_sha256}".encode("utf-8")
+        ).hexdigest()
+
+    def to_json_dict(self) -> dict[str, Any]:
+        return {
+            "status": self.status,
+            "failure_family": self.failure_family,
+            "problem_text_sha256": self.problem_text_sha256,
+            "observed_attempts": list(self.observed_attempts),
+            "suggested_next_fixture": self.suggested_next_fixture,
+            "requires_review": self.requires_review,
+            "mounted": self.mounted,
+        }
+
+
+def build_proposal(
+    text: str, family: FailureFamily, attempts: tuple[ComprehensionAttempt, ...]
+) -> FailureProposal | None:
+    """Build a proposal for a growth-surface family, or ``None`` for a correct wrong=0 boundary.
+
+    A family with ``proposal_allowed = False`` (every must-remain-refused boundary) yields NO
+    proposal — the loop never proposes against a faithful refusal.
+    """
+    if not family.proposal_allowed:
+        return None
+    return FailureProposal(
+        failure_family=family.name,
+        problem_text_sha256=_sha256(text),
+        observed_attempts=tuple(_attempt_to_dict(a) for a in attempts),
+    )
+
+
+def proposal_path(proposal: FailureProposal, root: Path | None = None) -> Path:
+    base = root if root is not None else default_proposal_root()
+    return base / f"{proposal.content_hash()}.json"
+
+
+def emit_proposal(
+    text: str,
+    family: FailureFamily,
+    attempts: tuple[ComprehensionAttempt, ...],
+    *,
+    root: Path | None = None,
+) -> Path | None:
+    """Write a proposal-only artifact for a growth-surface family; return its path, or ``None``.
+
+    Idempotent: the same failure on the same text writes the same content-addressed path with
+    byte-identical content (``sort_keys``). Creates the sink directory on demand.
+    """
+    proposal = build_proposal(text, family, attempts)
+    if proposal is None:
+        return None
+    path = proposal_path(proposal, root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(proposal.to_json_dict(), indent=2, sort_keys=True), encoding="utf-8")
+    return path
+
+
+__all__ = [
+    "FailureProposal",
+    "build_proposal",
+    "default_proposal_root",
+    "emit_proposal",
+    "proposal_path",
+]

core/comprehension_attempt/router.py

@@ -0,0 +1,77 @@
+"""Deterministic multi-organ setup router (N3).
+
+Boring on purpose: attempt the R1 and R2 setup compilers, collect their typed attempts, and
+select a setup ONLY when exactly one organ produced an admissible one. No dynamic "best"
+scoring, no priority heuristics.
+
+```text
+exactly one setup_correct          -> routed (use it)
+zero setup_correct                 -> all_refused (classify downstream)
+>= 2 setup_correct, signatures agree-> routed (organs concur)
+>= 2 setup_correct, signatures differ-> ambiguous (refuse — never pick)
+```
+
+Cross-organ signatures are produced by different functions and never coincide, so in practice
+two admitting organs always resolve to ``ambiguous``. The router never solves and never emits
+``setup_wrong`` — that is an eval-only outcome; against gold the routed setup must match (the
+wrong=0 invariant, asserted by the router tests).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+from core.comprehension_attempt.classify import classify_cmb, classify_r1, classify_r2, classify_r3
+from core.comprehension_attempt.model import ComprehensionAttempt
+
+RouteStatus = Literal["routed", "all_refused", "ambiguous"]
+
+
+@dataclass(frozen=True, slots=True)
+class RouteResult:
+    """The outcome of routing one problem across the organs: every attempt, the selected setup
+    (or ``None``), and the routing status."""
+
+    attempts: tuple[ComprehensionAttempt, ...]
+    selected: ComprehensionAttempt | None
+    status: RouteStatus
+
+
+def cmb_is_authoritative(attempts: tuple[ComprehensionAttempt, ...]) -> bool:
+    """True when the R4 combined-rate organ **positively** recognized combined-rate shape — a setup,
+    or a substantive ``cmb_*`` refusal (NOT the bare ``not_combined_rate_shaped`` / ``empty``
+    step-aside). When it does, R3's broader single-rate read of the SAME text is inadmissible: a more
+    specific positive recognition beats a broader partial one ("Anna and Ben paint together; Anna
+    paints 3 rooms/hour" must not be answered as a single-rate 12). This is the narrow CMB↔R3
+    instance of a future general domain-specificity adjudication; it does NOT mean "CMB always wins"
+    (on ``input_shape`` CMB cedes to R3, e.g. a plain single-rate car problem)."""
+    cmb = next((a for a in attempts if a.organ == "r4_combined_rate"), None)
+    if cmb is None:
+        return False
+    return cmb.is_setup_correct or (cmb.refusal_reason or "").startswith("cmb_")
+
+
+def route_setup(text: str, *, case_id: str | None = None) -> RouteResult:
+    """Route *text* to the single organ that admits an honest setup, or refuse."""
+    attempts = (
+        classify_r1(text, case_id=case_id),
+        classify_r2(text, case_id=case_id),
+        classify_r3(text, case_id=case_id),
+        classify_cmb(text, case_id=case_id),
+    )
+    # CMB-over-R3 domain precedence: a substantive CMB recognition vetoes R3's single-rate over-read.
+    vetoed = cmb_is_authoritative(attempts)
+    correct = tuple(
+        a for a in attempts if a.is_setup_correct and not (vetoed and a.organ == "r3_rate")
+    )
+    if len(correct) == 1:
+        return RouteResult(attempts, correct[0], "routed")
+    if not correct:
+        return RouteResult(attempts, None, "all_refused")
+    if len({a.setup_signature for a in correct}) == 1:
+        return RouteResult(attempts, correct[0], "routed")
+    return RouteResult(attempts, None, "ambiguous")
+
+
+__all__ = ["RouteResult", "RouteStatus", "cmb_is_authoritative", "route_setup"]

core/config.py

@@ -242,6 +242,7 @@ class RuntimeConfig:
     # live workload.
     unified_ingest: bool = False
 
+
     # ADR-0144 — recognition-grounded articulation graph.  When True and a
     # DerivedRecognizer is attached to CognitiveTurnPipeline, the articulation
     # graph is derived from the admitted EpistemicNode via the connector rather
@@ -249,6 +250,100 @@ class RuntimeConfig:
     # for every existing surface and trace_hash.
     recognition_grounded_graph: bool = False
 
+    # W-016 — wire session vault (T1) into discovery contemplation.
+    # When True, ChatRuntime builds a vault probe from the live session
+    # vault and passes it to contemplate() in _emit_discovery_candidates.
+    # The probe queries the vault at EpistemicStatus.COHERENT so only
+    # reviewed-coherent session entries contribute evidence; SPECULATIVE /
+    # CONTESTED / FALSIFIED entries are filtered by the vault layer per
+    # ADR-0021 §3.  Default False preserves all pre-W-016 discovery
+    # output byte-identically (null-drop invariant on discovery lanes).
+    vault_probe_discoveries: bool = False
+    # ADR-0148 — wire VaultPromotionPolicy into turn boundary.
+    # When True, ChatRuntime calls vault.promote_eligible_entries() after each
+    # finalize_turn(), scanning SPECULATIVE entries for crystallization to
+    # COHERENT based on their energy profile (EnergyClass E0/E1, coherence_residual
+    # ≤ 0.05).  Fresh entries written in the current turn are E2+ and will not
+    # promote yet — the policy fires on entries that have cooled across turns.
+    # Default False: zero behavior change when disabled (null-drop invariant).
+    # Unlocks W-007 (DerivedRecognizer derivation from promoted COHERENT entries).
+    vault_promotion_enabled: bool = False
+
+    # ADR-0150 — run contemplation on pending discovery candidates at checkpoint.
+    # Activates ADR-0056 Phase C1. Null-drop when False.
+    auto_contemplate: bool = False
+
+    # ADR-0151 — generate TeachingChainProposals from enriched candidates on load.
+    auto_proposal_enabled: bool = False
+
+    # Shape B+ (L10 resume-as-same-life) — persist and restore the FULL lived
+    # session state (field, vault, anchor, graph, referents, dialogue) across
+    # reboot, not just recognizers/candidates (Shape B). OFF by default: it is a
+    # deliberate always-on-runtime mode, and per-turn snapshotting has an O(turns)
+    # cost, so demos/evals/one-shot runtimes must not pay for resume they don't
+    # use. Enabled by the L10 continuity lane and the production L10 process.
+    persist_session_state: bool = False
+
+    # L11 — on reboot, if the stamped checkpoint identity != the recomputed
+    # engine identity (the ratified substrate changed during downtime), REFUSE to
+    # start (raise IdentityContinuityError) rather than the default warn-and-flag.
+    # OFF by default: reboot is recovery, not control flow (ADR-0157), and the
+    # operator must not be bricked by a benign ratified pack swap. Deployments
+    # wanting a hard identity-continuity guarantee opt in.
+    strict_identity_continuity: bool = False
+
+    # Step B (inline realization) — when on, each turn ACCRUES knowledge into the
+    # held self: a comprehensible declarative turn is realized into the session vault
+    # (SPECULATIVE, as-told), and a comprehensible question turn is determined over
+    # realized knowledge. This is the "one continuous life" telos made real — a
+    # conversation accumulates knowledge it can recall and reason over. OFF by default
+    # (one-shot/eval runtimes don't accrue); the production L10 process enables it
+    # alongside persist_session_state so accrued facts survive reboot. Realization is
+    # SESSION memory (immediate), NOT ratified learning — it proposes nothing; the
+    # teaching/review HITL path is untouched.
+    accrue_realized_knowledge: bool = False
+
+    # Step D (CLOSE) — when on, idle_tick consolidates soundly-derived determinations
+    # back into the held self: one semi-naive layer of the member/subset deductive
+    # closure (member∘subset, subset∘subset — NEVER member∘member) per tick, each
+    # derived edge proof_chain-verified, written as a SPECULATIVE realized record with
+    # derived-provenance. This is how the loop "learns from determined facts": derive
+    # once, remember, reach one hop further next tick — the directly answerable set
+    # climbs monotonically to the deductive-closure fixed point. OFF by default; the
+    # production L10 process enables it alongside accrue_realized_knowledge +
+    # persist_session_state. SESSION memory (immediate), NOT reviewed/corpus learning —
+    # no proposal coupling, the teaching/review HITL path is untouched. Bounded by the
+    # same _SUBSUMPTION_SUBSET_FACT_BUDGET; converges (a saturated tick is a no-op).
+    consolidate_determinations: bool = False
+
+    # IT (proposal-review surface) — when on, idle_tick runs a READ-ONLY sub-pass that scans
+    # the comprehension-failure proposal sink and surfaces a summary in
+    # IdleTickResult.proposal_review. It NEVER mutates an artifact, sets did_work, checkpoints,
+    # ratifies, mounts, or modifies readers; a reporter failure is captured, not propagated.
+    # OFF by default — idle ticks don't pay for the scan unless a deployment wants the surface.
+    review_pending_proposals: bool = False
+
+    # Step E (ESTIMATION) — when on, a converse query the engine would otherwise REFUSE
+    # (told p(a,b), asked p(b,a)) may be answered with a DISCLOSED [approximate] estimate
+    # IF the predicate-class has earned the SERVE license on the ratified, committed
+    # reliability ledger (ADR-0175 license_for, θ_SERVE=0.99) — routed through the
+    # ADR-0206 govern_response/shape_surface bridge. OFF by default; only meaningful with
+    # accrue_realized_knowledge (the estimate is computed in the accrual path). wrong=0 is
+    # preserved by construction: an estimate is ALWAYS disclosed ([approximate]), never
+    # asserted as fact, and is offered only for a class whose committed track record
+    # clears the Wilson floor. Absent a cleared license -> STRICT refuse (the safe
+    # default); the engine never raises its own ceiling.
+    estimation_enabled: bool = False
+
+    # ASK serving gate enable flag. When True, ASK serving is allowed.
+    # Default False (dark).
+    ask_serving_enabled: bool = False
+
+    # VERIFIED serving gate enable flag. When True, VERIFIED serving is allowed.
+    # Default False (dark).
+    verified_serving_enabled: bool = False
+
+
 
 DEFAULT_IDENTITY_PACK: str = "default_general_v1"
 DEFAULT_ETHICS_PACK: str = "default_general_ethics_v1"

core/contemplation/miners/__init__.py

@@ -2,8 +2,10 @@
 
 from .contradiction_detection import mine_contradiction_detection_report
 from .frontier_compare import mine_frontier_compare_report
+from .learning_arena import mine_learning_arena_report
 
 __all__ = [
     "mine_contradiction_detection_report",
     "mine_frontier_compare_report",
+    "mine_learning_arena_report",
 ]

core/contemplation/miners/learning_arena.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from core.contemplation.schema import (
+    ContemplationEvidenceRef,
+    ContemplationFinding,
+    FindingKind,
+)
+
+
+def mine_learning_arena_report(
+    report_path: str | Path,
+    *,
+    substrate_hash: str,
+    min_coverage: float = 0.25,
+) -> tuple[ContemplationFinding, ...]:
+    """Convert learning-arena report weaknesses into speculative findings.
+
+    Read-only: parses ``report_path`` and returns immutable findings. It never
+    writes packs, teaching examples, proposals, or runtime state.
+    """
+    path = Path(report_path)
+    report = json.loads(path.read_text(encoding="utf-8"))
+    source_id = str(path)
+    findings: list[ContemplationFinding] = []
+
+    for class_name, row in sorted(_per_class(report).items()):
+        committed = int(row.get("committed", 0) or 0)
+        coverage = float(row.get("coverage", 0.0) or 0.0)
+        t2_verified = int(row.get("t2_verified", 0) or 0)
+        if coverage < min_coverage:
+            evidence = ContemplationEvidenceRef(
+                source_type="learning_arena_report",
+                source_id=source_id,
+                pointer=f"class={class_name}",
+                summary=f"coverage={coverage};committed={committed};min={min_coverage}",
+            )
+            findings.append(
+                ContemplationFinding(
+                    kind=FindingKind.COVERAGE_GAP,
+                    subject=class_name,
+                    predicate="weak_coverage",
+                    object=None,
+                    evidence_refs=(evidence,),
+                    proposed_action=(
+                        "Inspect refusal diagnoses for this capability class and add "
+                        "practice or reviewed operators only where the missing piece is named."
+                    ),
+                    substrate_hash=substrate_hash,
+                )
+            )
+        if committed > 0 and t2_verified == 0:
+            evidence = ContemplationEvidenceRef(
+                source_type="learning_arena_report",
+                source_id=source_id,
+                pointer=f"class={class_name}",
+                summary=f"committed={committed};t2_verified=0",
+            )
+            findings.append(
+                ContemplationFinding(
+                    kind=FindingKind.UNPROVED_RELATION,
+                    subject=class_name,
+                    predicate="missing_tier2_evidence",
+                    object=None,
+                    evidence_refs=(evidence,),
+                    proposed_action=(
+                        "Add convergent self-verification evidence before promoting this "
+                        "class beyond gold-scored practice."
+                    ),
+                    substrate_hash=substrate_hash,
+                )
+            )
+
+    for record in report.get("elimination_records", ()) or ():
+        if not isinstance(record, dict):
+            continue
+        case_id = str(record.get("case_id", "unknown_case"))
+        class_name = str(record.get("class_name", "unknown_class"))
+        evidence = ContemplationEvidenceRef(
+            source_type="learning_arena_report",
+            source_id=source_id,
+            pointer=f"case={case_id}",
+            summary=str(record.get("reason", "wrong attempt")),
+        )
+        findings.append(
+            ContemplationFinding(
+                kind=FindingKind.BENCHMARK_CASE,
+                subject=f"{class_name}/{case_id}",
+                predicate="wrong_attempt",
+                object=str(record.get("gold", "")),
+                evidence_refs=(evidence,),
+                proposed_action=(
+                    "Use this gold-caught wrong attempt as elimination evidence; do not "
+                    "promote the class until the faulty derivation shape is pruned."
+                ),
+                substrate_hash=substrate_hash,
+            )
+        )
+
+    return tuple(findings)
+
+
+def _per_class(report: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    rows = report.get("per_class", {})
+    return {str(k): v for k, v in rows.items() if isinstance(v, dict)}
+
+
+__all__ = ["mine_learning_arena_report"]

core/demos/showcase.py

@@ -19,6 +19,7 @@ underlying demos. No new exposure of internal mechanisms.
 
 from __future__ import annotations
 
+import os
 import subprocess
 import time
 from dataclasses import dataclass
@@ -167,7 +168,8 @@ def run_showcase(*, output_dir: Path, include_runtime_ms: bool = True) -> dict[s
     deterministic_payload = {k: v for k, v in payload.items() if k != "total_runtime_ms"}
     json_path.write_bytes(canonical_json(deterministic_payload))
 
-    if total_runtime_ms > MAX_RUNTIME_SECONDS * 1000:
+    _skip_budget = os.environ.get("CORE_SHOWCASE_SKIP_BUDGET") == "1"
+    if total_runtime_ms > MAX_RUNTIME_SECONDS * 1000 and not _skip_budget:
         raise DemoContractError(
             f"showcase exceeded ADR-0099 runtime budget: "
             f"{total_runtime_ms} ms > {MAX_RUNTIME_SECONDS * 1000} ms"

core/engine_identity.py

@@ -0,0 +1,134 @@
+"""EngineIdentity — content-derived identity of the ratified substrate (L11).
+
+``EngineIdentity`` is the sha256 of the canonical serialization of the engine's
+ratified PERSONALITY substrate — the active identity / safety / ethics / register
+/ anchor-lens pack files — plus the code revision. It is **content-derived, NOT
+entropy-based**: two engines with the same ratified substrate compute the SAME
+identity, because they ARE the same engine functionally (substrate is shareable).
+
+This is the "who am I" hash. It is bumped only by a ratified change to the
+identity substrate (a new identity pack, a safety-axis change), NOT by lived
+learning (recall, teaching) — that is the engine's *experience*, carried across
+reboot by the Shape B+ lived-state lineage, not its identity. The git-like
+lineage chain (parent links on ratification) and the reboot identity verification
+build on this primitive.
+
+Honest scope (per the EngineIdentity candidate note): this is a *convention*
+naming the existing per-pack content hashes, not a new pack format. The ratified
+teaching corpus / recognizer-registry head can be folded into the tuple later
+(additive — a new key changes the identity, which is the correct semantic for a
+ratified-substrate change).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+from core.config import (
+    DEFAULT_ANCHOR_LENS,
+    DEFAULT_ETHICS_PACK,
+    DEFAULT_IDENTITY_PACK,
+    DEFAULT_REGISTER_PACK,
+    RuntimeConfig,
+)
+
+# The never-swappable safety pack default (packs/safety/loader.py).
+DEFAULT_SAFETY_PACK: str = "core_safety_axes_v1"
+
+_PACKS_ROOT = Path(__file__).resolve().parents[1] / "packs"
+
+#: role -> packs/ subdirectory holding ``<pack_id>.json``.
+_ROLE_DIRS: dict[str, str] = {
+    "identity": "identity",
+    "safety": "safety",
+    "ethics": "ethics",
+    "register": "register",
+    "anchor_lens": "anchor_lens",
+}
+
+#: The ratified roles that constitute the engine's identity, in canonical order.
+RATIFIED_ROLES: tuple[str, ...] = (
+    "identity",
+    "safety",
+    "ethics",
+    "register",
+    "anchor_lens",
+)
+
+
+class EngineIdentityError(RuntimeError):
+    """A ratified pack named by the identity tuple could not be resolved."""
+
+
+class IdentityContinuityError(RuntimeError):
+    """A reboot found the stamped checkpoint identity != the recomputed identity.
+
+    The ratified substrate changed while the engine was down, so it would resume
+    the lived state under a DIFFERENT identity than the checkpoint was written
+    under. Raised only under strict identity continuity; the default surfaces a
+    warning and a queryable break flag (reboot is recovery, not control flow).
+    """
+
+
+def _pack_content_hash(role: str, pack_id: str) -> str:
+    path = _PACKS_ROOT / _ROLE_DIRS[role] / f"{pack_id}.json"
+    if not path.exists():
+        raise EngineIdentityError(
+            f"ratified {role} pack not found: {_ROLE_DIRS[role]}/{pack_id}.json"
+        )
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def ratified_substrate(pack_ids: dict[str, str], git_revision: str) -> dict[str, Any]:
+    """The canonical, auditable identity tuple.
+
+    ``{role: {"pack_id", "sha256"}}`` for every ratified role plus
+    ``"code_revision"``. ``pack_ids`` must name a pack for every role in
+    ``RATIFIED_ROLES``.
+    """
+    substrate: dict[str, Any] = {}
+    for role in RATIFIED_ROLES:
+        pack_id = pack_ids[role]
+        substrate[role] = {
+            "pack_id": pack_id,
+            "sha256": _pack_content_hash(role, pack_id),
+        }
+    substrate["code_revision"] = git_revision
+    return substrate
+
+
+def compute_engine_identity(pack_ids: dict[str, str], git_revision: str) -> str:
+    """The sha256 EngineIdentity over the ratified substrate tuple."""
+    canonical = json.dumps(
+        ratified_substrate(pack_ids, git_revision),
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+    )
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+
+def _resolve_pack_ids(config: RuntimeConfig) -> dict[str, str]:
+    """Resolve each ratified role to its active pack id (config override or DEFAULT)."""
+    return {
+        "identity": config.identity_pack or DEFAULT_IDENTITY_PACK,
+        "safety": DEFAULT_SAFETY_PACK,  # never-swappable
+        "ethics": config.ethics_pack or DEFAULT_ETHICS_PACK,
+        "register": config.register_pack_id or DEFAULT_REGISTER_PACK,
+        "anchor_lens": config.anchor_lens_id or DEFAULT_ANCHOR_LENS,
+    }
+
+
+def engine_identity_for_config(config: RuntimeConfig, git_revision: str) -> str:
+    """EngineIdentity for a runtime config (resolving every role to its active pack)."""
+    return compute_engine_identity(_resolve_pack_ids(config), git_revision)
+
+
+def ratified_substrate_for_config(
+    config: RuntimeConfig, git_revision: str
+) -> dict[str, Any]:
+    """The auditable identity tuple for a runtime config."""
+    return ratified_substrate(_resolve_pack_ids(config), git_revision)

core/epistemic_disclosure/__init__.py

@@ -0,0 +1,87 @@
+"""The Epistemic Disclosure spine (P0-1+).
+
+CORE's served-surface governance: comprehension produces evidence, the limitation
+pass classifies *what kind of gap* is blocking resolution, and (in later slices) a
+disposition + disclosure-claim decide what reaches the user and under what epistemic
+claim. This package is the *owner* of that machine — ``generate/derivation/verify.py``
+and other serving sites may eventually *consume* it, but must never *define* it.
+
+Shipped so far (all off-serving — nothing here imports ``generate.derivation`` /
+``core.reliability_gate``):
+
+  * :mod:`~core.epistemic_disclosure.limitation` (P0-1) — the typed limitation
+    vocabulary, a CONSOLIDATING VIEW over the shipped failure-family registry +
+    contemplation terminals (no fourth taxonomy).
+  * :mod:`~core.epistemic_disclosure.disclosure_claim` (P0-2) — the ``DisclosureClaim``
+    axis (the epistemic claim a response makes), kept SEPARATE from ``ReachLevel``.
+  * :mod:`~core.epistemic_disclosure.disposition` (P0-3) — ``ServedDisposition`` and
+    ``choose_served_disposition``: the pure mapping
+    ``EpistemicState × LimitationAssessment × DisclosureClaim → ServedDisposition``.
+    Mapping scaffold only — no rendering, no bus, no ``verify.py``; nothing consumes
+    it yet.
+  * :mod:`~core.epistemic_disclosure.ask_serving` — a narrow Q1-D served-ASK artifact
+    adapter. It validates already-rendered question artifacts and returns a typed
+    decision; it does not render prose and does not acquire runtime contemplation.
+  * :mod:`~core.epistemic_disclosure.verified_contract` (P1-A) — the VERIFIED contract:
+    the obligation, the proof shape, the validator, and the single sanctioned route to
+    ``EpistemicState.VERIFIED`` / ``DisclosureClaim.VERIFIED``. Contract only — no
+    producer; a faithful solve of a WRONG read must not verify.
+"""
+
+from __future__ import annotations
+
+from core.epistemic_disclosure.ask_serving import (
+    ServedAskDecision,
+    evaluate_served_ask,
+)
+from core.epistemic_disclosure.disclosure_claim import (
+    DEFAULT_DISCLOSURE_CLAIM,
+    DisclosureClaim,
+)
+from core.epistemic_disclosure.disposition import (
+    ServedDisposition,
+    choose_served_disposition,
+)
+from core.epistemic_disclosure.limitation import (
+    Q1B_ASK_CARVE_OUT,
+    LimitationAssessment,
+    LimitationKind,
+    MissingSlot,
+    ResolutionAction,
+    assess_from_attempt,
+    assess_from_family,
+    terminal_for_action,
+)
+from core.epistemic_disclosure.verified_contract import (
+    VERIFICATION_OBLIGATION,
+    VerificationObligation,
+    VerificationProof,
+    VerificationResult,
+    VerificationVerdict,
+    disclosure_for_verification,
+    evaluate_verification,
+)
+
+__all__ = [
+    "DEFAULT_DISCLOSURE_CLAIM",
+    "Q1B_ASK_CARVE_OUT",
+    "VERIFICATION_OBLIGATION",
+    "DisclosureClaim",
+    "LimitationAssessment",
+    "LimitationKind",
+    "MissingSlot",
+    "ResolutionAction",
+    "ServedAskDecision",
+    "ServedDisposition",
+    "VerificationObligation",
+    "VerificationProof",
+    "VerificationResult",
+    "VerificationVerdict",
+    "assess_from_attempt",
+    "assess_from_family",
+    "choose_served_disposition",
+    "disclosure_for_verification",
+    "evaluate_served_ask",
+    "evaluate_verification",
+    "terminal_for_action",
+]

core/epistemic_disclosure/ask_serving.py

@@ -0,0 +1,171 @@
+"""Stage 2 ASK served-surface artifact adapter.
+
+This module is intentionally narrow: it validates a pre-rendered Q1-D
+``DeliveredQuestion`` artifact and decides whether that artifact is eligible to
+be exposed as a served ASK/QUESTION_NEEDED surface. It does not acquire
+contemplation results from runtime and does not render question prose.
+
+Validation enforces the Q1-D artifact contract:
+
+- top-level JSON object only;
+- ``status == "question_only"``;
+- ``requires_review is True``;
+- ``served is False``;
+- ``answer_binding`` is absent or ``None``;
+- ``question`` is an object;
+- ``question.text`` is a non-empty string;
+- ``question.slot_name`` is a non-empty string;
+- ``question_path`` exists on disk and differs from ``proposal_path``.
+
+Any validation failure fails closed to the caller's fallback surface and
+standing disposition. The served text is consumed from the artifact exactly; no
+runtime prose construction or mutation happens here.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from core.epistemic_disclosure.disposition import ServedDisposition, choose_served_disposition
+from core.epistemic_disclosure.limitation import LimitationAssessment
+from core.epistemic_questions.serving_gate import ask_serving_enabled
+from core.epistemic_state import EpistemicState
+
+_MISSING = object()
+
+
+@dataclass(frozen=True, slots=True)
+class ServedAskDecision:
+    """The adapter's served-ASK decision."""
+
+    served: bool
+    terminal: str
+    surface: str
+    disposition: ServedDisposition
+
+
+def _terminal_value(contemplation_result: Any) -> str:
+    terminal = getattr(contemplation_result, "terminal", None)
+    if terminal is None:
+        return "NO_PROGRESS"
+    return str(getattr(terminal, "value", terminal))
+
+
+def _fallback_disposition(terminal: str) -> ServedDisposition:
+    if terminal == "PROPOSAL_EMITTED":
+        return ServedDisposition.PROPOSE
+    if terminal == "SOLVED_VERIFIED":
+        return ServedDisposition.COMMIT
+    return ServedDisposition.REFUSE
+
+
+def _fallback_decision(contemplation_result: Any, fallback_surface: str) -> ServedAskDecision:
+    terminal = _terminal_value(contemplation_result)
+    return ServedAskDecision(
+        served=False,
+        terminal=terminal,
+        surface=fallback_surface,
+        disposition=_fallback_disposition(terminal),
+    )
+
+
+def _validate_question_artifact(data: Any, *, question_path: Path, proposal_path: Any) -> str | None:
+    """Return the valid question text, or ``None`` for any contract violation."""
+
+    if not isinstance(data, dict):
+        return None
+    if data.get("status") != "question_only":
+        return None
+    if data.get("requires_review") is not True:
+        return None
+    served = data.get("served", _MISSING)
+    if served is _MISSING or served is not False:
+        return None
+    answer_binding = data.get("answer_binding", _MISSING)
+    if answer_binding is not _MISSING and answer_binding is not None:
+        return None
+
+    question = data.get("question")
+    if not isinstance(question, dict):
+        return None
+
+    text = question.get("text")
+    if not isinstance(text, str) or not text.strip():
+        return None
+
+    slot_name = question.get("slot_name")
+    if not isinstance(slot_name, str) or not slot_name.strip():
+        return None
+
+    if proposal_path is not None and str(question_path) == str(proposal_path):
+        return None
+
+    return text.strip()
+
+
+def evaluate_served_ask(
+    config: Any,
+    contemplation_result: Any,
+    fallback_surface: str,
+) -> ServedAskDecision:
+    """Evaluate whether a Q1-D question artifact may be surfaced as ASK.
+
+    This is a bus/disposition adapter, not a renderer and not the runtime
+    acquisition path. The caller supplies a contemplation result that already
+    points to a delivered question artifact. When the gate is disabled or any
+    artifact invariant fails, the adapter returns the fallback surface and the
+    standing fallback disposition.
+    """
+
+    if not ask_serving_enabled(config):
+        return _fallback_decision(contemplation_result, fallback_surface)
+
+    if _terminal_value(contemplation_result) != "QUESTION_NEEDED":
+        return _fallback_decision(contemplation_result, fallback_surface)
+
+    question_path_value = getattr(contemplation_result, "question_path", None)
+    proposal_path_value = getattr(contemplation_result, "proposal_path", None)
+    if not question_path_value or question_path_value == proposal_path_value:
+        return _fallback_decision(contemplation_result, fallback_surface)
+
+    question_path = Path(question_path_value)
+    if not question_path.is_file():
+        return _fallback_decision(contemplation_result, fallback_surface)
+
+    try:
+        payload = json.loads(question_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return _fallback_decision(contemplation_result, fallback_surface)
+
+    question_text = _validate_question_artifact(
+        payload,
+        question_path=question_path,
+        proposal_path=proposal_path_value,
+    )
+    if question_text is None:
+        return _fallback_decision(contemplation_result, fallback_surface)
+
+    limitation = LimitationAssessment(
+        limitation_kind="missing_information",
+        resolution_action="ask_question",
+        epistemic_state=EpistemicState.UNDETERMINED,
+        owner_organ=payload.get("owner_organ"),
+        blocking_reason=str(payload.get("blocking_reason", "")),
+    )
+    disposition = choose_served_disposition(
+        epistemic_state=EpistemicState.UNDETERMINED,
+        limitation=limitation,
+    )
+
+    return ServedAskDecision(
+        served=True,
+        terminal="QUESTION_NEEDED",
+        surface=question_text,
+        disposition=disposition,
+    )
+
+
+__all__ = ["ServedAskDecision", "evaluate_served_ask"]

core/epistemic_disclosure/disclosure_claim.py

@@ -0,0 +1,65 @@
+"""P0-2 — the DisclosureClaim axis (the epistemic claim a served response makes).
+
+A served response carries two ORTHOGONAL governance properties:
+
+  * ``ReachLevel`` (``core/response_governance/policy.py``) — how far PAST
+    fully-grounded fact the response reaches (STRICT < APPROXIMATE < EXTRAPOLATE
+    < CREATIVE).
+  * ``DisclosureClaim`` (here) — the EPISTEMIC CLAIM the response makes about its
+    own truth status.
+
+These are deliberately separate axes. ``verified`` is **not** a reach level — it is
+a claim about *proof state*, not about how far the response speculates. Conflating
+them (e.g. a hypothetical ``ReachLevel.VERIFIED``) would let a proven answer inherit
+an "approximate" surface, or an approximation inherit a "verified" badge. Keeping the
+axes distinct is the architectural commitment behind the Stage-2 lockfile
+(``docs/analysis/stage2-epistemic-disclosure-bus-verified-v1-scoping-2026-06-08.md`` §0).
+
+**Discipline — no claim without a producer** (the spine enforces on itself what it
+enforces on answers). Every member has a real or imminent emitter:
+
+  * ``NONE``          — every response today (the baseline; STRICT + NONE).
+  * ``APPROXIMATE``   — active: the cognition Step-E disclosed estimate
+                        (``estimation_enabled`` / ADR-0206 §5).
+  * ``PROPOSAL_ONLY`` — active: ``teaching/proposals`` emits review-only proposals.
+  * ``VERIFIED``      — the imminent frontier: its producer is Phase 1 (P1-A..),
+                        declared because it is the v1 target the bus is built around.
+
+Two claims are intentionally ABSENT, because nothing can emit them — and the spine
+will not declare a label it cannot earn:
+
+  * ``PROVEN``    — a claim stronger than VERIFIED; no plan to build a producer.
+  * ``ESTIMATED`` — a *future* split of ``APPROXIMATE`` into a distinct
+                    numeric-estimate claim, added ONLY once a real estimator producer
+                    exists. Until then the cognition estimate is ``APPROXIMATE``.
+
+P0-2 ships ONLY the axis + its default. No bus behaviour, no mapping to a disposition
+(that is P0-3 / ServedDisposition). Off-serving: this module imports nothing.
+"""
+
+from __future__ import annotations
+
+from enum import Enum, unique
+
+
+@unique
+class DisclosureClaim(str, Enum):
+    """The epistemic claim a served surface makes about its own truth status.
+
+    Orthogonal to ``ReachLevel``. ``str``-valued for stable serialization into
+    telemetry / disposition records (the same convention as ``EpistemicState``).
+    """
+
+    NONE = "none"  # no epistemic claim beyond the plain surface (the default)
+    VERIFIED = "verified"  # independently confirmed under a canonical-comparison contract
+    APPROXIMATE = "approximate"  # a disclosed best-estimate from incomplete evidence
+    PROPOSAL_ONLY = "proposal_only"  # offered as a proposal for review, not asserted
+
+
+#: The default claim: a surface asserts nothing about its truth status unless a
+#: producer upgrades it. ``STRICT`` reach + ``NONE`` claim is today's every-response
+#: baseline.
+DEFAULT_DISCLOSURE_CLAIM: DisclosureClaim = DisclosureClaim.NONE
+
+
+__all__ = ["DEFAULT_DISCLOSURE_CLAIM", "DisclosureClaim"]

core/epistemic_disclosure/disposition.py

@@ -0,0 +1,110 @@
+"""P0-3 — ServedDisposition: the served-surface decision (mapping scaffold only).
+
+The third axis of the Epistemic Disclosure bus. Given (a) the epistemic state, (b)
+the limitation assessment (if resolution is blocked), and (c) the disclosure claim,
+:func:`choose_served_disposition` decides WHAT KIND OF MOVE the served surface makes:
+commit / disclose / ask / propose / report / explain / refuse / step-aside.
+
+This is a PURE MAPPING. No rendering, no bus behaviour, no ``verify.py``, no
+``govern_response`` mutation — nothing consumes the result yet. P0-3 only fixes the
+decision table so a later slice / Phase 1 can wire it.
+
+The load-bearing rule (the Phase-1 guard): a ``DisclosureClaim.VERIFIED`` discloses
+ONLY when the epistemic state is actually ``EpistemicState.VERIFIED``. An unbacked
+verified claim degrades to a plain ``COMMIT`` — it is NEVER served as verified before
+the producer exists. This protects the whole VERIFIED lane from accidental
+"verified-looking" serving.
+
+Off-serving: imports no ``generate.derivation`` / ``core.reliability_gate``.
+"""
+
+from __future__ import annotations
+
+from enum import Enum, unique
+
+from core.epistemic_disclosure.disclosure_claim import DisclosureClaim
+from core.epistemic_disclosure.limitation import LimitationAssessment
+from core.epistemic_state import EpistemicState
+
+
+@unique
+class ServedDisposition(str, Enum):
+    """What kind of move the served surface makes.
+
+    ``str``-valued for stable serialization (the ``EpistemicState`` /
+    ``DisclosureClaim`` convention).
+    """
+
+    COMMIT = "commit"  # serve a fully-grounded answer as-is, no epistemic caveat
+    DISCLOSE = "disclose"  # serve under a disclosure claim ([verified] / [approximate])
+    ASK = "ask"  # ask the user for the missing/ambiguous datum (Q1 tenant)
+    PROPOSE = "propose"  # offer a review-only capability proposal, do not assert
+    REPORT = "report"  # report a contradiction with a supplied answer key
+    EXPLAIN = "explain"  # explain that the ask is outside the current envelope (scope)
+    REFUSE = "refuse"  # hard-stop refusal (impossible / unreadable / known boundary)
+    STEP_ASIDE = "step_aside"  # not this organ's domain — cede
+
+
+def choose_served_disposition(
+    *,
+    epistemic_state: EpistemicState,
+    limitation: LimitationAssessment | None,
+    disclosure_claim: DisclosureClaim = DisclosureClaim.NONE,
+) -> ServedDisposition:
+    """Decide the served disposition. Pure, deterministic, total.
+
+    A blocking limitation dominates — you do not serve an answer, you ask / propose /
+    report / explain / refuse / step aside per its resolution action. (A limitation
+    whose action is ``answer`` is non-blocking and falls through to the serve
+    decision.) With no blocking limitation, the disclosure claim + epistemic state pick
+    the serve mode, under the Phase-1 ``VERIFIED`` guard.
+
+    NOTE (scaffold trust boundary): a blocking epistemic state (CONTRADICTED,
+    AMBIGUOUS, UNDETERMINED) reaches this function AS a limitation (e.g. a contradiction
+    arrives as ``report_contradiction``), not as ``limitation=None``. The serve branch
+    trusts ``limitation=None`` to mean "servable".
+    """
+    if limitation is not None:
+        match limitation.resolution_action:
+            case "ask_question":
+                return ServedDisposition.ASK
+            case "emit_proposal":
+                return ServedDisposition.PROPOSE
+            case "report_contradiction":
+                return ServedDisposition.REPORT
+            case "step_aside":
+                return ServedDisposition.STEP_ASIDE
+            case "refuse_known_boundary":
+                # scope_boundary is the governed "outside the current envelope"
+                # disposition — it may render as a refusal later, but must NOT collapse
+                # into a hard boundary here.
+                if limitation.limitation_kind == "scope_boundary":
+                    return ServedDisposition.EXPLAIN
+                return ServedDisposition.REFUSE
+            case "answer":
+                pass  # non-blocking — fall through to the serve decision
+
+    return _serve_disposition(epistemic_state, disclosure_claim)
+
+
+def _serve_disposition(
+    epistemic_state: EpistemicState, disclosure_claim: DisclosureClaim
+) -> ServedDisposition:
+    """The no-blocking-limitation branch: claim + state pick the serve mode."""
+    match disclosure_claim:
+        case DisclosureClaim.VERIFIED:
+            # The Phase-1 guard: disclose-as-verified ONLY with the backing state.
+            if epistemic_state is EpistemicState.VERIFIED:
+                return ServedDisposition.DISCLOSE
+            return ServedDisposition.COMMIT
+        case DisclosureClaim.APPROXIMATE:
+            return ServedDisposition.DISCLOSE
+        case DisclosureClaim.PROPOSAL_ONLY:
+            return ServedDisposition.PROPOSE
+        case DisclosureClaim.NONE:
+            return ServedDisposition.COMMIT
+        case _:  # pragma: no cover - exhaustive over the 4-member enum; loud if extended
+            raise AssertionError(f"unhandled disclosure_claim: {disclosure_claim!r}")
+
+
+__all__ = ["ServedDisposition", "choose_served_disposition"]

core/epistemic_disclosure/limitation.py

@@ -0,0 +1,378 @@
+"""P0-1 — the pre-question limitation pass, as a CONSOLIDATING VIEW (session §1.5).
+
+The intake gate of the Epistemic Disclosure spine: before contemplation chooses a
+served disposition, it classifies *what KIND of limitation* is blocking resolution.
+Asking a question is only one possible resolution, and asking is wrong unless the
+limitation is specifically the kind a question resolves (missing/ambiguous external
+information). Mis-classify and intake breaks two ways — refuse-when-should-ask (lose
+the unlocking datum) or ask-when-should-propose (waste the channel).
+
+This module is the first slice: the typed vocabulary (:data:`LimitationKind` /
+:data:`ResolutionAction` / :class:`LimitationAssessment`) and the *mapping* that
+DERIVES each from the already-shipped failure-family registry
+(:data:`core.comprehension_attempt.failure_family.REGISTRY`) and contemplation
+:class:`~generate.contemplation.findings.Terminal` set.
+
+**Hard invariant (no fourth taxonomy).** Every assessment is mechanically derived
+from an existing ``FailureFamily``; the *only* genuinely new resolution action is
+``ask_question`` (the Q1/ASK tenant). Through Q1-C it was the one action with no
+shipped terminal; Q1-D adds :attr:`~generate.contemplation.findings.Terminal.QUESTION_NEEDED`
+(sibling of ``PROPOSAL_EMITTED``), so :func:`terminal_for_action` is now total — every
+action maps onto a shipped terminal, which is what makes this a consolidating view.
+
+**Q1-B transitional carve-out (this slice).** Two shipped families —
+``missing_total_count`` and ``missing_weighted_total`` — are classified here as
+``missing_information`` / ``ask_question``: the user *could state the total* and
+unblock solving, so they are missing data, not capability gaps. The shipped
+:data:`REGISTRY` still flags them ``proposal_allowed = True`` so that existing
+consumers (:mod:`core.comprehension_attempt.proposal` /
+:mod:`generate.contemplation.pass_manager`) keep emitting proposal-only artifacts
+to the pile — until Q1-C/Q1-D wire ASK delivery to a served surface there is
+nowhere for an ``ask_question`` to go, and silently dropping the proposal signal
+would be a capability regression with no compensating intake. Once ASK is serving,
+the REGISTRY flag flips to ``False`` and the carve-out
+(:data:`Q1B_ASK_CARVE_OUT`) retires. The carve-out is named, enumerated, and
+covered by an explicit test (``tests/test_limitation_assessment.py``) so its
+removal is a conscious act, not a silent re-key.
+
+**Off-serving.** Imports no ``generate.derivation`` / ``core.reliability_gate``; it
+cannot move the sealed GSM8K metric. Nothing consumes ``resolution_action`` to change
+serving yet — this slice only *classifies* and *describes residue*.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+from core.comprehension_attempt.failure_family import (
+    FailureFamily,
+    family_for_reason,
+)
+from core.comprehension_attempt.model import ComprehensionAttempt
+from core.epistemic_state import EpistemicState
+from generate.contemplation.findings import Terminal
+
+#: Why resolution is blocked. The split from :data:`ResolutionAction` keeps *state*
+#: ("what is true / missing") distinct from *action* ("what to do about it").
+LimitationKind = Literal[
+    "missing_information",  # a needed datum is absent — could be supplied → ask
+    "ambiguous_structure",  # data present, relationship unclear → ask (when user-resolvable)
+    "scope_boundary",  # exceeds the current capability/evidence envelope → refuse/explain
+    "capability_gap",  # info present, CORE lacks the transform → propose (or refuse if signal too coarse)
+    "hard_boundary",  # mathematically/logically impossible or undefined → refuse
+    "contradiction",  # evidence conflicts with a claimed answer → report
+    "renderability_gap",  # asking is right but terms aren't grounded enough to name safely → ask-generic
+    "input_shape",  # not this organ's domain → step aside
+]
+
+#: What to do about a limitation. ``ask_question`` is the genuinely new action this
+#: spine introduces; the other five each correspond to a shipped contemplation
+#: terminal (:func:`terminal_for_action`).
+ResolutionAction = Literal[
+    "answer",
+    "ask_question",
+    "emit_proposal",
+    "refuse_known_boundary",
+    "report_contradiction",
+    "step_aside",
+]
+
+
+@dataclass(frozen=True, slots=True)
+class MissingSlot:
+    """One typed slot the ASK limitation identifies as missing.
+
+    A *structural* description (NOT user-renderable prose): ``slot_name`` is the
+    family-defined slot identifier (e.g. ``"total_count"``); ``expected_unit_or_type``
+    is the family-typed expectation a future bound answer must satisfy (e.g.
+    ``"count_int"``); ``binding_target`` is the structural role the slot fills in
+    the organ's setup (e.g. ``"collective_unit_total"``), which Q2 answer-binding
+    re-enters the gate against (scoping §4). Renderable, user-facing strings come
+    later from grounded text spans (:attr:`LimitationAssessment.grounded_terms`),
+    NEVER from these snake_case identifiers — that split is what keeps the renderer
+    wrong=0-safe (scoping §2).
+    """
+
+    slot_name: str
+    expected_unit_or_type: str
+    binding_target: str
+
+
+@dataclass(frozen=True, slots=True)
+class LimitationAssessment:
+    """One typed classification of the limitation blocking a comprehension attempt.
+
+    ``epistemic_state`` (what is true) and ``resolution_action`` (what to do) are
+    deliberately distinct: e.g. ``UNDETERMINED`` + ``ask_question`` for a missing
+    datum. ``blocking_reason`` is the failure-family key (the partition key), so the
+    assessment is back-traceable to the shipped registry.
+
+    ``missing_slots`` and ``grounded_terms`` are the ASK *typed residue* — populated
+    only for ``ask_question`` resolutions by :func:`assess_from_attempt`. Both
+    default to empty so existing P0-1 callers using :func:`assess_from_family`
+    continue to work unchanged. The wrong=0 invariant (scoping §2): a slot here
+    carries family-typed structural identifiers only; renderable prose must come
+    from ``grounded_terms`` (verbatim text spans), never fabricated.
+    """
+
+    limitation_kind: LimitationKind
+    resolution_action: ResolutionAction
+    epistemic_state: EpistemicState
+    owner_organ: str | None
+    blocking_reason: str
+    missing_slots: tuple[MissingSlot, ...] = field(default_factory=tuple)
+    grounded_terms: tuple[str, ...] = field(default_factory=tuple)
+
+
+# --- The consolidating mapping (derived from the shipped registry, not invented) ---
+
+#: ``EpistemicState`` each kind asserts. ``scope_boundary`` lights up the RESERVED
+#: ``SCOPE_BOUNDARY`` state with a real producer; ``contradiction`` / ``ambiguous``
+#: reuse the ACTIVE states. The refuse/propose kinds share ``UNDETERMINED`` — the
+#: *kind* carries the distinction, the *state* only says "no answer determined".
+_KIND_TO_STATE: dict[LimitationKind, EpistemicState] = {
+    "missing_information": EpistemicState.UNDETERMINED,
+    "ambiguous_structure": EpistemicState.AMBIGUOUS,
+    "scope_boundary": EpistemicState.SCOPE_BOUNDARY,
+    "capability_gap": EpistemicState.UNDETERMINED,
+    "hard_boundary": EpistemicState.UNDETERMINED,
+    "contradiction": EpistemicState.CONTRADICTED,
+    "renderability_gap": EpistemicState.UNDETERMINED,
+    "input_shape": EpistemicState.UNDETERMINED,
+}
+
+#: The shipped contemplation ``Terminal`` each action corresponds to. Through Q1-C
+#: ``ask_question`` mapped to ``None`` (the one action the spine added with no terminal
+#: yet); Q1-D ships ``QUESTION_NEEDED`` (sibling of ``PROPOSAL_EMITTED``), so the map is
+#: now TOTAL — all six actions correspond to shipped terminals. This totality is the
+#: proof the limitation pass is a consolidating view, not a new universe.
+#:
+#: NOTE: this is the action's *home* terminal "in principle". The terminal a Q1-D
+#: *delivery* actually emits depends on renderability — an unrenderable ``ask_question``
+#: falls back to the family's standing disposition (the D2 guard in
+#: :mod:`core.epistemic_questions.delivery`), it does NOT emit a contentless
+#: ``QUESTION_NEEDED``.
+_ACTION_TO_TERMINAL: dict[ResolutionAction, Terminal] = {
+    "answer": Terminal.SOLVED_VERIFIED,
+    "emit_proposal": Terminal.PROPOSAL_EMITTED,
+    "refuse_known_boundary": Terminal.REFUSED_KNOWN_BOUNDARY,
+    "report_contradiction": Terminal.CONTRADICTION_DETECTED,
+    "step_aside": Terminal.NO_PROGRESS,
+    "ask_question": Terminal.QUESTION_NEEDED,
+}
+
+#: **Transitional carve-out (Q1-B).** Families this slice classifies as
+#: ``ask_question`` in the limitation layer while their shipped
+#: :data:`REGISTRY` entries keep ``proposal_allowed = True`` so the contemplation
+#: pass and proposal pile keep working unchanged. This is an honest migration seam:
+#: the disclosure layer speaks the truthful classification now; the operational
+#: layer keeps the current signal so nothing regresses before Q1-C/Q1-D wires ASK
+#: delivery. Retirement: once ASK is serving, flip ``proposal_allowed = False`` on
+#: these two families in :mod:`core.comprehension_attempt.failure_family`, drop
+#: this set, and amend the ``proposal_allowed`` invariant in tests.
+Q1B_ASK_CARVE_OUT: frozenset[str] = frozenset(
+    {"missing_total_count", "missing_weighted_total"}
+)
+
+#: family name → (LimitationKind, ResolutionAction). Keys must equal the REGISTRY's
+#: family names exactly (asserted total by test). Classification rationale per family:
+#:  - growth surfaces (``proposal_allowed``) → ``capability_gap`` / ``emit_proposal``
+#:    EXCEPT :data:`Q1B_ASK_CARVE_OUT` — see that constant's docstring
+#:  - underdetermined / missing-datum refusals → ``missing_information`` / ``ask_question``
+#:  - same-unit-but-no-cue ambiguity the user could resolve → ``ambiguous_structure`` / ask
+#:  - math/logic impossibility, incoherence, coarse-signal parse gaps → ``hard_boundary`` / refuse
+#:  - beyond-current-solver-envelope → ``scope_boundary`` / refuse
+#:  - the answer-key verdict → ``contradiction`` / ``report_contradiction``
+#:  - foreign text → ``input_shape`` / ``step_aside``
+_FAMILY_TO_LIMITATION: dict[str, tuple[LimitationKind, ResolutionAction]] = {
+    # cross-organ
+    "input_shape": ("input_shape", "step_aside"),
+    "admissibility_incompatible": ("hard_boundary", "refuse_known_boundary"),
+    # R1
+    "unsupported_clause_shape": ("capability_gap", "refuse_known_boundary"),
+    "ungrounded_base": ("missing_information", "ask_question"),
+    "over_determined": ("hard_boundary", "refuse_known_boundary"),
+    # R2 boundaries
+    "unsupported_system_size": ("scope_boundary", "refuse_known_boundary"),
+    "indistinguishable_system": ("hard_boundary", "refuse_known_boundary"),
+    "non_integer_solution": ("hard_boundary", "refuse_known_boundary"),
+    "negative_solution": ("hard_boundary", "refuse_known_boundary"),
+    "answer_choice_unresolved": ("ambiguous_structure", "refuse_known_boundary"),
+    # R2 growth surfaces — Q1-B reclassification (see Q1B_ASK_CARVE_OUT):
+    # disclosure says ask; REGISTRY still emits proposals to the pile.
+    "missing_total_count": ("missing_information", "ask_question"),
+    "missing_weighted_total": ("missing_information", "ask_question"),
+    "missing_category_pair": ("capability_gap", "emit_proposal"),
+    "missing_attribute_coefficient": ("capability_gap", "emit_proposal"),
+    # R2 verdict
+    "answer_key_contradiction": ("contradiction", "report_contradiction"),
+    # R3
+    "unsupported_rate_duration": ("capability_gap", "emit_proposal"),
+    "rate_underdetermined": ("missing_information", "ask_question"),
+    "unsupported_temporal_state": ("scope_boundary", "refuse_known_boundary"),
+    # R4 combined-rate boundaries
+    "cmb_unit_mismatch": ("hard_boundary", "refuse_known_boundary"),
+    "cmb_combine_ambiguous": ("ambiguous_structure", "ask_question"),
+    "cmb_underdetermined": ("missing_information", "ask_question"),
+    "cmb_non_positive_net": ("hard_boundary", "refuse_known_boundary"),
+    "cmb_non_integer": ("hard_boundary", "refuse_known_boundary"),
+    # R4 growth surfaces
+    "cmb_unsupported_rate_count": ("capability_gap", "emit_proposal"),
+    "cmb_unsupported_reciprocal": ("capability_gap", "emit_proposal"),
+    "cmb_unsupported_clock_interval": ("capability_gap", "emit_proposal"),
+}
+
+#: family name → typed slots an ASK assessment for that family identifies as missing.
+#: Only families with a *known* slot structure appear here; an ask-mapped family without
+#: an entry yields an empty residue (the "minimal" stance — never fabricate a slot the
+#: family's contract has not pinned down yet). Slot semantics, per family:
+#:  - ``missing_total_count``  : the collective-unit total count (R2 constraint C7);
+#:    ``binding_target`` matches the equation slot the augmented input would fill
+#:    (Q2 re-entry, scoping §4).
+#:  - ``missing_weighted_total``: the measured-unit weighted total (R2 constraint C8).
+#: Other ask-mapped families (``ungrounded_base``, ``rate_underdetermined``,
+#: ``cmb_underdetermined``, ``cmb_combine_ambiguous``) get slots in later Q1 sub-PRs
+#: once their per-family slot signatures are pinned with tests.
+_FAMILY_TO_MISSING_SLOTS: dict[str, tuple[MissingSlot, ...]] = {
+    "missing_total_count": (
+        MissingSlot(
+            slot_name="total_count",
+            expected_unit_or_type="count_int",
+            binding_target="collective_unit_total",
+        ),
+    ),
+    "missing_weighted_total": (
+        MissingSlot(
+            slot_name="weighted_total",
+            expected_unit_or_type="measured_unit_int",
+            binding_target="weighted_total_value",
+        ),
+    ),
+}
+
+# A conservative refusal for any family/reason that is not in the mapping. The total
+# mapping (asserted by test against REGISTRY) means this is dead in practice; if a new
+# family ever lands unmapped, it refuses — it NEVER silently becomes an answerable
+# question (the wrong=0-safe default).
+_CONSERVATIVE_DEFAULT: tuple[LimitationKind, ResolutionAction] = (
+    "hard_boundary",
+    "refuse_known_boundary",
+)
+
+
+def assess_from_family(family: FailureFamily) -> LimitationAssessment:
+    """The limitation a failure family expresses, as a typed assessment.
+
+    Total over :data:`REGISTRY` (asserted by test). An unmapped family falls to the
+    conservative refuse default — never ``ask_question``. Residue defaults to empty;
+    populating typed slots / grounded terms requires a specific attempt (use
+    :func:`assess_from_attempt`).
+    """
+    kind, action = _FAMILY_TO_LIMITATION.get(family.name, _CONSERVATIVE_DEFAULT)
+    return LimitationAssessment(
+        limitation_kind=kind,
+        resolution_action=action,
+        epistemic_state=_KIND_TO_STATE[kind],
+        owner_organ=family.owner,
+        blocking_reason=family.name,
+    )
+
+
+def _residue_from_attempt(
+    attempt: ComprehensionAttempt,
+    family: FailureFamily,
+    action: ResolutionAction,
+) -> tuple[tuple[MissingSlot, ...], tuple[str, ...]]:
+    """Typed ASK residue for an ask-mapped attempt — empty for any other action.
+
+    Wrong=0 invariant (scoping §2): ``grounded_terms`` carries only verbatim text from
+    :attr:`ComprehensionAttempt.evidence` SourceSpanLinks. If the attempt carries no
+    evidence (today: every refused attempt — :mod:`core.comprehension_attempt.classify`
+    leaves ``evidence = ()``), ``grounded_terms`` is empty, NEVER fabricated from the
+    family or the refusal reason. ``missing_slots`` is family-derived (snake_case
+    structural identifiers, not renderable prose) so it is always safe to emit; absent
+    from :data:`_FAMILY_TO_MISSING_SLOTS` ⇒ no slots (minimal stance — never invent a
+    slot the family contract has not pinned down).
+    """
+    if action != "ask_question":
+        return ((), ())
+    slots = _FAMILY_TO_MISSING_SLOTS.get(family.name, ())
+    grounded = tuple(link.text for link in attempt.evidence)
+    return (slots, grounded)
+
+
+def assess_from_attempt(attempt: ComprehensionAttempt) -> LimitationAssessment | None:
+    """Classify the limitation a comprehension attempt expresses, or ``None``.
+
+    - ``contradiction`` outcome → report it (no refusal reason carries this; it is the
+      answer-choice verdict).
+    - a refusal → classify via its failure family; an *unclassified* refusal reason
+      falls to the conservative refuse default (never ``ask_question``).
+    - any non-limitation outcome (solved/admissible setup, or eval-only ``*_wrong``)
+      → ``None``: there is no resolvable limitation to act on.
+
+    For ask-mapped refusals, the returned assessment carries typed residue
+    (:attr:`~LimitationAssessment.missing_slots` / ``grounded_terms``) per
+    :func:`_residue_from_attempt`'s wrong=0 invariant.
+    """
+    if attempt.outcome == "contradiction":
+        return LimitationAssessment(
+            limitation_kind="contradiction",
+            resolution_action="report_contradiction",
+            epistemic_state=EpistemicState.CONTRADICTED,
+            owner_organ=attempt.organ,
+            blocking_reason="answer_key_contradiction",
+        )
+    if not attempt.is_refusal:
+        return None
+    family = family_for_reason(attempt.refusal_reason)
+    if family is None:
+        kind, action = _CONSERVATIVE_DEFAULT
+        return LimitationAssessment(
+            limitation_kind=kind,
+            resolution_action=action,
+            epistemic_state=_KIND_TO_STATE[kind],
+            owner_organ=attempt.organ,
+            blocking_reason=attempt.refusal_reason or "unclassified",
+        )
+    base = assess_from_family(family)
+    missing_slots, grounded_terms = _residue_from_attempt(
+        attempt, family, base.resolution_action
+    )
+    if not missing_slots and not grounded_terms:
+        return base
+    return LimitationAssessment(
+        limitation_kind=base.limitation_kind,
+        resolution_action=base.resolution_action,
+        epistemic_state=base.epistemic_state,
+        owner_organ=attempt.organ,
+        blocking_reason=base.blocking_reason,
+        missing_slots=missing_slots,
+        grounded_terms=grounded_terms,
+    )
+
+
+def terminal_for_action(action: ResolutionAction) -> Terminal:
+    """The shipped contemplation ``Terminal`` an action corresponds to — total.
+
+    Every action maps to a shipped terminal; ``ask_question`` resolves to
+    ``QUESTION_NEEDED`` (added by Q1-D, sibling of ``PROPOSAL_EMITTED``). That totality
+    is what makes this a consolidating view rather than a new taxonomy. This is the
+    action's *home* terminal; the terminal a Q1-D delivery actually emits may differ
+    when the question is unrenderable (the D2 fallback — see
+    :mod:`core.epistemic_questions.delivery`).
+    """
+    return _ACTION_TO_TERMINAL[action]
+
+
+__all__ = [
+    "Q1B_ASK_CARVE_OUT",
+    "LimitationAssessment",
+    "LimitationKind",
+    "MissingSlot",
+    "ResolutionAction",
+    "assess_from_attempt",
+    "assess_from_family",
+    "terminal_for_action",
+]

core/epistemic_disclosure/serving_gate.py

@@ -0,0 +1,33 @@
+"""VERIFIED serving gate helper — default-dark, no served-surface wiring.
+
+This module centralizes the future kill-switch predicate for VERIFIED serving.
+It is default-dark / fail-closed: if the config field is missing or malformed,
+it must evaluate to False.
+
+This helper only centralizes the future kill-switch predicate so that future serving code
+has one audited predicate. It does not wire any served-surface or implement served
+VERIFIED behavior. Missing field means False.
+
+Note that eval-gold-backed producers (such as the verification producer in
+evals/constraint_oracle/verified_producer.py) are not serving-eligible.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from core.config import DEFAULT_CONFIG, RuntimeConfig
+
+
+def verified_serving_enabled(config: RuntimeConfig | Any | None = None) -> bool:
+    """Return whether served VERIFIED delivery is explicitly enabled.
+
+    Missing attribute means False. This is the load-bearing dark-gate invariant:
+    the served VERIFIED path cannot light merely because the helper exists or because
+    an older RuntimeConfig instance lacks the future field.
+    """
+    cfg = DEFAULT_CONFIG if config is None else config
+    return bool(getattr(cfg, "verified_serving_enabled", False))
+
+
+__all__ = ["verified_serving_enabled"]