diff --git a/.github/workflows/det-gates.yml b/.github/workflows/det-gates.yml
new file mode 100644
index 00000000..7024511e
--- /dev/null
+++ b/.github/workflows/det-gates.yml
@@ -0,0 +1,280 @@
+# SPDX-License-Identifier: Apache-2.0
+# © James Ross Ω FLYING•ROBOTS <https://github.com/flyingrobots>
+name: det-gates
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  classify-changes:
+    name: classify-changes
+    runs-on: ubuntu-latest
+    outputs:
+      run_full: ${{ steps.classify.outputs.run_full }}
+      run_reduced: ${{ steps.classify.outputs.run_reduced }}
+      run_none: ${{ steps.classify.outputs.run_none }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Detect changed files
+        id: changed
+        env:
+          BASE_REF: ${{ github.base_ref }}
+          EVENT_NAME: ${{ github.event_name }}
+        run: |
+          if [ "$EVENT_NAME" = "pull_request" ]; then
+            git fetch origin "$BASE_REF" --depth=1
+            git diff --name-only "origin/$BASE_REF...HEAD" > changed.txt
+          else
+            git diff --name-only HEAD~1..HEAD > changed.txt || true
+          fi
+          echo "Changed files:"
+          cat changed.txt || true
+
+      - name: Convert policy to JSON
+        run: |
+          yq -o=json det-policy.yaml > det-policy.json
+
+      - name: Classify path impact from det-policy.yaml
+        id: classify
+        run: |
+          node ./scripts/classify_changes.cjs det-policy.json changed.txt >> $GITHUB_OUTPUT
+
+  determinism-linux:
+    name: G1 determinism (linux)
+    needs: classify-changes
+    if: needs.classify-changes.outputs.run_full == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+      - name: Run parity tests (linux)
+        run: |
+          cargo test -p echo-scene-port test_float_parity_with_js -- --nocapture 2>&1 | tee det-linux.log
+          grep -q " 0 passed" det-linux.log && echo "FATAL: zero tests matched filter" && exit 1 || true
+      - name: Run DIND suite (linux)
+        run: |
+          node scripts/dind-run-suite.mjs --mode run | tee dind-linux.log
+      - name: Create digest table
+        env:
+          COMMIT_SHA: ${{ github.sha }}
+          RUN_ID: ${{ github.run_id }}
+        run: |
+          mkdir -p artifacts
+          echo "target,commit,run_id,digest" > artifacts/digest-table.csv
+          echo "linux,${COMMIT_SHA},${RUN_ID},$(sha256sum dind-report.json | cut -d' ' -f1)" >> artifacts/digest-table.csv
+      - name: Upload artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: det-linux-artifacts
+          path: |
+            det-linux.log
+            dind-linux.log
+            dind-report.json
+            artifacts/digest-table.csv
+
+  determinism-macos:
+    name: G1 determinism (macos)
+    needs: classify-changes
+    if: needs.classify-changes.outputs.run_full == 'true'
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+      - name: Run parity tests (macos)
+        run: |
+          cargo test -p echo-scene-port test_float_parity_with_js -- --nocapture 2>&1 | tee det-macos.log
+          grep -q " 0 passed" det-macos.log && echo "FATAL: zero tests matched filter" && exit 1 || true
+      - name: Run DIND suite (macos)
+        run: |
+          node scripts/dind-run-suite.mjs --mode run | tee dind-macos.log
+      - name: Create digest table
+        env:
+          COMMIT_SHA: ${{ github.sha }}
+          RUN_ID: ${{ github.run_id }}
+        run: |
+          mkdir -p artifacts
+          echo "target,commit,run_id,digest" > artifacts/digest-table.csv
+          echo "macos,${COMMIT_SHA},${RUN_ID},$(shasum -a 256 dind-report.json | cut -d' ' -f1)" >> artifacts/digest-table.csv
+      - name: Upload artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: det-macos-artifacts
+          path: |
+            det-macos.log
+            dind-macos.log
+            dind-report.json
+            artifacts/digest-table.csv
+
+  static-inspection:
+    name: DET-001 Static Inspection
+    needs: classify-changes
+    if: needs.classify-changes.outputs.run_full == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install ripgrep
+        run: command -v rg >/dev/null || (sudo apt-get update && sudo apt-get install -y ripgrep)
+      - name: Run determinism check
+        id: det_check
+        env:
+          DETERMINISM_PATHS: "crates/warp-core crates/warp-geom crates/warp-wasm crates/warp-ffi crates/echo-wasm-abi crates/echo-scene-port crates/echo-scene-codec crates/echo-graph crates/echo-ttd crates/echo-dind-harness crates/echo-dind-tests crates/ttd-browser crates/ttd-protocol-rs crates/ttd-manifest"
+        run: |
+          ./scripts/ban-nondeterminism.sh | tee static-inspection.log
+      - name: Create report
+        if: always()
+        env:
+          DET_OUTCOME: ${{ steps.det_check.outcome }}
+        run: |
+          if [ "$DET_OUTCOME" = "success" ]; then
+            echo '{"claim_id": "DET-001", "status": "PASSED"}' > static-inspection.json
+          else
+            echo '{"claim_id": "DET-001", "status": "FAILED"}' > static-inspection.json
+          fi
+      - name: Upload inspection artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: static-inspection
+          path: |
+            static-inspection.log
+            static-inspection.json
+
+  decoder-security:
+    name: G2 decoder security tests
+    needs: classify-changes
+    if: needs.classify-changes.outputs.run_full == 'true' || needs.classify-changes.outputs.run_reduced == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+      - name: Run codec tests
+        run: |
+          cargo test -p echo-scene-codec --lib cbor::tests -- --nocapture 2>&1 | tee sec-tests.log
+          grep -q " 0 passed" sec-tests.log && echo "FATAL: zero tests matched filter" && exit 1 || true
+      - name: Upload security artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: sec-artifacts
+          path: |
+            sec-tests.log
+            docs/determinism/sec-claim-map.json
+
+  perf-regression:
+    name: G3 perf regression (criterion)
+    needs: classify-changes
+    if: needs.classify-changes.outputs.run_none != 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+      - name: Run benchmarks
+        run: |
+          cargo bench -p warp-benches --bench materialization_hotpath -- --output-format bencher | tee perf.log
+      - name: Upload perf artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: perf-artifacts
+          path: perf.log
+
+  build-repro:
+    name: G4 build reproducibility (wasm)
+    needs: classify-changes
+    if: needs.classify-changes.outputs.run_full == 'true' || needs.classify-changes.outputs.run_reduced == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Rust (Global)
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: wasm32-unknown-unknown
+      - name: Checkout Build 1
+        uses: actions/checkout@v4
+        with:
+          path: build1
+      - name: Build 1
+        run: |
+          cd build1
+          rustup target add wasm32-unknown-unknown
+          cargo build --release --target wasm32-unknown-unknown -p ttd-browser
+          sha256sum target/wasm32-unknown-unknown/release/ttd_browser.wasm > ../hash1.txt
+          cp target/wasm32-unknown-unknown/release/ttd_browser.wasm ../build1.wasm
+      - name: Checkout Build 2
+        uses: actions/checkout@v4
+        with:
+          path: build2
+      - name: Build 2
+        run: |
+          cd build2
+          rustup target add wasm32-unknown-unknown
+          cargo build --release --target wasm32-unknown-unknown -p ttd-browser
+          sha256sum target/wasm32-unknown-unknown/release/ttd_browser.wasm > ../hash2.txt
+          cp target/wasm32-unknown-unknown/release/ttd_browser.wasm ../build2.wasm
+      - name: Compare hashes
+        run: |
+          diff hash1.txt hash2.txt || (echo "Reproducibility failure: Hashes differ!" && exit 1)
+          echo "Hashes match: $(cat hash1.txt)"
+      - name: Upload build artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: build-repro-artifacts
+          path: |
+            hash1.txt
+            hash2.txt
+            build1.wasm
+            build2.wasm
+
+  validate-evidence:
+    name: Evidence schema / claim policy
+    needs:
+      - classify-changes
+      - determinism-linux
+      - determinism-macos
+      - static-inspection
+      - decoder-security
+      - perf-regression
+      - build-repro
+    if: always() && needs.classify-changes.result == 'success' && needs.classify-changes.outputs.run_none != 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: gathered-artifacts
+      - name: Verify artifact presence
+        env:
+          RUN_FULL: ${{ needs.classify-changes.outputs.run_full }}
+        run: |
+          ls -R gathered-artifacts
+          # Always required (run on both full and reduced)
+          [ -d gathered-artifacts/sec-artifacts ] || (echo "Missing sec-artifacts" && exit 1)
+          [ -d gathered-artifacts/build-repro-artifacts ] || (echo "Missing build-repro-artifacts" && exit 1)
+          [ -d gathered-artifacts/perf-artifacts ] || (echo "Missing perf-artifacts" && exit 1)
+          # Only required when run_full (these jobs are skipped for run_reduced)
+          if [ "$RUN_FULL" = "true" ]; then
+            [ -d gathered-artifacts/det-linux-artifacts ] || (echo "Missing det-linux-artifacts" && exit 1)
+            [ -d gathered-artifacts/det-macos-artifacts ] || (echo "Missing det-macos-artifacts" && exit 1)
+            [ -d gathered-artifacts/static-inspection ] || (echo "Missing static-inspection" && exit 1)
+          fi
+      - name: Generate evidence pack
+        run: |
+          node scripts/generate_evidence.cjs gathered-artifacts
+      - name: Validate evidence pointers
+        run: |
+          node scripts/validate_claims.cjs gathered-artifacts/evidence.json
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f710ba29..c66323c7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,90 @@
 
 ## Unreleased
 
+## [0.1.3] — 2026-02-21
+
+### Fixed (Sprint S1)
+
+- **CI Security:** Hardened `det-gates` workflow against script injection by using
+  environment variables for all `github.*` interpolations (branch refs, SHA,
+  run ID, event name).
+- **WASM Reproducibility:** Implemented bit-exact reproducibility checks (G4)
+  for `ttd-browser` WASM using hash comparison of clean isolated rebuilds.
+- **Static Inspection:** Added automated CI guard for `DET-001` covering all 14
+  DET_CRITICAL crate paths (expanded from `echo-wasm-abi` only). Report now
+  conditional on check outcome (PASSED/FAILED).
+- **Evidence Validation:** Made artifact presence checks in `validate-evidence`
+  conditional on classification tier; added `det-macos-artifacts` check;
+  `run_reduced` and `DET_NONCRITICAL` paths no longer hard-fail.
+- **Policy Classification:** Promoted `warp-benches` from DET_NONCRITICAL to
+  DET_IMPORTANT so benchmark crate changes trigger reduced gates.
+- **Benchmark Correctness:** Replaced `let _ =` with `.unwrap()` on all
+  `bus.emit()` calls; migrated `iter_with_setup` to `iter_batched`.
+- **CBOR Robustness:** Expanded negative security tests for `ProjectionKind`
+  and `LabelAnchor` enum tags and optimized `MAX_OPS` boundary check.
+- **Evidence Integrity:** Enhanced `generate_evidence.cjs` and `validate_claims.cjs`
+  with stricter semantic validation (SHAs, run IDs) and artifact existence checks.
+- **Script Quality:** Replaced `process.exit(1)` with `throw` in
+  `classify_changes.cjs`; removed dead import; exported functions for testing.
+- **Governance:** Moved `sec-claim-map.json` to `docs/determinism/`, formalized
+  gate states in `RELEASE_POLICY.md`, tightened claim statements in
+  `CLAIM_MAP.yaml`.
+- **CI Permissions:** Added `permissions: contents: read` to `det-gates.yml`
+  for least-privilege workflow execution.
+- **CI Robustness:** Made ripgrep install idempotent; gated `validate-evidence`
+  on `classify-changes` success; invoked CJS scripts via `node` for
+  cross-platform portability.
+- **Evidence Validation:** Relaxed `commit_sha` check to accept `local` sentinel
+  for local development; exported `generateEvidence` and `validateClaims`
+  functions for unit testing (#286).
+- **Claims Precision:** Sharpened `PRF-001` statement to reference specific
+  Criterion benchmark rather than generic threshold language.
+- **Backlog:** Added five `TASKS-DAG.md` items: BLD-001 claim gap, macOS parity
+  claim, CI concurrency controls, expanded script test coverage, and
+  `det-policy.yaml` path simplification.
+- **Evidence Completeness:** Added `REPRO-001` claim for G4 build reproducibility
+  to `CLAIM_MAP.yaml` and wired into `generate_evidence.cjs`.
+- **Script Hardening:** Added `Array.isArray` guard for `required_gates` in
+  `validate_det_policy.cjs`; used explicit null/undefined check in
+  `validate_claims.cjs` instead of falsy coercion.
+- **Test Robustness:** Encoded all 5 CBOR fields in `reject_invalid_version`
+  to prevent false passes from decoder field-read reordering.
+- **Docs:** Added G3 staging-optional rationale in `RELEASE_POLICY.md`;
+  merge-commit revert guidance and evidence packet filing in `ROLLBACK_TTD.md`;
+  documented `tests/**`/`e2e/**` classification rationale in `det-policy.yaml`.
+- **Gate Coverage:** Made G3 (perf-regression) run for all non-`run_none` paths,
+  not just `run_full`. Ensures PRF-001 claim fires for DET_IMPORTANT changes
+  (e.g., `warp-benches`). Moved `perf-artifacts` presence check to always-required.
+- **Classification Precision:** Carved `tests/dind*` and `testdata/dind/**` out
+  of the DET_NONCRITICAL `docs` catch-all into a dedicated `dind-tests-root`
+  entry at DET_IMPORTANT, preventing gate evasion for DIND test modifications.
+
+## [0.1.2] — 2026-02-14
+
+### Added — TTD Hardening Sprint S1 (Gates & Evidence)
+
+- **Path-Aware CI Gates:** Implemented `det-policy.yaml` and `classify_changes.cjs`
+  to classify workspace crates (DET_CRITICAL/IMPORTANT/NONCRITICAL) and drive
+  selective CI gate triggering (G1-G4).
+- **Hardening Gates (G1-G4):**
+    - **G1 (Determinism):** Integrated float parity tests and the DIND (Deterministic
+      Ironclad Nightmare Drills) suite on both Linux and macOS.
+    - **G2 (Security):** Added negative security tests for the CBOR decoder
+      (MAX_OPS, invalid versions/enums, truncated payloads).
+    - **G3 (Performance):** Created `materialization_hotpath` Criterion benchmark
+      in `warp-benches` to track materialization overhead.
+    - **G4 (Build):** Added WASM build reproducibility checks verifying bit-exact
+      artifacts across clean rebuilds.
+- **Evidence Integrity:** Added `generate_evidence.cjs` and `validate_claims.cjs`
+  to ensure all `VERIFIED` claims are backed by immutable CI artifacts (run IDs,
+  commit SHAs).
+- **Static Inspection:** Integrated `DET-001` automated static inspection into CI
+  to verify zero-HashMap usage in deterministic guest paths.
+- **Governance:** Published `RELEASE_POLICY.md` (staging/prod blockers) and
+  `ROLLBACK_TTD.md` (commit-ordered rollback sequences).
+- **Security Claim Mapping:** Exported `sec-claim-map.json` mapping decoder
+  controls to explicit negative test cases.
+
 ### Added — Deterministic Scene Data (TTD)
 
 - **Scene Rendering Port (`echo-scene-port`):** Defined the core data model for
diff --git a/ECHO_ROADMAP.md b/ECHO_ROADMAP.md
index 2c9736a0..f980532b 100644
--- a/ECHO_ROADMAP.md
+++ b/ECHO_ROADMAP.md
@@ -1,8 +1,22 @@
 <!-- SPDX-License-Identifier: Apache-2.0 OR MIND-UCAL-1.0 -->
 <!-- © James Ross Ω FLYING•ROBOTS <https://github.com/flyingrobots> -->
+
 # ECHO_ROADMAP — Phased Plan (Post-ADR Alignment)
 
+## Completed Sprint: TTD-HARDENING-S1 (2026-02-14 to 2026-02-15)
+
+**Goal:** Formalize the TTD (Time-Travel Determinism) hardening gates and evidence integrity.
+
+- [x] **G1 (DET):** Multi-platform determinism matrix (macOS/Linux + wasm).
+- [x] **G2 (SEC):** Explicit negative test mapping for decoder controls.
+- [x] **G3 (PRF):** Criterion baseline + regression threshold for materialization path.
+- [x] **G4 (REP):** Enforce artifact-backed VERIFIED claims and path-aware gates.
+- [x] **GOV:** Publish release policy and commit-ordered rollback playbooks.
+
+---
+
 This roadmap re-syncs active work with recent ADRs:
+
 - ADR-0003: Causality-first API + MaterializationBus/Port
 - ADR-0004: No global state / explicit dependency injection
 - ADR-0005: Physics as deterministic scheduled rewrites
@@ -13,98 +27,111 @@ It also incorporates the latest DIND status from `GEMINI_CONTINUE_NOTES.md`.
 ---
 
 ## Phase 0 — Repo Hygiene & Ownership
+
 Goal: eliminate structural drift and restore correct ownership boundaries.
 
 - Move `crates/echo-dind-harness/` to the Echo repo (submodule) where it belongs.
-  - Remove the crate from this workspace once moved.
-  - Ensure any references/scripts in this repo point to the Echo submodule path.
+    - Remove the crate from this workspace once moved.
+    - Ensure any references/scripts in this repo point to the Echo submodule path.
 - Audit for other Echo-owned crates/docs accidentally mirrored here.
 - Update docs to reflect the correct location of DIND tooling.
 
 Exit criteria:
+
 - `crates/echo-dind-harness/` no longer exists in this repo.
 - A clear pointer exists for where to run DIND locally (Echo repo).
 
 ---
 
 ## Phase 1 — Determinism Guardrails (ADR-0004 + ADR-0006)
+
 Goal: codify the “no global state / no nondeterminism” doctrine and enforce it in CI.
 
 - Add CI scripts:
-  - `scripts/ban-globals.sh` (ADR-0004)
-  - `scripts/ban-nondeterminism.sh` and `scripts/ban-unordered-abi.sh` (ADR-0006)
+    - `scripts/ban-globals.sh` (ADR-0004)
+    - `scripts/ban-nondeterminism.sh` and `scripts/ban-unordered-abi.sh` (ADR-0006)
 - Wire scripts into CI for core crates (warp-core, warp-wasm, app wasm).
 - Add minimal allowlist files (empty by default).
 - Document determinism rules in README / doctrine doc.
 
 Exit criteria:
+
 - CI fails on banned patterns.
 - No global init (`install_*` style) in runtime core.
 
 ---
 
 ## Phase 2 — Causality-First Boundary (ADR-0003)
+
 Goal: enforce ingress-only writes and bus-first reads.
 
 - Define/confirm canonical intent envelopes for ingress (bytes-only).
 - Ensure all write paths use ingress; remove any public “direct mutation” APIs.
 - Implement MaterializationBus + MaterializationPort boundary:
-  - `view_subscribe`, `view_drain`, `view_replay_last`, `view_unsubscribe`
-  - channel IDs are byte-based (TypeId-derived), no strings in ABI
+    - `view_subscribe`, `view_drain`, `view_replay_last`, `view_unsubscribe`
+    - channel IDs are byte-based (TypeId-derived), no strings in ABI
 - Ensure UI uses materializations rather than direct state reads (except inspector).
 - Define InspectorPort as a gated, separate API (optional).
 
 Exit criteria:
+
 - No direct mutation path exposed to tools/UI.
 - UI can run solely on materialized channels (or has a plan to get there).
 
 ---
 
 ## Phase 3 — Physics Pipeline (ADR-0005)
+
 Goal: implement deterministic physics as scheduled rewrites.
 
 - Implement tick phases:
-  1) Integrate (predict)
-  2) Candidate generation (broadphase + narrowphase)
-  3) Solver iterations with footprint scheduling
-  4) Finalize (commit)
+    1. Integrate (predict)
+    2. Candidate generation (broadphase + narrowphase)
+    3. Solver iterations with footprint scheduling
+    4. Finalize (commit)
 - Canonical ordering:
