Add CI, contributor essentials, and full T3/T4 demo coverage

- GitHub Actions CI: fmt check, clippy (-D warnings), build, test, release smoke test
- Dependabot for cargo + github-actions
- CONTRIBUTING.md, SECURITY.md, issue templates, PR template
- CHANGELOG.md
- Extend main.rs walkthrough to genuinely exercise T3/T4 elevation and D2/D3
capability issuance (was previously untested dead code, now real coverage)
- Document intentional clippy/dead_code allowances instead of suppressing
blindly
- README: CI/license/rust badges, live demo link, contributing/security/changelog sections
- Remove HF-only YAML frontmatter from the shared README (GitHub renders it
literally; license is now set via HF's dataset settings UI instead)

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,23 @@
+---
+name: Bug report
+about: Report unexpected behavior, a build failure, or a broken test
+title: "[Bug] "
+labels: bug
+---
+
+**Describe the bug**
+A clear, concise description of what's wrong.
+
+**To reproduce**
+Steps or a minimal code snippet that triggers it.
+
+**Expected behavior**
+What you expected to happen instead.
+
+**Environment**
+- OS:
+- Rust version (`rustc --version`):
+- Commit/tag:
+
+**Additional context**
+Anything else relevant — logs, `cargo test` output, etc.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: true
+contact_links:
+  - name: Security vulnerability
+    url: https://github.com/kaymyg/ubda-engine/security/advisories/new
+    about: Please report security issues privately — see SECURITY.md

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,18 @@
+---
+name: Feature request
+about: Suggest an addition or improvement to the architecture or code
+title: "[Feature] "
+labels: enhancement
+---
+
+**What are you trying to do?**
+Describe the use case or gap you've noticed.
+
+**Proposed approach**
+If you have one in mind — a new module, a change to an existing trait, etc.
+
+**Alternatives considered**
+Any other ways to solve this you thought about and ruled out.
+
+**Additional context**
+Links, references, or related issues.

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,15 @@
+## What does this change do?
+
+<!-- Brief description -->
+
+## Checklist
+
+- [ ] `cargo fmt --check` passes
+- [ ] `cargo clippy --all-targets --all-features -- -D warnings` passes
+- [ ] `cargo test` passes
+- [ ] Updated `docs/ARCHITECTURE.md` or `README.md` if this changes behavior or structure
+- [ ] Added/updated tests for the change, where applicable
+
+## Related issue
+
+<!-- Closes #123, if applicable -->

.github/dependabot.yml

@@ -0,0 +1,11 @@
+version: 2
+updates:
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 5
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/ci.yml

@@ -0,0 +1,59 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  fmt:
+    name: Format check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install stable toolchain with rustfmt
+        run: rustup component add rustfmt
+      - name: Check formatting
+        run: cargo fmt --check
+
+  clippy:
+    name: Clippy lints
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install stable toolchain with clippy
+        run: rustup component add clippy
+      - name: Cache cargo registry
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+      - name: Run clippy
+        run: cargo clippy --all-targets --all-features -- -D warnings
+
+  test:
+    name: Build & test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Cache cargo registry
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+      - name: Build
+        run: cargo build --locked --verbose
+      - name: Run tests
+        run: cargo test --locked --verbose
+      - name: Run release walkthrough (smoke test)
+        run: cargo run --locked --release

CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to this project are documented here.
+Format loosely follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## [1.2.0-alpha] - 2026-08-28
+
+### Added
+- Initial public release of the UBDA trust-state engine: `TrustState` /
+  `DataClassification` model, `SystemStateMachine`, `BehavioralTrustEngine`,
+  `MockHardwareAuthorizer` (`KeyAuthority`), `KeyBroker`, and `ReplayStore`.
+- End-to-end CLI walkthrough (`cargo run`) exercising the full T0→T4 trust
+  lifecycle, including D0–D3 capability issuance, replay defense, signature
+  tamper detection, and compromise lockout/recovery.
+- 17-test unit suite covering state transitions, capability issuance,
+  key-broker verification (signature, expiry, replay, session binding,
+  operation matching), and derived-key determinism.
+- Architecture documentation (`docs/ARCHITECTURE.md`) with trust-state and
+  component-isolation diagrams.
+- Live Gradio demo Space and a Hugging Face dataset backup of the source.
+- CI (fmt, clippy, build, test), issue/PR templates, security policy,
+  contributing guide, and Dependabot config.
+
+### Notes
+- `MockHardwareAuthorizer` is a software stand-in for a real hardware/TEE key
+  authority — see the README's prototype-status warning.

CONTRIBUTING.md

@@ -0,0 +1,59 @@
+# Contributing to UBDA
+
+Thanks for your interest in this project — it started as a self-teaching
+exercise in capability-based access-control design, and contributions,
+questions, and critiques are all welcome.
+
+## Getting set up
+
+Requires a stable Rust toolchain (2021 edition; tested against rustc 1.75+).
+
+```bash
+git clone https://github.com/kaymyg/ubda-engine.git
+cd ubda-engine
+cargo build
+cargo test
+cargo run
+```
+
+## Before opening a PR
+
+Please run the same checks CI runs, so review focuses on the actual change:
+
+```bash
+cargo fmt --check
+cargo clippy --all-targets --all-features -- -D warnings
+cargo test
+```
+
+If `cargo fmt --check` fails, just run `cargo fmt` to fix it in place.
+
+## What to work on
+
+Good starting points:
+
+- Anything in the "Known simplifications" section of
+  [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md)
+- Additional unit tests for edge cases not yet covered
+- Clearer error messages or documentation
+- A real (non-mock) `KeyAuthority` backend, e.g. against a software TEE
+  simulator
+
+For anything bigger than a small fix, please open an issue first to discuss
+the approach before investing time in a PR.
+
+## Commit style
+
+Small, focused commits with a clear one-line summary are preferred over one
+large commit. No strict format is enforced beyond that.
+
+## Reporting bugs / requesting features
+
+Use the issue templates under `.github/ISSUE_TEMPLATE/`. For security-relevant
+findings, please see [`SECURITY.md`](SECURITY.md) instead of opening a public
+issue.
+
+## Code of conduct
+
+Be respectful and constructive. This is a small educational project — the bar
+is "would a reasonable person feel welcome contributing here."

README.md

@@ -1,9 +1,9 @@
----
-license: mit
----
-
 # UBDA — Unified Behavioral Data Access (V1.2-alpha)
 
+[![CI](https://github.com/kaymyg/ubda-engine/actions/workflows/ci.yml/badge.svg)](https://github.com/kaymyg/ubda-engine/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Rust 2021](https://img.shields.io/badge/rust-2021_edition-orange.svg)](Cargo.toml)
+
 UBDA is a prototype **capability-based data access architecture** written in Rust. It
 models a system where a software behavioral-trust engine can *influence* trust
 levels, but only a separate hardware/TEE-style authority can ever mint the
@@ -16,6 +16,9 @@ explore the design pattern — not to ship a production security product.
 > is used as a placeholder for a future post-quantum signature scheme. Do not
 > use this as-is to protect real secrets.
 
+**Try it live:** [UBDA Engine Demo on Hugging Face Spaces](https://huggingface.co/spaces/sahek/ubda-engine)
+— click "Run protocol walkthrough" to execute the real compiled engine in your browser.
+
 ## Concept
 
 * **Trust states (`T-1`…`T4`)** describe how strongly the system currently
@@ -66,7 +69,8 @@ cargo test
 Expected `cargo run` output walks through: reaching T2 via behavioral
 continuity, a rejected over-privileged request, a full issue → verify →
 derive-key cycle, a blocked replay attempt, a blocked signature-tampering
-attempt, and a compromise lockout + recovery reset.
+attempt, full elevation through T3/T4 with real D2/D3 capability issuance, and
+a compromise lockout + recovery reset.
 
 ## Requirements
 
@@ -77,3 +81,18 @@ attempt, and a compromise lockout + recovery reset.
 ## License
 
 MIT — see [`LICENSE`](LICENSE).
+
+## Contributing
+
+Bug reports, feature ideas, and PRs are welcome — see
+[`CONTRIBUTING.md`](CONTRIBUTING.md) for setup and the checks CI runs.
+
+## Security
+
+Found a design or implementation flaw? Please see
+[`SECURITY.md`](SECURITY.md) for how to report it responsibly rather than
+opening a public issue.
+
+## Changelog
+
+See [`CHANGELOG.md`](CHANGELOG.md).

SECURITY.md

@@ -0,0 +1,33 @@
+# Security Policy
+
+## Project status
+
+UBDA is a **prototype / educational project** exploring a capability-based
+data access architecture. It is not audited, not hardened, and not intended
+to protect real secrets in production. See the warning at the top of the
+[README](README.md) for details — in particular, `MockHardwareAuthorizer`
+uses an in-process Ed25519 keypair and a hard-coded demo secret in place of a
+real HSM/TEE.
+
+That said, if you find a genuine flaw in the *design* (e.g. a way to bypass
+trust-state enforcement, forge a capability, or defeat replay protection
+within the model as specified), that's a meaningful and welcome finding.
+
+## Reporting a vulnerability
+
+Please **do not** open a public GitHub issue for security findings.
+
+Instead, use GitHub's private vulnerability reporting for this repository
+(Security tab → "Report a vulnerability"), or reach out directly to the
+maintainer. Please include:
+
+- A description of the issue and its potential impact
+- Steps to reproduce, or a minimal example
+- Whether it affects the architectural design itself vs. this specific
+  prototype implementation
+
+## Response expectations
+
+This is a small, self-taught, part-time project — please expect a best-effort
+response rather than a guaranteed SLA. Reports will be acknowledged as soon
+as reasonably possible.

rustfmt.toml

@@ -0,0 +1 @@
+edition = "2021"

src/bte_interface.rs

@@ -17,7 +17,8 @@ impl BehavioralTrustEngine {
     ) -> PolicyAssertion {
         let inferred_state = if telemetry.anomaly_score >= self.anomaly_threshold {
             TrustState::Compromised
-        } else if telemetry.anomaly_score < 0.20 && current_state == TrustState::DeviceAuthenticated {
+        } else if telemetry.anomaly_score < 0.20 && current_state == TrustState::DeviceAuthenticated
+        {
             TrustState::BehavioralContinuity
         } else {
             current_state

src/hardware_authorizer.rs

@@ -1,5 +1,6 @@
 use crate::types::{
-    AccessOperation, DataClassification, DataAccessCapability, EphemeralSessionKey, PolicyAssertion, TrustState
+    AccessOperation, DataAccessCapability, DataClassification, EphemeralSessionKey,
+    PolicyAssertion, TrustState,
 };
 use ring::hkdf;
 use ring::rand::SystemRandom;
@@ -15,6 +16,9 @@ pub enum AuthorizerError {
         classification: DataClassification,
     },
     #[error("Signature generation failed.")]
+    // Ring's Ed25519 signing is currently infallible, so this variant isn't reachable yet.
+    // It's kept for forward compatibility with a fallible hardware/HSM or PQC signer.
+    #[allow(dead_code)]
     SigningFailure,
     #[error("Key derivation failed.")]
     DerivationFailure,
@@ -23,6 +27,10 @@ pub enum AuthorizerError {
 pub trait KeyAuthority {
     fn public_key_bytes(&self) -> &[u8];
 
+    // 8 args mirrors the signed DAC envelope's field set (resource, classification,
+    // operation, timing, nonce) one-to-one; a request-object refactor is tracked as a
+    // possible future cleanup, not urgent for a prototype of this size.
+    #[allow(clippy::too_many_arguments)]
     fn issue_dac(
         &self,
         assertion: &PolicyAssertion,
@@ -74,6 +82,7 @@ impl KeyAuthority for MockHardwareAuthorizer {
         &self.public_key
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn issue_dac(
         &self,
         assertion: &PolicyAssertion,
@@ -182,7 +191,10 @@ mod tests {
             60,
             1,
         );
-        assert!(matches!(dac, Err(AuthorizerError::InsufficientTrustState { .. })));
+        assert!(matches!(
+            dac,
+            Err(AuthorizerError::InsufficientTrustState { .. })
+        ));
     }
 
     #[test]
@@ -191,10 +203,26 @@ mod tests {
         let assertion = low_risk_assertion("s1", TrustState::BehavioralContinuity);
 
         let dac_a = authorizer
-            .issue_dac(&assertion, "a.enc".to_string(), DataClassification::D1, AccessOperation::Read, 0, 60, 1)
+            .issue_dac(
+                &assertion,
+                "a.enc".to_string(),
+                DataClassification::D1,
+                AccessOperation::Read,
+                0,
+                60,
+                1,
+            )
             .unwrap();
         let dac_b = authorizer
-            .issue_dac(&assertion, "b.enc".to_string(), DataClassification::D1, AccessOperation::Read, 0, 60, 2)
+            .issue_dac(
+                &assertion,
+                "b.enc".to_string(),
+                DataClassification::D1,
+                AccessOperation::Read,
+                0,
+                60,
+                2,
+            )
             .unwrap();
 
         let key_a = authorizer.derive_session_key(&dac_a).unwrap();
@@ -207,7 +235,15 @@ mod tests {
         let authorizer = MockHardwareAuthorizer::new();
         let assertion = low_risk_assertion("s1", TrustState::BehavioralContinuity);
         let dac = authorizer
-            .issue_dac(&assertion, "a.enc".to_string(), DataClassification::D1, AccessOperation::Read, 0, 60, 1)
+            .issue_dac(
+                &assertion,
+                "a.enc".to_string(),
+                DataClassification::D1,
+                AccessOperation::Read,
+                0,
+                60,
+                1,
+            )
             .unwrap();
 
         let key1 = authorizer.derive_session_key(&dac).unwrap();

src/key_broker.rs

@@ -9,13 +9,23 @@ pub enum KeyBrokerError {
     #[error("Invalid capability signature or canonical payload tampered.")]
     InvalidSignature,
     #[error("Time bounds invalid. Current: {current}, Issued: {issued}, Expires: {expires}")]
-    InvalidTimeBounds { current: i64, issued: i64, expires: i64 },
+    InvalidTimeBounds {
+        current: i64,
+        issued: i64,
+        expires: i64,
+    },
     #[error("Capability replayed! Cap ID or nonce consumed.")]
     ReplayDetected,
     #[error("Operation requested ({requested:?}) does not match DAC permission ({permitted:?}).")]
-    OperationMismatch { requested: AccessOperation, permitted: AccessOperation },
+    OperationMismatch {
+        requested: AccessOperation,
+        permitted: AccessOperation,
+    },
     #[error("System trust state ({current:?}) is lower than required DAC state ({required:?}).")]
-    StateRequirementNotMet { current: TrustState, required: TrustState },
+    StateRequirementNotMet {
+        current: TrustState,
+        required: TrustState,
+    },
     #[error("Session ID mismatch. Key Broker bound to {expected}, DAC issued to {found}.")]
     SessionMismatch { expected: String, found: String },
     #[error("Underlying Key Authority error.")]
@@ -72,7 +82,10 @@ impl<'a> KeyBroker<'a> {
             });
         }
 
-        if !self.replay_store.check_and_register(&dac.cap_id, &dac.session_id, dac.nonce) {
+        if !self
+            .replay_store
+            .check_and_register(&dac.cap_id, &dac.session_id, dac.nonce)
+        {
             return Err(KeyBrokerError::ReplayDetected);
         }
 
@@ -96,7 +109,12 @@ mod tests {
     use crate::hardware_authorizer::MockHardwareAuthorizer;
     use crate::types::{BehavioralTelemetry, DataClassification};
 
-    fn setup() -> (MockHardwareAuthorizer, DataAccessCapability, i64, &'static str) {
+    fn setup() -> (
+        MockHardwareAuthorizer,
+        DataAccessCapability,
+        i64,
+        &'static str,
+    ) {
         let authorizer = MockHardwareAuthorizer::new();
         let bte = BehavioralTrustEngine::new(0.7);
         let session_id = "test_session";
@@ -108,7 +126,8 @@ mod tests {
             spatial_risk_factor: 0.01,
             timestamp: now,
         };
-        let assertion = bte.process_telemetry(session_id, telemetry, TrustState::DeviceAuthenticated);
+        let assertion =
+            bte.process_telemetry(session_id, telemetry, TrustState::DeviceAuthenticated);
 
         let dac = authorizer
             .issue_dac(
@@ -144,7 +163,13 @@ mod tests {
         let (authorizer, dac, now, session_id) = setup();
         let mut broker = KeyBroker::new(&authorizer);
         broker
-            .execute_key_use(&dac, session_id, AccessOperation::Read, now, TrustState::BehavioralContinuity)
+            .execute_key_use(
+                &dac,
+                session_id,
+                AccessOperation::Read,
+                now,
+                TrustState::BehavioralContinuity,
+            )
             .unwrap();
 
         let replay = broker.execute_key_use(
@@ -184,7 +209,10 @@ mod tests {
             now,
             TrustState::DeviceAuthenticated, // below required T2
         );
-        assert!(matches!(result, Err(KeyBrokerError::StateRequirementNotMet { .. })));
+        assert!(matches!(
+            result,
+            Err(KeyBrokerError::StateRequirementNotMet { .. })
+        ));
     }
 
     #[test]
@@ -198,7 +226,10 @@ mod tests {
             now + 301, // past TTL
             TrustState::BehavioralContinuity,
         );
-        assert!(matches!(result, Err(KeyBrokerError::InvalidTimeBounds { .. })));
+        assert!(matches!(
+            result,
+            Err(KeyBrokerError::InvalidTimeBounds { .. })
+        ));
     }
 
     #[test]
@@ -212,7 +243,10 @@ mod tests {
             now,
             TrustState::BehavioralContinuity,
         );
-        assert!(matches!(result, Err(KeyBrokerError::OperationMismatch { .. })));
+        assert!(matches!(
+            result,
+            Err(KeyBrokerError::OperationMismatch { .. })
+        ));
     }
 
     #[test]
@@ -226,6 +260,9 @@ mod tests {
             now,
             TrustState::BehavioralContinuity,
         );
-        assert!(matches!(result, Err(KeyBrokerError::SessionMismatch { .. })));
+        assert!(matches!(
+            result,
+            Err(KeyBrokerError::SessionMismatch { .. })
+        ));
     }
 }

src/main.rs

@@ -23,7 +23,7 @@ fn main() {
     let now = chrono::Utc::now().timestamp();
 
     // 1. Establish State T0 -> T1 -> T2
-    println!("\n[1/6] Transitioning State: T0 -> T1 -> T2...");
+    println!("\n[1/7] Transitioning State: T0 -> T1 -> T2...");
     state_machine.handle_device_authenticated().unwrap();
 
     let telemetry = BehavioralTelemetry {
@@ -33,14 +33,20 @@ fn main() {
         timestamp: now,
     };
 
-    let assertion = bte.process_telemetry(session_id, telemetry.clone(), state_machine.current_state());
-    state_machine.handle_behavioral_assertion(&telemetry).unwrap();
+    let assertion =
+        bte.process_telemetry(session_id, telemetry.clone(), state_machine.current_state());
+    state_machine
+        .handle_behavioral_assertion(&telemetry)
+        .unwrap();
 
-    assert_eq!(state_machine.current_state(), TrustState::BehavioralContinuity);
+    assert_eq!(
+        state_machine.current_state(),
+        TrustState::BehavioralContinuity
+    );
     println!(" -> Active State: T2 (BehavioralContinuity)");
 
     // 2. Reject Insufficient Classification (T2 requesting D2 data)
-    println!("\n[2/6] Testing Classification Policy Enforcement (T2 requesting D2 data)...");
+    println!("\n[2/7] Testing Classification Policy Enforcement (T2 requesting D2 data)...");
     let d2_issuance = mock_authorizer.issue_dac(
         &assertion,
         "financial_records.enc".to_string(),
@@ -59,7 +65,7 @@ fn main() {
     }
 
     // 3. Valid D1 Capability Cycle
-    println!("\n[3/6] Issuing & Consuming Valid D1 Capability...");
+    println!("\n[3/7] Issuing & Consuming Valid D1 Capability...");
     let valid_dac = mock_authorizer
         .issue_dac(
             &assertion,
@@ -73,13 +79,22 @@ fn main() {
         .expect("D1 DAC issuance failed");
 
     let key = key_broker
-        .execute_key_use(&valid_dac, session_id, AccessOperation::Read, now, state_machine.current_state())
+        .execute_key_use(
+            &valid_dac,
+            session_id,
+            AccessOperation::Read,
+            now,
+            state_machine.current_state(),
+        )
         .expect("Key derivation failed");
 
-    println!(" -> PASS: Derived Ephemeral Key (Digest: {:?})", &key.key_bytes[0..4]);
+    println!(
+        " -> PASS: Derived Ephemeral Key (Digest: {:?})",
+        &key.key_bytes[0..4]
+    );
 
     // 4. Anti-Replay Enforcement
-    println!("\n[4/6] Testing Replay Defense...");
+    println!("\n[4/7] Testing Replay Defense...");
     let replay_result = key_broker.execute_key_use(
         &valid_dac,
         session_id,
@@ -96,7 +111,7 @@ fn main() {
     }
 
     // 5. Signature Tamper Verification
-    println!("\n[5/6] Testing Signature Integrity Verification...");
+    println!("\n[5/7] Testing Signature Integrity Verification...");
     let mut tampered_dac = mock_authorizer
         .issue_dac(
             &assertion,
@@ -122,13 +137,73 @@ fn main() {
 
     match tamper_result {
         Err(key_broker::KeyBrokerError::InvalidSignature) => {
-            println!(" -> PASS: Key Broker detected field modification via canonical verification.");
+            println!(
+                " -> PASS: Key Broker detected field modification via canonical verification."
+            );
         }
         _ => panic!(" -> FAIL: Tampered capability signature validated!"),
     }
 
-    // 6. Hard Anomaly Lockout & Controlled Recovery
-    println!("\n[6/6] Injecting Hard Anomaly Interrupt (T_-1 Lockout)...");
+    // 6. Full Elevation to T3/T4 and Issuing High-Classification Capabilities
+    println!("\n[6/7] Elevating T2 -> T3 -> T4 and Issuing D2/D3 Capabilities...");
+    state_machine.handle_step_up_auth().unwrap();
+    assert_eq!(state_machine.current_state(), TrustState::HighAssurance);
+    println!(" -> Active State: T3 (HighAssurance)");
+
+    let d2_assertion =
+        bte.process_telemetry(session_id, telemetry.clone(), state_machine.current_state());
+    let d2_dac = mock_authorizer
+        .issue_dac(
+            &d2_assertion,
+            "financial_records.enc".to_string(),
+            DataClassification::D2,
+            AccessOperation::Read,
+            now,
+            300,
+            2004,
+        )
+        .expect("D2 DAC issuance failed at T3");
+    key_broker
+        .execute_key_use(
+            &d2_dac,
+            session_id,
+            AccessOperation::Read,
+            now,
+            state_machine.current_state(),
+        )
+        .expect("D2 key derivation failed at T3");
+    println!(" -> PASS: Issued & consumed D2 capability under T3 trust level.");
+
+    state_machine.handle_critical_elevation().unwrap();
+    assert_eq!(state_machine.current_state(), TrustState::CriticalElevation);
+    println!(" -> Active State: T4 (CriticalElevation)");
+
+    let d3_assertion =
+        bte.process_telemetry(session_id, telemetry.clone(), state_machine.current_state());
+    let d3_dac = mock_authorizer
+        .issue_dac(
+            &d3_assertion,
+            "root_signing_key.enc".to_string(),
+            DataClassification::D3,
+            AccessOperation::Read,
+            now,
+            300,
+            2005,
+        )
+        .expect("D3 DAC issuance failed at T4");
+    key_broker
+        .execute_key_use(
+            &d3_dac,
+            session_id,
+            AccessOperation::Read,
+            now,
+            state_machine.current_state(),
+        )
+        .expect("D3 key derivation failed at T4");
+    println!(" -> PASS: Issued & consumed D3 (master key) capability under T4 trust level.");
+
+    // 7. Hard Anomaly Lockout & Controlled Recovery
+    println!("\n[7/7] Injecting Hard Anomaly Interrupt (T_-1 Lockout)...");
     state_machine.trigger_compromise();
     assert_eq!(state_machine.current_state(), TrustState::Compromised);
 

src/state_machine.rs

@@ -43,7 +43,10 @@ impl SystemStateMachine {
         Ok(self.current_state)
     }
 
-    pub fn handle_behavioral_assertion(&mut self, telemetry: &BehavioralTelemetry) -> Result<TrustState, StateMachineError> {
+    pub fn handle_behavioral_assertion(
+        &mut self,
+        telemetry: &BehavioralTelemetry,
+    ) -> Result<TrustState, StateMachineError> {
         self.assert_not_compromised()?;
 
         if telemetry.anomaly_score >= self.anomaly_threshold {
@@ -134,7 +137,8 @@ mod tests {
         sm.handle_device_authenticated().unwrap();
         assert_eq!(sm.current_state(), TrustState::DeviceAuthenticated);
 
-        sm.handle_behavioral_assertion(&low_risk_telemetry()).unwrap();
+        sm.handle_behavioral_assertion(&low_risk_telemetry())
+            .unwrap();
         assert_eq!(sm.current_state(), TrustState::BehavioralContinuity);
 
         sm.handle_step_up_auth().unwrap();
@@ -173,7 +177,9 @@ mod tests {
         sm.trigger_compromise();
 
         assert!(sm.handle_device_authenticated().is_err());
-        assert!(sm.handle_behavioral_assertion(&low_risk_telemetry()).is_err());
+        assert!(sm
+            .handle_behavioral_assertion(&low_risk_telemetry())
+            .is_err());
         assert!(sm.handle_step_up_auth().is_err());
         assert!(sm.handle_critical_elevation().is_err());
 

src/types.rs

@@ -4,21 +4,21 @@ use zeroize::{Zeroize, ZeroizeOnDrop};
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 pub enum TrustState {
     Compromised = -1,         // T_-1: Hard Isolation / Containment
-    Unauthenticated = 0,     // T_0: Unauthenticated / Raw Boot
-    DeviceAuthenticated = 1, // T_1: Hardened Device Access
-    BehavioralContinuity = 2,// T_2: BTE Telemetry Verified
-    HighAssurance = 3,       // T_3: Biometric / Step-Up Verified
-    CriticalElevation = 4,   // T_4: Out-of-Band / Hardware Token
+    Unauthenticated = 0,      // T_0: Unauthenticated / Raw Boot
+    DeviceAuthenticated = 1,  // T_1: Hardened Device Access
+    BehavioralContinuity = 2, // T_2: BTE Telemetry Verified
+    HighAssurance = 3,        // T_3: Biometric / Step-Up Verified
+    CriticalElevation = 4,    // T_4: Out-of-Band / Hardware Token
 }
 
 impl TrustState {
     /// Enforces the minimum trust state required for each data classification level.
     pub fn minimum_required_for(classification: DataClassification) -> Self {
         match classification {
-            DataClassification::D0 => TrustState::DeviceAuthenticated,   // D0 -> T1
-            DataClassification::D1 => TrustState::BehavioralContinuity,  // D1 -> T2
-            DataClassification::D2 => TrustState::HighAssurance,         // D2 -> T3
-            DataClassification::D3 => TrustState::CriticalElevation,     // D3 -> T4
+            DataClassification::D0 => TrustState::DeviceAuthenticated, // D0 -> T1
+            DataClassification::D1 => TrustState::BehavioralContinuity, // D1 -> T2
+            DataClassification::D2 => TrustState::HighAssurance,       // D2 -> T3
+            DataClassification::D3 => TrustState::CriticalElevation,   // D3 -> T4
         }
     }
 }