First Asset Lineage.
The insurer, PE, fund admin, tokenization, and regulator story — all at once.

01The two queries — what they return

asset:           loan_84711_borrower_principal
decisions:       2
  · decision_loan_84711_recommendation (recommend_credit)
    outcome=recommend_approve by AI risk agent
  · decision_loan_84711_approval (approve_credit_application)
    outcome=approved by credit officer
responsibilities: 2 chains
loss_events:     1  (loss_loan_84711_default · $4.2M · credit_default)
claim_events:    1  (claim_84711 · $4.2M · filed)
consequences:    0
aggregate $:     $4,200,000.00
evidence events: 4

distinct principals:    6
  asset_owners:         1
  actors:               2
  supervisors:          2
  policy_owners:        1
  model_owners:         1
  approving_authorities: 1
─────────────────────────
The asset is owned by 1 principal.
5 OTHER principals bore responsibility.

02The responsibility view — by principal, by role

The borrower owns the asset. None of the borrower's roles include Actor, Supervisor, Policy Owner, Model Owner, or Approving Authority. The decisions that produced the consequences for this asset were made entirely by people and systems other than the asset's owner. That is exactly the lesson the locked four-buyer audience cares about — and it is now rendered as structural fact, not opinion.

03The money quote

04The pattern — six money quotes, one corpus

The pattern is now six lines deep. Each line is something people routinely confuse.

05The schema (Q1 LOCKED Option A — pure composition)

"Asset Lineage is supposed to prove a category, not a data model." Eric LOCKED zero new event kinds. v1 walks existing string references between Decision, ResponsibilityChain, LossEvent, ClaimEvent, and Consequence.

AssetLineage {
    asset_id, computed_at_ms,
    decisions: Vec<AssetLineageDecisionNode>,
    responsibilities: Vec<AssetLineageResponsibilityNode>,
    loss_events: Vec<LossEventSnapshot>,
    claim_events: Vec<ClaimEventSnapshot>,
    consequences: Vec<ConsequenceSnapshot>,
    risk_severities_observed, aggregate_exposure_usd,
    aggregate_exposure_value, evidence_event_count,
    money_quote, honest_limit_caption,
}

AssetResponsibility {
    asset_id, computed_at_ms,
    entries: Vec<AssetResponsibilityEntry>,
    count_asset_owners, count_actors, count_supervisors,
    count_policy_owners, count_model_owners, count_approving_authorities,
    money_quote, honest_limit_caption,
}

Upgrade note (page-level disclosure): Asset entities are currently derived from referenced objects. Future versions may introduce typed asset registration and transfer events. v1 preserves the upgrade path without contaminating the proof.

06Why this proof matters to four different buyers

07Where this proof sits — rung-deepener

Asset Lineage strengthens Rung 4 (Consequence Replay) by typing the asset as a first-class entity in the walk. Compounds naturally with #15 (loss lineage), #16 (inherited risk), and #167 (decision reproducibility). Pairs with #177 (Reality Gap Detection) for asset-scoped gap reports.

08What this proof IS and IS NOT

09Honest limits

1. Asset entities are derived from references. v1 walks string references; typed AssetRegister + AssetTransfer events are a future schema option (locked as future work in the design memo).
2. Off-chain asset transfers are not visible. The walk is over canonical events; possession changes outside the log are invisible to v1.
3. show_asset_responsibility names roles, not fault. A principal named in a chain bore a structural role; whether that role was exercised correctly is an audit determination.
4. Phase E applies. Pre-L9.1 events on the canonical continuity tenant carry the same unverifiable-but-structurally-replayable status. v1 reports honestly.
5. Asset ≠ Responsibility. The money quote.

10Evidence appendix

11Readiness determination

What this unlocks: an asset-centric walk every PE, fund admin, tokenization, insurer, and regulator buyer immediately understands. The walk is structural; the lesson is universal.

What this does not unlock: ownership determinations, fault verdicts, off-chain asset visibility, or typed-asset-entity workflows. Those wait for v2's optional AssetRegister + AssetTransfer event kinds (preserved as upgrade path; not built in v1). Asset ≠ Responsibility.