-  - candidate keys: `(toi_q, min_id, max_id, feature_id)`
-  - deterministic iteration order for bodies and contacts
+    - candidate keys: `(toi_q, min_id, max_id, feature_id)`
+    - deterministic iteration order for bodies and contacts
 - Add optional trace channels for physics (debug materializations).
 - Ensure physics outputs only emit post-commit.
 
 Exit criteria:
+
 - Physics determinism across wasm/native with fixed seeds and inputs.
 - No queue-based “micro-inbox” for derived physics work.
 
 ---
 
 ## Phase 4 — DIND Mission Continuation (from GEMINI_CONTINUE_NOTES)
+
 Goal: complete Mission 3 polish and Mission 4 performance envelope.
 
 ### Mission 3 (Polish / Verification)
+
 - Badge scoping: clarify scope (“PR set”) and platforms.
 - Badge truth source: generate from CI artifacts only.
 - Matrix audit: confirm explicit aarch64 coverage needs.
 
 ### Mission 4 (Performance Envelope)
+
 - Add `perf` command to DIND harness:
-  - `perf <scenario> --baseline <file> --tolerance 15%`
-  - track `time_ms`, `steps`, `time_per_step`
-  - optional: max nodes/edges, allocations
+    - `perf <scenario> --baseline <file> --tolerance 15%`
+    - track `time_ms`, `steps`, `time_per_step`
+    - optional: max nodes/edges, allocations
 - Add baseline: `testdata/dind/perf_baseline.json`
 - CI:
