# Production Readiness Report — First Replayable Responsibility (accountability infrastructure)

**Proof ID:** `first-replayable-responsibility`
**Subject:** A failure scenario — a $50M treasury transfer approved on an AI recommendation under policy v1, which incurred a $20M loss. Two years later the supervisor's authority is revoked (employment terminated). Five years later, replay reconstructs the full responsibility chain at the moment of decision, including who retained which type of responsibility, even though the supervisor's authority no longer exists.
**Date:** 2026-06-02
**Determination:** PROVEN IN OPERATION (scope: one accountability tenant, 9 signed events, 2 decisions with full responsibility chains, 7 responsibility types derivable, 13 typed responsibility_index entries, the supervisor's authority is revoked while the responsibility at decision time remains intact.)
**Version:** 1.0 (Final)

---

## The killer concept (LOCKED — Eric Beans, June 2 2026)

> *"Responsibility survives authority."*

**Authority may be revoked, expired, suspended. Responsibility remains replayable forever.**

> "Many systems can tell you who had permission. Very few can tell you who remained accountable after the permission disappeared."

This is the sentence that distinguishes H33 from every IAM, GRC, governance, and audit system in market today.

---

## The framing discipline

NOT: *"Who do we blame?"* (legal interpretation).

YES: ***"Who owned what responsibility at the moment the decision occurred?"*** (structural evidentiary fact).

Liability is the legal interpretation applied to a responsibility chain. The schema records the structural fact; the legal interpretation is layered on at audit time.

---

## Three claims (the 10-second read)

1. **Every decision carries a `responsibility_chain` at the moment of decision** — actor + supervisor + policy_owner + model_owner + approving_authority + asset_owner + delegated_from + timestamp. Reconstructable byte-identically from signed canonical events.
2. **Seven responsibility types are queryable** — EXECUTION · SUPERVISION · POLICY · MODEL · APPROVAL · ASSET · OVERSIGHT. The engine derives a typed `responsibility_index` so ASL queries like *"find decisions where principal_X retained APPROVAL"* return answers.
3. **The supervisor's authority is revoked in the snapshot, but their responsibility at decision time is permanently recorded.** Authority was revoked. Responsibility remained.

---

## 01 — The failure scenario

Five years ago — June 1, 2025 — a $50M treasury transfer was approved at this enterprise.

The AI risk agent reviewed the proposed transfer under the underwriting model `model_treasury_underwriting v1` and recommended approval. The human supervisor consumed the recommendation and authorized the transfer. The transfer cleared. The policy in effect was `pol_treasury_transfer_approval v1`.

Six months later, in December 2025, the policy owner amended the policy — tightening the risk threshold from 0.75 to 0.60 and dropping the maximum transfer ceiling from $50M to $25M. This was too late for the June transfer; it incurred a $20M loss in subsequent years.

Two years post-decision, in June 2027, the supervisor's authority was revoked. Reason: `employment_terminated`. Reason category: `compliance_action` following the $20M loss investigation.

Five years post-decision, June 2030, an auditor and an investigator open the question:

> *"Reconstruct who retained responsibility for this decision at the moment it occurred."*

That's the question this proof answers.

---

## 02 — The two decisions and their responsibility chains

### Decision 1 — the recommendation

| Field | Value |
|---|---|
| `decision_id` | `decision_treasury_50M_recommendation` |
| `at_ms` | 1748736000000 (June 1, 2025, 00:00 UTC) |
| `actor_principal` | `princ_risk_agent_001` |
| `capability` | `recommend_transfer` |
| `subject` | `transfer_50M_treasury_holdings` |
| `model_version_ref` | `(model_treasury_underwriting, 1)` |
| `policy_version_ref` | `(pol_treasury_transfer_approval, 1)` |
| `outcome` | `recommend_approve` |
| **responsibility_chain** | actor: risk_agent · supervisor: human_supervisor · policy_owner: policy_owner · model_owner: model_owner · asset_owner: treasury_holder · delegated_from: human_supervisor |

### Decision 2 — the approval (consumes Decision 1)

| Field | Value |
|---|---|
| `decision_id` | `decision_treasury_50M_approval` |
| `at_ms` | 1748739600000 (June 1, 2025, 01:00 UTC) |
| `actor_principal` | `princ_human_supervisor_001` |
| `capability` | `approve_treasury_transfer` |
| `outcome` | `approved` |
| `parent_decision_ids` | `["decision_treasury_50M_recommendation"]` |
| **responsibility_chain** | actor: human_supervisor · approving_authority: human_supervisor · policy_owner: policy_owner · model_owner: model_owner · asset_owner: treasury_holder · delegated_from: root |

---

## 03 — The reconstructed responsibility (seven types)

The engine derives a `responsibility_index` from each decision's chain. Each entry is `(decision_id, principal, responsibility_type, at_ms, delegated_from?)`. Thirteen entries across both decisions:

| Decision | Principal | Type |
|---|---|---|
| recommendation | `princ_risk_agent_001` | **EXECUTION** |
| recommendation | `princ_human_supervisor_001` | **SUPERVISION** |
| recommendation | `princ_policy_owner_001` | **POLICY** |
| recommendation | `princ_model_owner_001` | **MODEL** |
| recommendation | `princ_treasury_holder_001` | **ASSET** |
| recommendation | `princ_human_supervisor_001` | **OVERSIGHT** (delegated_from) |
| approval | `princ_human_supervisor_001` | **EXECUTION** |
| approval | `princ_human_supervisor_001` | **APPROVAL** |
| approval | `princ_root_responsibility_…` | **SUPERVISION** |
| approval | `princ_policy_owner_001` | **POLICY** |
| approval | `princ_model_owner_001` | **MODEL** |
| approval | `princ_treasury_holder_001` | **ASSET** |
| approval | `princ_root_responsibility_…` | **OVERSIGHT** (delegated_from) |

This is the queryable substrate. ASL extensions (planned) surface as one-line queries.

---

## 04 — The killer demonstration

By the replay timestamp (June 15, 2030), the supervisor's authority has been revoked for three years.

| Question | Answer |
|---|---|
| Is the supervisor in `active_grants` now? | ✗ **NO** — authority revoked T+730 days, reason `employment_terminated` |
| Is the supervisor in the approval `responsibility_chain` at decision time? | ✓ **YES** — `actor`, `approving_authority`, and `responsibility_timestamp_ms = T_decision` |
| Time since the supervisor's authority was revoked, at replay time | ≈ 95,184,000,000 ms (≈ 3 years) |
| Does this change the recorded responsibility? | ✗ **NO** — the chain is signed in the canonical event log at decision time. Subsequent revocation is a separate event. |

> **Authority was revoked. Responsibility remained.**

This is the demonstration auditors, insurers, investigators, and regulators care about. It is also the demonstration that distinguishes H33 from every IAM, GRC, governance, and audit system in market today.

---

## 05 — ASL-style queries demonstrated

Eric's locked taxonomy makes responsibility queryable. The test exercises the substrate with these ASL-style queries (typed Rust today; string-DSL in a future ASL v2):

```
supervisor retained APPROVAL responsibility for:
  → [decision_treasury_50M_approval]

policy_owner retained POLICY responsibility for:
  → [both decisions]

model_owner retained MODEL responsibility for:
  → [both decisions]

asset_owner retained ASSET responsibility for:
  → [both decisions]

risk_agent retained EXECUTION responsibility for:
  → [recommendation only]
```

These are the substrate queries ASL will surface as one-click portal answers in Proof #19 Regulator Mode, and as the foundation for Decision Insurance underwriting in the roadmap.

---

## 06 — The schema

```rust
ResponsibilityChain {
    actor: Option<PrincipalId>,                  // EXECUTION
    supervisor: Option<PrincipalId>,             // SUPERVISION
    policy_owner: Option<PrincipalId>,           // POLICY
    model_owner: Option<PrincipalId>,            // MODEL
    approving_authority: Option<PrincipalId>,    // APPROVAL
    asset_owner: Option<PrincipalId>,            // ASSET
    delegated_from: Option<PrincipalId>,         // OVERSIGHT
    responsibility_timestamp_ms: u64,
}

ResponsibilityIndexEntry {
    decision_id: String,
    principal: PrincipalId,
    responsibility_type: String,  // 7-value taxonomy
    at_ms: u64,
    delegated_from: Option<PrincipalId>,
}
```

`AuthEvent::Decision` extended with `responsibility_chain: Option<ResponsibilityChain>` — backward-compat via `skip_serializing_if = Option::is_none`. `DecisionSnapshot` extended with the same field. `AuthorityStateSnapshot` extended with `responsibility_index: Vec<ResponsibilityIndexEntry>` (skip-if-empty).

**All 14 prior proofs' state_ids verified byte-identical under the extended engine** — decisions without the chain produce an empty index for those tenants.

The 7-value `responsibility_type` taxonomy is implicit in the field names; ASL queries reference these strings directly.

---

## 07 — What this proof IS and IS NOT

**This proof IS:**
- The accountability layer on top of #14 (Authority Lifecycle Replay). The substrate Eric named as *"one of the most important objects in the entire system."*
- A *structural evidentiary fact* — who owned what responsibility at the moment the decision occurred, recorded in signed canonical events.
- The first proof to demonstrate that *responsibility survives authority* — explicit failure scenario where the supervisor's authority is revoked but their responsibility at decision time is permanent.
- The substrate that #18 Asset Lineage and #19 Regulator Mode + the Decision Insurance roadmap items ride on.

**This proof IS NOT:**
- A legal verdict. Liability is the legal interpretation of a responsibility chain; that's a separate layer applied at audit time.
- A claim that the engine enforces "responsibility cannot be assigned to revoked principals at issuance" — issuance-time enforcement is policy-layer.
- A claim that any real enterprise has migrated their decisions onto responsibility-chain-bearing events yet (operator-side; the substrate is ready when the first one does).
- A complete demonstration of all the ASL queries the substrate makes possible — the string-DSL parser is a v2 ASL item.

---

## 08 — Known limitations

1. **`Modify` event still deferred** from #14 — mid-lifecycle scope or expiry changes warrant their own event kind.
2. **Phase E lock open.** `AuthEvent.signature` stored but not verified at replay ingestion; L9.1 closes this.
3. **ASL string-DSL parser not yet shipped.** The substrate supports typed queries today; the string-DSL is v2.
4. **Decisions in this proof carry the chain by direct authoring (operator-side).** A receipt-issuing service that auto-populates `responsibility_chain` from runtime context is a follow-up.
5. **Single tenant, two decisions.** Multi-tenant cross-organizational responsibility is queued for #16 (Enterprise Acquisition Replay).

---

## 09 — Evidence appendix

| Field | Value |
|---|---|
| Tenant ID | `tenant_responsibility_chain_44962d9b-25f5-5622-bd9a-98d5580bb8a2` |
| Tenant root | `princ_root_responsibility_44962d9b-…` |
| Risk Agent | `princ_risk_agent_001` |
| Human Supervisor | `princ_human_supervisor_001` |
| Policy Owner | `princ_policy_owner_001` |
| Model Owner | `princ_model_owner_001` |
| Treasury Holder (asset owner) | `princ_treasury_holder_001` |
| Event count | 9 |
| Decisions with chain | 2 of 2 |
| responsibility_index entries | 13 |
| 7 responsibility types represented | ✓ |
| state_id at T_replay (5yr later) | `7cf13a8fb53fc38d5d82936694c2018901307e52789df221e5464b2acad70d2c` |
| Reconstruction artifact | [`reconstruction.json`](reconstruction.json) |
| Harness | `tests/replayable_responsibility_001.rs` (scif-backend @ `8544e3915`) |

---

## Independent reconstruction

```bash
H33_TEST_PG_URL='postgres://…?sslmode=require' \
  cargo test --test replayable_responsibility_001 -- --ignored --nocapture
```

Expected: state_id matches; both decisions carry their `responsibility_chain`; the supervisor's authority is revoked at the replay's T BUT remains in the approval chain at the decision's `responsibility_timestamp_ms`; 13 typed entries in `responsibility_index` across all 7 types.

---

## 10 — Readiness determination

> **First Replayable Responsibility: PROVEN IN OPERATION** for one accountability tenant, 9 signed events, 2 decisions with full responsibility chains, 7 responsibility types derivable, supervisor's authority revoked while responsibility at decision time remains intact.

What this unlocks:
- The accountability infrastructure layer on top of authority infrastructure.
- ASL queries over the responsibility_index (substrate ready; string-DSL is v2).
- **Proof #15 — First Replayable Insurance Claim:** answers *"who acted, who approved, who supervised, who retained responsibility"* exactly the questions claim investigators care about.
- **Proof #18 — First Asset Lineage:** `asset_owner` is already in the chain; the Asset object becomes the typed entity it references.
- **Proof #19 — First Regulator Mode:** seven responsibility queries become one-click portal answers.
- The Decision Insurance roadmap item: insurers underwrite the chain, not just the event.
- The Reality Gap Detection roadmap item: *"show me decisions where retained responsibility doesn't match the org chart."*

What this does **not** unlock:
- A legal verdict.
- Issuance-time enforcement (policy-layer concern).
- The string-DSL ASL parser (v2).

---

## 11 — Where this proof sits

| # | Proof | Status |
|---|---|---|
| #11 | First Time Travel Replay (L5) | proven |
| #12 | First Independent Replay (L9, the moat) | proven |
| #12.1 | First Catastrophic Vendor Failure | proven |
| #13 | First Replayable Enterprise (the category) | proven |
| #14 | First Authority Lifecycle Replay (foundation of accountability) | proven |
| **#14.1** | **First Replayable Responsibility (this proof)** | **proven now** |
| #15 | First Replayable Insurance Claim | next |
| #16 | First Enterprise Acquisition Replay | roadmap |
| #18 | First Asset Lineage (formalizes the Asset object) | roadmap |
| #19 | First Regulator Mode (surfaces responsibility queries) | roadmap |

---

## Version

| Field | Value |
|---|---|
| Report version | v1.0 (Final) |
| Frozen | 2026-06-02 |
| Supersedes | None |
| Superseded by (planned) | `first-replayable-responsibility-with-asl-queries` (when ASL string-DSL ships) · `first-responsibility-at-issuance` (when receipt-issuing service auto-populates the chain) |

---

*Issued by H33, Inc. — Eric Beans, CEO. Independently reconstructable per Section 09.*