-  - PR: core scenarios, release build, fail on >15% regression
-  - Nightly: full suite, upload perf artifacts
+    - PR: core scenarios, release build, fail on >15% regression
+    - Nightly: full suite, upload perf artifacts
 
 Exit criteria:
+
 - DIND perf regressions fail CI.
 - Stable baseline file committed.
 
 ---
 
 ## Phase 5 — App-Repo Integration (flyingrobots.dev specific)
+
 Goal: keep app-specific wasm boundary clean and deterministic.
 
 - Ensure TS encoders are the source of truth for binary protocol.
@@ -113,12 +140,14 @@ Goal: keep app-specific wasm boundary clean and deterministic.
 - Add or update tests verifying canonical ordering and envelope bytes.
 
 Exit criteria:
+
 - ABI tests use TS encoders, not wasm placeholder exports.
 - wasm build + vitest pass.
 
 ---
 
 ## Open Questions / Dependencies
+
 - Precise target crates for determinism guardrails in this repo vs Echo repo.
 - Whether InspectorPort needs to exist in flyingrobots.dev or only in Echo.
 - Final home for DIND artifacts: Echo repo or shared tooling repo.
@@ -126,9 +155,10 @@ Exit criteria:
 ---
 
 ## Suggested Execution Order
-1) Phase 0 (move DIND harness) to prevent ownership drift.
-2) Phase 1 guardrails to lock determinism.
-3) Phase 2 boundary enforcement (ingress + bus).
-4) Phase 3 physics pipeline.
-5) Phase 4 DIND polish/perf.
-6) Phase 5 app integration clean-up.
+
+1. Phase 0 (move DIND harness) to prevent ownership drift.
+2. Phase 1 guardrails to lock determinism.
+3. Phase 2 boundary enforcement (ingress + bus).
+4. Phase 3 physics pipeline.
+5. Phase 4 DIND polish/perf.
+6. Phase 5 app integration clean-up.
diff --git a/TASKS-DAG.md b/TASKS-DAG.md
index f78be64d..7ab2bbb7 100644
--- a/TASKS-DAG.md
+++ b/TASKS-DAG.md
@@ -654,6 +654,58 @@ This living list documents open issues and the inferred dependencies contributor
 - Status: Open
 - (No detected dependencies)
 
+## [#284: CI: Per-crate gate overrides in det-policy classification system](https://github.com/flyingrobots/echo/issues/284)
+
+- Status: Open
+- (No detected dependencies)
+
+## [#285: CI: Auto-generate DETERMINISM_PATHS from det-policy.yaml DET_CRITICAL entries](https://github.com/flyingrobots/echo/issues/285)
+
+- Status: Open
+- (No detected dependencies)
+
+## [#286: CI: Add unit tests for classify_changes.cjs and matches()](https://github.com/flyingrobots/echo/issues/286)
+
+- Status: Open
+- (No detected dependencies)
+
+## [#287: Docs: Document ban-nondeterminism.sh allowlist process in RELEASE_POLICY.md](https://github.com/flyingrobots/echo/issues/287)
+
+- Status: Open
+- (No detected dependencies)
+
+## Backlog: Add BLD-001 claim for G4 build reproducibility
+
+- Status: Open
+- Evidence: `generate_evidence.cjs` has no claim entry for G4. `CLAIM_MAP.yaml` has no BLD-001 declaration. The `build-repro` job runs and `validate-evidence` checks artifact presence, but no VERIFIED/UNVERIFIED status is emitted into the evidence pack. The release policy blocker matrix references G4 but the evidence chain cannot enforce it.
+- (No detected dependencies)
+
+## Backlog: Add macOS parity claim (DET-002 is Linux-only)
+
+- Status: Open
+- Evidence: `generate_evidence.cjs:33` maps DET-002 solely to `det-linux-artifacts`. The `det-macos-artifacts` are gathered and presence-validated, but no claim captures macOS parity results. A macOS-specific divergence would go undetected by the evidence system.
+- (No detected dependencies)
+
+## Backlog: Add concurrency controls to det-gates.yml
+
+- Status: Open
+- Evidence: `det-gates.yml` has no `concurrency:` block. Multiple runs for the same PR can pile up, burning CI minutes. Standard fix: `concurrency: { group: det-gates-${{ github.head_ref || github.ref }}, cancel-in-progress: true }`.
+- (No detected dependencies)
+
+## Backlog: Expand #286 scope to cover validate_claims.cjs and generate_evidence.cjs
+
+- Status: Open
+- Blocked by:
+    - [#286: CI: Add unit tests for classify_changes.cjs and matches()](https://github.com/flyingrobots/echo/issues/286)
+    - Confidence: medium
+    - Evidence: Both scripts now export their main functions (M1/M2 in det-hard). Edge cases to cover: 'local' sentinel, missing artifacts, malformed evidence JSON.
+
+## Backlog: Simplify docs crate path list in det-policy.yaml
+
+- Status: Open
+- Evidence: The `docs` entry in `det-policy.yaml` mixes directory globs with 20+ individual top-level filenames. Growing unwieldy; any new top-level file that doesn't match an existing crate pattern triggers `require_full_classification` failure. Consider a glob simplification or a catch-all mechanism.
+- (No detected dependencies)
+
 ---
 
 Rendering note (2026-01-09):
diff --git a/crates/echo-scene-codec/src/cbor.rs b/crates/echo-scene-codec/src/cbor.rs
index 43682045..38257fb5 100644
--- a/crates/echo-scene-codec/src/cbor.rs
+++ b/crates/echo-scene-codec/src/cbor.rs
@@ -983,6 +983,72 @@ mod tests {
         );
     }
 
+    #[test]
+    fn reject_exceeding_max_ops() {
+        // Minimal CBOR header for SceneDelta
+        let mut buf = Vec::new();
+        let mut encoder = Encoder::new(&mut buf);
+        encoder.array(5).unwrap();
+        encoder.u8(1).unwrap(); // Version
+        encoder.bytes(&make_test_hash(1)).unwrap(); // session
+        encoder.bytes(&make_test_hash(2)).unwrap(); // cursor
+        encoder.u64(0).unwrap(); // epoch
+        encoder.array((MAX_OPS + 1) as u64).unwrap(); // ops array header
+
+        let result = decode_scene_delta(&buf);
+        assert!(
+            result.is_err(),
+            "Decoder should reject ops count exceeding MAX_OPS"
+        );
+        let err = result.err().unwrap().to_string();
+        assert!(err.contains("exceeds MAX_OPS"));
+    }
+
+    #[test]
+    fn reject_invalid_version() {
+        let mut buf = Vec::new();
+        let mut encoder = Encoder::new(&mut buf);
+        encoder.array(5).unwrap();
+        encoder.u8(99).unwrap(); // Unsupported version
+        encoder.bytes(&make_test_hash(1)).unwrap(); // session
+        encoder.bytes(&make_test_hash(2)).unwrap(); // cursor
+        encoder.u64(0).unwrap(); // epoch
+        encoder.array(0).unwrap(); // empty ops
+
+        let result = decode_scene_delta(&buf);
+        assert!(result.is_err());
+        assert!(result.err().unwrap().to_string().contains("version"));
+    }
+
+    #[test]
+    fn reject_invalid_enum_tags() {
+        let mut buf = Vec::new();
+
+        // NodeShape: allowed 0..=1
+        let mut encoder = Encoder::new(&mut buf);
+        encoder.u8(2).unwrap();
+        assert!(decode_node_shape(&mut Decoder::new(&buf)).is_err());
+
+        // EdgeStyle: allowed 0..=1
+        buf.clear();
+        let mut encoder = Encoder::new(&mut buf);
+        encoder.u8(2).unwrap();
+        assert!(decode_edge_style(&mut Decoder::new(&buf)).is_err());
+
+        // ProjectionKind: allowed 0..=1
+        buf.clear();
+        let mut encoder = Encoder::new(&mut buf);
+        encoder.u8(2).unwrap();
+        assert!(decode_projection_kind(&mut Decoder::new(&buf)).is_err());
+
+        // LabelAnchor tag: allowed 0..=1
+        buf.clear();
+        let mut encoder = Encoder::new(&mut buf);
+        encoder.array(2).unwrap();
+        encoder.u8(2).unwrap(); // Invalid tag
+        assert!(decode_label_anchor(&mut Decoder::new(&buf)).is_err());
+    }
+
     #[test]
     fn drill_truncated_cbor() {
         let delta = SceneDelta {
diff --git a/crates/warp-benches/Cargo.toml b/crates/warp-benches/Cargo.toml
index f7e1a620..32f84f85 100644
--- a/crates/warp-benches/Cargo.toml
+++ b/crates/warp-benches/Cargo.toml
@@ -42,3 +42,7 @@ harness = false
 [[bench]]
 name = "boaw_baseline"
 harness = false
+
+[[bench]]
+name = "materialization_hotpath"
+harness = false
diff --git a/crates/warp-benches/benches/materialization_hotpath.rs b/crates/warp-benches/benches/materialization_hotpath.rs
new file mode 100644
index 00000000..82d6fd20
--- /dev/null
+++ b/crates/warp-benches/benches/materialization_hotpath.rs
@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: Apache-2.0
+// © James Ross Ω FLYING•ROBOTS <https://github.com/flyingrobots>
+// criterion_group!/criterion_main! expand to undocumented functions that cannot
+// carry #[allow] (attributes on macro invocations are ignored). Crate-level
+// suppress is required for benchmark binaries using Criterion.
+#![allow(missing_docs)]
+//! Microbenchmarks for `MaterializationBus` performance.
+use criterion::{black_box, criterion_group, criterion_main, BatchSize, Criterion};
+use warp_core::materialization::{make_channel_id, ChannelPolicy, EmitKey, MaterializationBus};
+use warp_core::Hash;
+
+/// Helper to create a deterministic hash from a u64.
+fn h(n: u64) -> Hash {
+    let mut bytes = [0u8; 32];
+    bytes[24..32].copy_from_slice(&n.to_be_bytes());
+    bytes
+}
+
+/// Benchmark emitting 1000 items to a single `Log` channel.
+/// Note: `payload.clone()` is intentional — measures realistic end-to-end cost
+/// including payload ownership transfer (64-byte Vec allocation per emit).
+fn bench_materialization_emit_log(c: &mut Criterion) {
+    let bus = MaterializationBus::new();
+    let ch = make_channel_id("bench:log");
+    let payloads: Vec<Vec<u8>> = (0..1000).map(|_| vec![0u8; 64]).collect();
+
+    c.bench_function("materialization_emit_log_1000", |b| {
+        b.iter(|| {
+            for (i, p) in payloads.iter().enumerate() {
+                bus.emit(
+                    black_box(ch),
+                    black_box(EmitKey::new(h(i as u64), 1)),
+                    black_box(p.clone()),
+                )
+                .unwrap();
+            }
+            bus.clear();
+        })
+    });
+}
+
+/// Benchmark finalizing a single `Log` channel with 1000 items.
+fn bench_materialization_finalize_log(c: &mut Criterion) {
+    let bus = MaterializationBus::new();
+    let ch = make_channel_id("bench:log");
+    let payloads: Vec<Vec<u8>> = (0..1000).map(|_| vec![0u8; 64]).collect();
+
+    c.bench_function("materialization_finalize_log_1000", |b| {
+        b.iter_batched(
+            || {
+                for (i, p) in payloads.iter().enumerate() {
+                    bus.emit(ch, EmitKey::new(h(i as u64), 1), p.clone())
+                        .unwrap();
+                }
+            },
+            |_| {
+                let _ = black_box(bus.finalize());
+            },
+            BatchSize::PerIteration,
+        )
+    });
+}
+
+/// Benchmark emitting 1000 items across 1000 distinct `StrictSingle` channels.
+fn bench_materialization_emit_strict_many(c: &mut Criterion) {
+    let mut bus = MaterializationBus::new();
+    let channels: Vec<_> = (0..1000)
+        .map(|i| {
+            let ch = make_channel_id(&format!("bench:strict:{}", i));
+            bus.register_channel(ch, ChannelPolicy::StrictSingle);
+            ch
+        })
+        .collect();
+    let payloads: Vec<Vec<u8>> = (0..1000).map(|_| vec![0u8; 64]).collect();
+
+    c.bench_function("materialization_emit_strict_1000", |b| {
+        b.iter(|| {
+            for (i, ch) in channels.iter().enumerate() {
+                bus.emit(
+                    black_box(*ch),
+                    black_box(EmitKey::new(h(0), 1)),
+                    black_box(payloads[i].clone()),
+                )
+                .unwrap();
+            }
+            bus.clear();
+        })
+    });
+}
+
+/// Benchmark finalizing 1000 `StrictSingle` channels.
+fn bench_materialization_finalize_strict_many(c: &mut Criterion) {
+    let mut bus = MaterializationBus::new();
+    let channels: Vec<_> = (0..1000)
+        .map(|i| {
+            let ch = make_channel_id(&format!("bench:strict:{}", i));
+            bus.register_channel(ch, ChannelPolicy::StrictSingle);
+            ch
+        })
+        .collect();
+    let payloads: Vec<Vec<u8>> = (0..1000).map(|_| vec![0u8; 64]).collect();
+
+    c.bench_function("materialization_finalize_strict_1000", |b| {
+        b.iter_batched(
+            || {
+                for (i, ch) in channels.iter().enumerate() {
+                    bus.emit(*ch, EmitKey::new(h(0), 1), payloads[i].clone())
+                        .unwrap();
+                }
+            },
+            |_| {
+                let _ = black_box(bus.finalize());
+            },
+            BatchSize::PerIteration,
+        )
+    });
+}
+
+criterion_group!(
+    benches,
+    bench_materialization_emit_log,
+    bench_materialization_finalize_log,
+    bench_materialization_emit_strict_many,
+    bench_materialization_finalize_strict_many
+);
+criterion_main!(benches);
diff --git a/det-policy.yaml b/det-policy.yaml
new file mode 100644
index 00000000..a193fdf5
--- /dev/null
+++ b/det-policy.yaml
@@ -0,0 +1,170 @@
+# SPDX-License-Identifier: Apache-2.0
+# © James Ross Ω FLYING•ROBOTS <https://github.com/flyingrobots>
+version: 1
+
+# Crate classification drives path-aware CI gates
+classes:
+  DET_CRITICAL:
+    description: "Determinism/security/replay-critical. Full gates required."
+    required_gates: [G1, G2, G3, G4]
+  DET_IMPORTANT:
+    description: "Affects critical systems indirectly. Reduced gate set."
+    required_gates: [G2, G4]
+  DET_NONCRITICAL:
+    description: "No deterministic runtime impact. Standard CI only."
+    required_gates: []
+
+# One entry per workspace crate/package
+crates:
+  # ---- DET_CRITICAL ----
+  warp-core:
+    class: DET_CRITICAL
+    owner_role: "Architect"
+    paths: ["crates/warp-core/**"]
+  warp-geom:
+    class: DET_CRITICAL
+    owner_role: "Architect"
+    paths: ["crates/warp-geom/**"]
+  warp-wasm:
+    class: DET_CRITICAL
+    owner_role: "Architect"
+    paths: ["crates/warp-wasm/**"]
+  warp-ffi:
+    class: DET_CRITICAL
+    owner_role: "Architect"
+    paths: ["crates/warp-ffi/**"]
+  echo-wasm-abi:
+    class: DET_CRITICAL
+    owner_role: "Architect"
+    paths: ["crates/echo-wasm-abi/**"]
+  echo-scene-port:
+    class: DET_CRITICAL
+    owner_role: "Architect"
+    paths: ["crates/echo-scene-port/**"]
+  echo-scene-codec:
+    class: DET_CRITICAL
+    owner_role: "Security Engineer"
+    paths: ["crates/echo-scene-codec/**"]
+  echo-graph:
+    class: DET_CRITICAL
+    owner_role: "Architect"
+    paths: ["crates/echo-graph/**"]
+  echo-ttd:
+    class: DET_CRITICAL
+    owner_role: "Architect"
+    paths: ["crates/echo-ttd/**"]
+  echo-dind-harness:
+    class: DET_CRITICAL
+    owner_role: "CI Engineer"
+    paths: ["crates/echo-dind-harness/**"]
+  echo-dind-tests:
+    class: DET_CRITICAL
+    owner_role: "CI Engineer"
+    paths: ["crates/echo-dind-tests/**"]
+  ttd-browser:
+    class: DET_CRITICAL
+    owner_role: "Architect"
+    paths: ["crates/ttd-browser/**"]
+  ttd-protocol-rs:
+    class: DET_CRITICAL
+    owner_role: "Architect"
+    paths: ["crates/ttd-protocol-rs/**"]
+  ttd-manifest:
+    class: DET_CRITICAL
+    owner_role: "Architect"
+    paths: ["crates/ttd-manifest/**"]
+  ci:
+    class: DET_CRITICAL
+    owner_role: "CI Engineer"
+    paths: [".github/workflows/**", "scripts/**", "det-policy.yaml", "Makefile", "xtask/**"]
+
+  # ---- DET_IMPORTANT ----
+  build-system:
+    class: DET_IMPORTANT
+    owner_role: "Architect"
+    paths: ["Cargo.toml", "Cargo.lock", "rust-toolchain.toml", "package.json", "pnpm-lock.yaml", "pnpm-workspace.yaml", "deny.toml", "audit.toml"]
+  echo-wasm-bindings:
+    class: DET_IMPORTANT
+    owner_role: "Tooling Engineer"
+    paths: ["crates/echo-wasm-bindings/**"]
+  echo-wesley-gen:
+    class: DET_IMPORTANT
+    owner_role: "Tooling Engineer"
+    paths: ["crates/echo-wesley-gen/**"]
+  echo-app-core:
+    class: DET_IMPORTANT
+    owner_role: "Architect"
+    paths: ["crates/echo-app-core/**"]
+  echo-cas:
+    class: DET_IMPORTANT
+    owner_role: "Architect"
+    paths: ["crates/echo-cas/**"]
+  echo-config-fs:
+    class: DET_IMPORTANT
+    owner_role: "Architect"
+    paths: ["crates/echo-config-fs/**"]
+  echo-registry-api:
+    class: DET_IMPORTANT
+    owner_role: "Architect"
+    paths: ["crates/echo-registry-api/**"]
+  echo-session-client:
+    class: DET_IMPORTANT
+    owner_role: "Architect"
+    paths: ["crates/echo-session-client/**"]
+  echo-session-proto:
+    class: DET_IMPORTANT
+    owner_role: "Architect"
+    paths: ["crates/echo-session-proto/**"]
+  echo-session-service:
+    class: DET_IMPORTANT
+    owner_role: "Architect"
+    paths: ["crates/echo-session-service/**"]
+  echo-session-ws-gateway:
+    class: DET_IMPORTANT
+    owner_role: "Architect"
+    paths: ["crates/echo-session-ws-gateway/**"]
+  warp-cli:
+    class: DET_IMPORTANT
+    owner_role: "Architect"
+    paths: ["crates/warp-cli/**"]
+  warp-viewer:
+    class: DET_IMPORTANT
+    owner_role: "Architect"
+    paths: ["crates/warp-viewer/**"]
+  warp-benches:
+    class: DET_IMPORTANT
+    owner_role: "Performance Engineer"
+    paths: ["crates/warp-benches/**"]
+
+  dind-tests-root:
+    class: DET_IMPORTANT
+    owner_role: "CI Engineer"
+    paths: ["tests/dind*", "tests/hooks/**", "testdata/dind/**"]
+
+  # ---- DET_NONCRITICAL ----
+  # Note: remaining tests/** and e2e/** are repo-root integration/E2E tests
+  # (Playwright), not determinism tests. DIND tests are classified above.
+  # Crate-level tests are classified with their parent crate.
+  ttd-app:
+    class: DET_NONCRITICAL
+    owner_role: "Frontend Engineer"
+    paths: ["apps/ttd-app/**", "playwright.config.ts"]
+  docs:
+    class: DET_NONCRITICAL
+    owner_role: "Tech Writer"
+    paths: ["docs/**", "README.md", "CHANGELOG.md", "LEGAL.md", "LICENSE*", "NOTICE", "SECURITY.md", "AGENTS.md", "COMING_SOON.md", "CONTRIBUTING.md", "ECHO_ROADMAP.md", ".editorconfig", ".gitignore", ".gitattributes", ".markdownlint.json", "ADR-*.md", "TASKS-DAG.md", "WASM-TASKS.md", ".ban-*", "DIND-MISSION*.md", "DETERMINISM-AUDIT.md", "MERGE_TTD_BRANCH_PLAN.md", "testdata/**", "tests/**", "e2e/**"]
+  echo-dry-tests:
+    class: DET_NONCRITICAL
+    owner_role: "CI Engineer"
+    paths: ["crates/echo-dry-tests/**"]
+
+policy:
+  require_full_classification: true
+  require_owners_for_critical: true
+  deterministic_guardrails:
+    enabled: true
+    # Documentation-only; enforcement is in scripts/ban-nondeterminism.sh
+    deny_patterns:
+      - "HashMap"
+      - "HashSet"
+    allowlist_files: []
diff --git a/docs/RELEASE_POLICY.md b/docs/RELEASE_POLICY.md
new file mode 100644
index 00000000..b36f8e86
--- /dev/null
+++ b/docs/RELEASE_POLICY.md
@@ -0,0 +1,78 @@
+<!-- SPDX-License-Identifier: Apache-2.0 OR MIND-UCAL-1.0 -->
+<!-- © James Ross Ω FLYING•ROBOTS <https://github.com/flyingrobots> -->
+
+# Release Policy — TTD / Determinism Program
+
+## Version
+
+- Policy Version: 1.1
+- Effective Date: 2026-02-15
+
+## Gate Definitions
+
+- **G1 Determinism**
+    - Cross-platform parity for deterministic corpus (macOS + Linux; wasm checks as applicable).
+    - Evidence: digest comparison artifact with run IDs and commit SHA.
+
+- **G2 Decoder Security**
+    - Negative tests prove rejection/handling of malformed payload classes.
+    - Evidence: mapped test IDs + CI artifact output.
+
+- **G3 Performance Regression Bound**
+    - Benchmark delta for DET-critical hot paths within accepted threshold.
+    - Evidence: baseline vs current perf artifact.
+
+- **G4 Build Reproducibility**
+    - Reproducible deterministic build constraints validated in CI.
+    - Evidence: build artifact metadata and checksums.
+
+## Blocker Matrix
+
+The blocker matrix for release decisions:
+
+```yaml
+release_policy:
+    staging_blockers: [G1, G2, G4]
+    production_blockers: [G1, G2, G3, G4]
+    # G3 is intentionally staging-optional: perf regressions are caught
+    # before production but do not block functional validation in staging.
+```
+
+## Recommendation Rules
+
+- **GO**: all required blockers are VERIFIED.
+- **CONDITIONAL**: one or more required blockers are UNVERIFIED/INFERRED with approved closeout plan.
+- **NO-GO**: required blocker FAILED or unresolved with no approved mitigation.
+
+## Gate States
+
+- **VERIFIED**: Evidence exists in the form of immutable CI artifacts (run ID, commit SHA) proving the gate pass.
+- **INFERRED**: High confidence that the gate passes based on circumstantial evidence (e.g., downstream tests pass), but direct artifact-backed proof is pending.
+- **UNVERIFIED**: No supporting evidence currently exists.
+
+## Closeout Plan
+
+An **Approved Closeout Plan** is required for any CONDITIONAL release.
+
+- **Definition**: A documented set of tasks, owners, and ETAs to move a gate from UNVERIFIED/INFERRED to VERIFIED.
+- **Approval Authority**: Must be approved by the **Architect** or **Security Engineer** role as defined in `det-policy.yaml` for the affected crate.
+
+## Evidence Rules
+
+A gate may be marked VERIFIED only with immutable pointers:
+
+- workflow/job name
+- run ID
+- commit SHA
+- artifact filename
+- checksum (where relevant)
+
+No immutable evidence => gate must be INFERRED or UNVERIFIED.
+
+## Escalation
+
+If staging/prod blocker state conflicts with recommendation:
+
+1. Freeze recommendation to CONDITIONAL.
+2. Open blocker issues with owners and ETA.
+3. Re-run gate suite before release decision.
diff --git a/docs/ROLLBACK_TTD.md b/docs/ROLLBACK_TTD.md
new file mode 100644
index 00000000..497d0668
--- /dev/null
+++ b/docs/ROLLBACK_TTD.md
@@ -0,0 +1,88 @@
+<!-- SPDX-License-Identifier: Apache-2.0 OR MIND-UCAL-1.0 -->
+<!-- © James Ross Ω FLYING•ROBOTS <https://github.com/flyingrobots> -->
+
+# Rollback Playbook — TTD Integration
+
+## Scope
+
+> **Note:** Commit SHAs below are pinned to the original TTD integration merge window. Verify against `git log` before executing any rollback.
+
+Rollback coverage for commit range:
+
+- Base: `efae3e8`
+- Head: `e201c9b`
+
+## Preconditions
+
+- Release owner approval logged.
+- Current branch state saved/tagged.
+- Incident ticket created.
+
+## Scenario A — Full TTD Rollback
+
+### Objective (Scenario A)
+
+Return repository to pre-TTD integration state.
+
+### Ordered actions
+
+1. Create rollback branch:
+    - `rollback/ttd-full-<date>`
+2. Revert commits in reverse order from head to base+1:
+    - `e201c9b`
+    - `fd98b91`
+    - `ce98d80`
+    - `a02ea86`
+    - `3187e6a`
+    - `6e34a77`
+    - `f138b8a`
+        > **Merge commits:** If any listed commit is a merge, use `git revert -m 1 <sha>` to select the first parent as the mainline.
+3. Resolve conflicts preserving pre-TTD behavior.
+
+### Validation Checklist (Scenario A)
+
+- [ ] `cargo check --workspace` passes
+- [ ] Determinism suite for non-TTD core passes
+- [ ] Build pipelines pass
+- [ ] Smoke test core runtime flows pass
+
+---
+
+## Scenario B — Partial Rollback (FFI/UI layer)
+
+### Objective (Scenario B)
+
+Remove unstable FFI/UI integration while preserving core hardening.
+
+### Candidate revert target(s)
+
+- `fd98b91` (UI/WASM Integration)
+- `ce98d80` (Frontend Restoration)
+- optionally `a02ea86` if FFI safety layer must be reverted together
+
+### Dependency constraints
+
+- Reverting `a02ea86` may break consumers expecting SessionToken/FFI contracts.
+- Validate dependent crates/apps after each revert step.
+
+### Validation Checklist (Scenario B)
+
+- [ ] `apps/ttd-app` build status known (pass/fail expected documented)
+- [ ] Core codec/scene crates compile and tests pass
+- [ ] CI gate summary attached to incident
+
+---
+
+## Post-Rollback Evidence Packet (required)
+
+- commit SHAs reverted
+- CI run IDs
+- failing/passing gate delta (before vs after)
+- residual risk summary
+- recommendation: GO / CONDITIONAL / NO-GO
+
+### Filing
+
+- Attach the evidence packet to the incident ticket.
+- Link the packet in the rollback PR description.
+- Name the artifact `incident-<ID>-post-rollback-evidence`.
diff --git a/docs/determinism/CLAIM_MAP.yaml b/docs/determinism/CLAIM_MAP.yaml
new file mode 100644
index 00000000..3f684ac7
--- /dev/null
+++ b/docs/determinism/CLAIM_MAP.yaml
@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: Apache-2.0
+# © James Ross Ω FLYING•ROBOTS <https://github.com/flyingrobots>
+version: 1
+claims:
+  DET-001:
+    statement: "DET_CRITICAL crate paths contain zero matches for the banned pattern set defined in ban-nondeterminism.sh."
+    required_evidence:
+      - type: static_inspection
+      - type: ci_artifact
+    owner_role: Architect
+
+  DET-002:
+    statement: "Rust and JS implementations produce bit-identical outputs for all float canonicalization and serialization in the deterministic test corpus."
+    required_evidence:
+      - type: behavior_test
+      - type: ci_artifact
+    owner_role: CI Engineer
+
+  SEC-001:
+    statement: "CBOR payloads declaring more than MAX_OPS operations are rejected with an error before allocation."
+    required_evidence:
+      - type: behavior_test
+      - type: ci_artifact
+    owner_role: Security Engineer
+
+  SEC-002:
+    statement: "CBOR payloads with trailing bytes after the expected structure are rejected with an error."
+    required_evidence:
+      - type: behavior_test
+      - type: ci_artifact
+    owner_role: Security Engineer
+
+  SEC-003:
+    statement: "CBOR payloads truncated before the expected structure is complete are rejected with an error."
+    required_evidence:
+      - type: behavior_test
+      - type: ci_artifact
+    owner_role: Security Engineer
+
+  SEC-004:
+    statement: "CBOR payloads with unrecognized version fields are rejected with an error."
+    required_evidence:
+      - type: behavior_test
+      - type: ci_artifact
+    owner_role: Security Engineer
+
+  SEC-005:
+    statement: "CBOR payloads containing out-of-range enum discriminant tags are rejected with an error."
+    required_evidence:
+      - type: behavior_test
+      - type: ci_artifact
+    owner_role: Security Engineer
+
+  REPRO-001:
+    statement: "Dual WASM builds of ttd-browser produce bit-identical artifacts, verified by SHA-256 hash comparison in isolated CI environments."
+    required_evidence:
+      - type: ci_artifact
+      - type: static_inspection
+    owner_role: CI Engineer
+
+  PRF-001:
+    statement: "MaterializationBus hot-path benchmark latency remains within the Criterion noise threshold across runs."
+    required_evidence:
+      - type: benchmark
+      - type: ci_artifact
+    owner_role: Performance Engineer
diff --git a/docs/determinism/sec-claim-map.json b/docs/determinism/sec-claim-map.json
new file mode 100644
index 00000000..5e4dd967
--- /dev/null
+++ b/docs/determinism/sec-claim-map.json
@@ -0,0 +1,35 @@
+{
+  "version": 1,
+  "mappings": [
+    {
+      "claim_id": "SEC-001",
+      "control": "MAX_OPS+1 rejection",
+      "test_id": "cbor::tests::reject_exceeding_max_ops",
+      "crate": "echo-scene-codec"
+    },
+    {
+      "claim_id": "SEC-002",
+      "control": "trailing-byte rejection",
+      "test_id": "cbor::tests::reject_trailing_garbage",
+      "crate": "echo-scene-codec"
+    },
+    {
+      "claim_id": "SEC-003",
+      "control": "truncated payload rejection",
+      "test_id": "cbor::tests::drill_truncated_cbor",
+      "crate": "echo-scene-codec"
+    },
+    {
+      "claim_id": "SEC-004",
+      "control": "bad version handling",
+      "test_id": "cbor::tests::reject_invalid_version",
+      "crate": "echo-scene-codec"
+    },
+    {
+      "claim_id": "SEC-005",
+      "control": "invalid enum tag rejection",
+      "test_id": "cbor::tests::reject_invalid_enum_tags",
+      "crate": "echo-scene-codec"
+    }
+  ]
+}
diff --git a/scripts/classify_changes.cjs b/scripts/classify_changes.cjs
new file mode 100755
index 00000000..f1c135d8
--- /dev/null
+++ b/scripts/classify_changes.cjs
@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+const fs = require('fs');
+
+/**
+ * Checks if a file path matches a glob-like pattern.
+ * Supports ** for recursive directory matching and * for single level.
+ * 
+ * @param {string} file - The file path to check.
+ * @param {string} pattern - The glob-like pattern to match against.
+ * @returns {boolean} - True if the path matches the pattern.
+ */
+function matches(file, pattern) {
+  const regexPattern = pattern
+    .replace(/\*\*/g, '___DBL_STAR___')
+    .replace(/\*/g, '___SGL_STAR___')
+    .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+    .replace(/___SGL_STAR___/g, '[^/]*')
+    .replace(/___DBL_STAR___/g, '.*');
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(file);
+}
+
+/**
+ * Classifies the impact of changed files based on a det-policy JSON.
+ * Outputs max_class and run_* flags for GitHub Actions.
+ * 
+ * @param {string} policyPath - Path to the det-policy JSON file.
+ * @param {string} changedFilesPath - Path to the file containing list of changed files.
+ */
+function classifyChanges(policyPath, changedFilesPath) {
+  if (!fs.existsSync(policyPath)) {
+    throw new Error(`Policy file not found: ${policyPath}`);
+  }
+  if (!fs.existsSync(changedFilesPath)) {
+    throw new Error(`Changed files list not found: ${changedFilesPath}`);
+  }
+
+  const policy = JSON.parse(fs.readFileSync(policyPath, 'utf8'));
+  const changedFiles = fs.readFileSync(changedFilesPath, 'utf8').split('\n').filter(Boolean);
+
+  let maxClass = 'DET_NONCRITICAL';
+  const classPriority = {
+    'DET_CRITICAL': 2,
+    'DET_IMPORTANT': 1,
+    'DET_NONCRITICAL': 0
+  };
+
+  const requireFull = policy.policy && policy.policy.require_full_classification;
+
+  for (const file of changedFiles) {
+    let matched = false;
+    if (policy.crates) {
+      for (const [crateName, crateInfo] of Object.entries(policy.crates)) {
+        const paths = crateInfo.paths || [];
+        for (const pattern of paths) {
+          if (matches(file, pattern)) {
+            matched = true;
+            const cls = crateInfo.class;
+            if (classPriority[cls] > classPriority[maxClass]) {
+              maxClass = cls;
+            }
+          }
+        }
+      }
+    }
+    
+    if (requireFull && !matched) {
+      throw new Error(`File ${file} is not classified in det-policy.yaml and require_full_classification is enabled.`);
+    }
+  }
+
+  // Debug log for CI visibility
+  console.error(`Classified ${changedFiles.length} files. Max class: ${maxClass}`);
+
+  process.stdout.write(`max_class=${maxClass}\n`);
+  process.stdout.write(`run_full=${maxClass === 'DET_CRITICAL'}\n`);
+  process.stdout.write(`run_reduced=${maxClass === 'DET_IMPORTANT' || maxClass === 'DET_CRITICAL'}\n`);
+  const noGates = changedFiles.length === 0 || maxClass === 'DET_NONCRITICAL';
+  process.stdout.write(`run_none=${noGates}\n`);
+}
+
+module.exports = { classifyChanges, matches };
+
+if (require.main === module) {
+  try {
+    const policyPath = process.argv[2] || 'det-policy.json';
+    const changedFilesPath = process.argv[3] || 'changed.txt';
+    classifyChanges(policyPath, changedFilesPath);
+  } catch (e) {
+    console.error(e.message);
+    process.exit(1);
+  }
+}
diff --git a/scripts/generate_evidence.cjs b/scripts/generate_evidence.cjs
new file mode 100755
index 00000000..843de026
--- /dev/null
+++ b/scripts/generate_evidence.cjs
@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Generates an evidence JSON pack for CI claims.
+ * Maps specific claim IDs to immutable CI artifacts if they exist.
+ * 
+ * @param {string} gatheredArtifactsDir - Path to the directory where all artifacts were downloaded.
+ */
+function generateEvidence(gatheredArtifactsDir) {
+  const workflow = process.env.GITHUB_WORKFLOW || 'det-gates';
+  const runId = process.env.GITHUB_RUN_ID || 'local';
+  const commitSha = process.env.GITHUB_SHA || 'local';
+
+  const checkArtifact = (name) => {
+    const fullPath = path.join(gatheredArtifactsDir, name);
+    try {
+      return fs.existsSync(fullPath) && fs.readdirSync(fullPath).length > 0;
+    } catch (e) {
+      return false;
+    }
+  };
+
+  const claims = [
+    {
+      id: 'DET-001',
+      status: checkArtifact('static-inspection') ? 'VERIFIED' : 'UNVERIFIED',
+      evidence: { workflow, run_id: runId, commit_sha: commitSha, artifact_name: 'static-inspection' }
+    },
+    {
+      id: 'DET-002',
+      status: checkArtifact('det-linux-artifacts') ? 'VERIFIED' : 'UNVERIFIED',
+      evidence: { workflow, run_id: runId, commit_sha: commitSha, artifact_name: 'det-linux-artifacts' }
+    },
+    {
+      id: 'SEC-001',
+      status: checkArtifact('sec-artifacts') ? 'VERIFIED' : 'UNVERIFIED',
+      evidence: { workflow, run_id: runId, commit_sha: commitSha, artifact_name: 'sec-artifacts' }
+    },
+    {
+      id: 'SEC-002',
+      status: checkArtifact('sec-artifacts') ? 'VERIFIED' : 'UNVERIFIED',
+      evidence: { workflow, run_id: runId, commit_sha: commitSha, artifact_name: 'sec-artifacts' }
+    },
+    {
+      id: 'SEC-003',
+      status: checkArtifact('sec-artifacts') ? 'VERIFIED' : 'UNVERIFIED',
+      evidence: { workflow, run_id: runId, commit_sha: commitSha, artifact_name: 'sec-artifacts' }
+    },
+    {
+      id: 'SEC-004',
+      status: checkArtifact('sec-artifacts') ? 'VERIFIED' : 'UNVERIFIED',
+      evidence: { workflow, run_id: runId, commit_sha: commitSha, artifact_name: 'sec-artifacts' }
+    },
+    {
+      id: 'SEC-005',
+      status: checkArtifact('sec-artifacts') ? 'VERIFIED' : 'UNVERIFIED',
+      evidence: { workflow, run_id: runId, commit_sha: commitSha, artifact_name: 'sec-artifacts' }
+    },
+    {
+      id: 'REPRO-001',
+      status: checkArtifact('build-repro-artifacts') ? 'VERIFIED' : 'UNVERIFIED',
+      evidence: { workflow, run_id: runId, commit_sha: commitSha, artifact_name: 'build-repro-artifacts' }
+    },
+    {
+      id: 'PRF-001',
+      status: checkArtifact('perf-artifacts') ? 'VERIFIED' : 'UNVERIFIED',
+      evidence: { workflow, run_id: runId, commit_sha: commitSha, artifact_name: 'perf-artifacts' }
+    }
+  ];
+
+  const evidence = {
+    claims,
+    metadata: {
+      generated_at: new Date().toISOString(),
+      workflow,
+      run_id: runId,
+      commit_sha: commitSha
+    }
+  };
+
+  const outputPath = path.join(gatheredArtifactsDir, 'evidence.json');
+  fs.writeFileSync(outputPath, JSON.stringify(evidence, null, 2));
+  console.log(`Generated evidence.json at ${outputPath}`);
+}
+
+module.exports = { generateEvidence };
+
+if (require.main === module) {
+  const gatheredArtifactsDir = process.argv[2] || '.';
+  generateEvidence(gatheredArtifactsDir);
+}
diff --git a/scripts/validate_claims.cjs b/scripts/validate_claims.cjs
new file mode 100755
index 00000000..ad8378d4
--- /dev/null
+++ b/scripts/validate_claims.cjs
@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+const fs = require('fs');
+
+/**
+ * Validates that all claims marked as VERIFIED in the evidence file
+ * have the required immutable CI pointers (workflow, run_id, commit_sha, artifact_name).
+ * 
+ * @param {string} evidenceFile - Path to the evidence JSON file.
+ * @returns {boolean} - True if all verified claims are valid.
+ */
+function validateClaims(evidenceFile) {
+  if (!fs.existsSync(evidenceFile)) {
+    console.error(`Error: Evidence file ${evidenceFile} not found.`);
+    return false;
+  }
+
+  try {
+    const data = JSON.parse(fs.readFileSync(evidenceFile, 'utf8'));
+    const requiredFields = ['workflow', 'run_id', 'commit_sha', 'artifact_name'];
+    const violations = [];
+
+    if (!data.claims || !Array.isArray(data.claims)) {
+      console.error('Error: evidence.json is missing a valid claims array.');
+      return false;
+    }
+
+    for (const claim of data.claims) {
+      if (claim.status === 'VERIFIED') {
+        const evidence = claim.evidence || {};
+        const missing = requiredFields.filter(f => evidence[f] == null || evidence[f] === '');
+        if (missing.length > 0) {
+          violations.push(`Claim ${claim.id} is VERIFIED but missing pointers: ${missing.join(', ')}`);
+          continue;
+        }
+
+        // Semantic validation
+        if (evidence.commit_sha !== 'local' && !/^[0-9a-f]{40}$/i.test(evidence.commit_sha)) {
+          violations.push(`Claim ${claim.id} has invalid commit_sha: ${evidence.commit_sha}`);
+        }
+        if (!/^\d+$/.test(String(evidence.run_id)) && evidence.run_id !== 'local') {
+          violations.push(`Claim ${claim.id} has invalid run_id: ${evidence.run_id}`);
+        }
+      }
+    }
+
+    if (violations.length > 0) {
+      violations.forEach(v => console.error(v));
+      return false;
+    }
+
+    console.log('All VERIFIED claims have required evidence pointers.');
+    return true;
+  } catch (e) {
+    console.error(`Error parsing evidence JSON: ${e}`);
+    return false;
+  }
+}
+
+module.exports = { validateClaims };
+
+if (require.main === module) {
+  const evidencePath = process.argv[2] || 'evidence.json';
+  if (!validateClaims(evidencePath)) {
+    process.exit(1);
+  }
+}
diff --git a/scripts/validate_det_policy.cjs b/scripts/validate_det_policy.cjs
new file mode 100755
index 00000000..f0346f41
--- /dev/null
+++ b/scripts/validate_det_policy.cjs
@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+const fs = require('fs');
+
+/**
+ * Validates the structure and content of a det-policy JSON file.
+ * Checks for required gate definitions, crate classifications, and owner assignments.
+ * 
+ * @param {string} filePath - Path to the det-policy JSON file.
+ * @returns {boolean} - True if the policy file is valid.
+ */
+function validateDetPolicy(filePath) {
+  if (!fs.existsSync(filePath)) {
+    console.error(`Error: ${filePath} not found.`);
+    return false;
+  }
+
+  try {
+    // Expecting JSON format to avoid external dependencies
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+
+    if (data.version !== 1) {
+      console.error(`Error: Invalid version in ${filePath}`);
+      return false;
+    }
+
+    const ALLOWED_GATES = new Set(['G1', 'G2', 'G3', 'G4']);
+    const classes = data.classes || {};
+    const crates = data.crates || {};
+    const policy = data.policy || {};
+
+    // Check classes
+    for (const [className, classInfo] of Object.entries(classes)) {
+      if (!Array.isArray(classInfo.required_gates)) {
+        console.error(`Error: Class ${className} missing or invalid required_gates (must be an array)`);
+        return false;
+      }
+      for (const gate of classInfo.required_gates) {
+        if (!ALLOWED_GATES.has(gate)) {
+          console.error(`Error: Class ${className} has invalid gate ${gate}`);
+          return false;
+        }
+      }
+    }
+
+    // Check crates
+    for (const [crateName, crateInfo] of Object.entries(crates)) {
+      if (!crateInfo.class) {
+        console.error(`Error: Crate ${crateName} missing class`);
+        return false;
+      }
+      const cls = crateInfo.class;
+      if (!classes[cls]) {
+        console.error(`Error: Crate ${crateName} has unknown class ${cls}`);
+        return false;
+      }
+
+      if (!crateInfo.paths || !Array.isArray(crateInfo.paths) || crateInfo.paths.length === 0) {
+        console.error(`Error: Crate ${crateName} missing or invalid paths`);
+        return false;
+      }
+
+      if (policy.require_owners_for_critical && cls === 'DET_CRITICAL') {
+        if (!crateInfo.owner_role) {
+          console.error(`Error: DET_CRITICAL crate ${crateName} missing owner_role`);
+          return false;
+        }
+      }
+    }
+
+    console.log(`${filePath} is valid.`);
+    return true;
+  } catch (e) {
+    console.error(`Error parsing JSON: ${e}`);
+    return false;
+  }
+}
+
+module.exports = { validateDetPolicy };
+
+if (require.main === module) {
+  const filePath = process.argv[2] || 'det-policy.json';
+  if (!validateDetPolicy(filePath)) {
+    process.exit(1);
+  }
+}