npm - percolation-inversion-compiler-ts - Versions diffs - 0.4.5 → 0.5.0 - Mend

percolation-inversion-compiler-ts 0.4.5 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (197) hide show

package/CHANGELOG.md +8 -0
package/README.md +77 -22
package/agent-manifest.json +50 -0
package/dist/alt_lift/index.d.ts +7 -0
package/dist/alt_lift/index.js +101 -0
package/dist/bit_engine/index.d.ts +8 -0
package/dist/bit_engine/index.js +213 -0
package/dist/cli/main.js +2106 -162
package/dist/index.d.ts +5 -0
package/dist/index.js +1611 -16
package/dist/phase_lab/index.d.ts +26 -0
package/dist/phase_lab/index.js +1124 -0
package/dist/sqot_controller/index.d.ts +8 -0
package/dist/sqot_controller/index.js +141 -0
package/dist/trc_adapter/index.d.ts +6 -0
package/dist/trc_adapter/index.js +86 -0
package/docs/alt-ecpt-lift.md +32 -0
package/docs/bit-inversion-engine.md +32 -0
package/docs/cli-reference.md +68 -0
package/docs/effective-packet-graph.md +35 -0
package/docs/for-agents.md +44 -0
package/docs/phase-ecology-lab.md +46 -0
package/docs/sqot-queue-sovereignty.md +31 -0
package/docs/threshold-certificates.md +30 -0
package/docs/trc-trace-adapter.md +30 -0
package/docs/v050-audit.md +126 -0
package/examples/alt_lift/alt_ecpt_lift.example.json +27 -0
package/examples/bit_engine/bottlenecks.example.json +38 -0
package/examples/bit_engine/inversion_candidates.example.json +55 -0
package/examples/packet_exchange/packet_envelope.example.json +51 -0
package/examples/packet_exchange/packet_merge_report.example.json +60 -0
package/examples/phase_lab/certificate_abstain.example.json +39 -0
package/examples/phase_lab/closure_report.example.json +41 -0
package/examples/phase_lab/effective_graph.example.json +112 -0
package/examples/phase_lab/executable_paths.example.json +20 -0
package/examples/phase_lab/phase_window_observation.example.json +61 -0
package/examples/phase_lab/runtime_report_1.json +19 -0
package/examples/phase_lab/runtime_report_2.json +16 -0
package/examples/phase_lab/threshold_status.example.json +31 -0
package/examples/sqot_controller/queue_report.example.json +30 -0
package/examples/sqot_controller/rebalance_plan.example.json +14 -0
package/examples/thresholds/asi_proxy_development.json +15 -0
package/examples/trc_adapter/tool_trace_input.example.json +17 -0
package/examples/trc_adapter/typed_trace.example.json +64 -0
package/fixtures/portability_conformance_v050/certificate_abstain.example.json +39 -0
package/fixtures/portability_conformance_v050/closure_report.example.json +39 -0
package/fixtures/portability_conformance_v050/effective_graph.example.json +112 -0
package/fixtures/portability_conformance_v050/executable_paths.example.json +20 -0
package/fixtures/portability_conformance_v050/manifest.json +55 -0
package/fixtures/portability_conformance_v050/phase_lab_event_1.json +51 -0
package/fixtures/portability_conformance_v050/phase_lab_event_2.json +55 -0
package/fixtures/portability_conformance_v050/phase_window_observation.example.json +61 -0
package/fixtures/portability_conformance_v050/runtime_report_1.json +19 -0
package/fixtures/portability_conformance_v050/runtime_report_2.json +14 -0
package/fixtures/portability_conformance_v050/threshold_status.example.json +29 -0
package/fixtures/python_v044_cli/agent_autonomy_audit.json +4 -3
package/fixtures/python_v044_cli/agent_manifest.json +2 -1
package/fixtures/python_v044_cli/agent_runbook.json +2 -1
package/fixtures/python_v044_cli/demo_installed_smoke.json +86 -86
package/fixtures/python_v044_demo/manifest.json +2 -1
package/fixtures/python_v050_cli/alt_capital_impact.json +30 -0
package/fixtures/python_v050_cli/alt_ecpt_lift.json +85 -0
package/fixtures/python_v050_cli/alt_liquidity_to_paths.json +85 -0
package/fixtures/python_v050_cli/alt_receiver_lift.json +15 -0
package/fixtures/python_v050_cli/bit_certificate.json +15 -0
package/fixtures/python_v050_cli/bit_compare_baseline.json +24 -0
package/fixtures/python_v050_cli/bit_diagnose.json +95 -0
package/fixtures/python_v050_cli/bit_invert.json +235 -0
package/fixtures/python_v050_cli/bit_mec.json +18 -0
package/fixtures/python_v050_cli/ecology_effective_graph.json +178 -0
package/fixtures/python_v050_cli/ecology_execution_available_paths.json +88 -0
package/fixtures/python_v050_cli/manifest.json +48 -0
package/fixtures/python_v050_cli/phase_lab_certify.json +443 -0
package/fixtures/python_v050_cli/phase_lab_closure.json +85 -0
package/fixtures/python_v050_cli/phase_lab_compare_window.json +24 -0
package/fixtures/python_v050_cli/phase_lab_executable_paths.json +88 -0
package/fixtures/python_v050_cli/phase_lab_graph.json +178 -0
package/fixtures/python_v050_cli/phase_lab_ingest_1.json +105 -0
package/fixtures/python_v050_cli/phase_lab_ingest_2.json +109 -0
package/fixtures/python_v050_cli/phase_lab_init.json +20 -0
package/fixtures/python_v050_cli/phase_lab_list_windows.json +63 -0
package/fixtures/python_v050_cli/phase_lab_observe.json +108 -0
package/fixtures/python_v050_cli/phase_lab_threshold_status.json +164 -0
package/fixtures/python_v050_cli/sqot_diagnose_queue.json +38 -0
package/fixtures/python_v050_cli/sqot_quarantine.json +7 -0
package/fixtures/python_v050_cli/sqot_rebalance.json +19 -0
package/fixtures/python_v050_cli/sqot_reserve_check.json +20 -0
package/fixtures/python_v050_cli/sqot_salience_obstruction.json +19 -0
package/fixtures/python_v050_cli/trc_action_boundary.json +451 -0
package/fixtures/python_v050_cli/trc_tool_trace.json +221 -0
package/fixtures/python_v050_cli/trc_trace_adapter.json +221 -0
package/fixtures/python_v050_demo/asi_proxy_development.json +15 -0
package/fixtures/python_v050_demo/certificate_abstain.example.json +39 -0
package/fixtures/python_v050_demo/closure_report.example.json +39 -0
package/fixtures/python_v050_demo/effective_graph.example.json +112 -0
package/fixtures/python_v050_demo/executable_paths.example.json +20 -0
package/fixtures/python_v050_demo/phase_window_observation.example.json +61 -0
package/fixtures/python_v050_demo/runtime_report_1.json +19 -0
package/fixtures/python_v050_demo/runtime_report_2.json +14 -0
package/fixtures/python_v050_demo/threshold_status.example.json +29 -0
package/fixtures/python_v050_snapshots/manifest.json +39 -0
package/fixtures/python_v050_snapshots/snapshot_list.json +112 -0
package/fixtures/python_v050_snapshots/snapshot_routes.json +926 -0
package/fixtures/python_v050_snapshots/snapshot_show_alt.json +6830 -0
package/fixtures/python_v050_snapshots/snapshot_show_bit.json +594 -0
package/fixtures/python_v050_snapshots/snapshot_show_ecpt.json +2894 -0
package/fixtures/python_v050_snapshots/snapshot_show_sqot.json +2392 -0
package/fixtures/python_v050_snapshots/snapshot_show_trc.json +3037 -0
package/fixtures/python_v050_snapshots/snapshot_verify_alt.json +10 -0
package/fixtures/python_v050_snapshots/snapshot_verify_bit.json +10 -0
package/fixtures/python_v050_snapshots/snapshot_verify_ecpt.json +10 -0
package/fixtures/python_v050_snapshots/snapshot_verify_sqot.json +10 -0
package/fixtures/python_v050_snapshots/snapshot_verify_trc.json +10 -0
package/package.json +45 -3
package/schemas/ASIProxyThresholdSpec.schema.json +72 -0
package/schemas/ASIProxyThresholdStatus.schema.json +512 -0
package/schemas/ActionBoundaryRequirement.schema.json +28 -0
package/schemas/ActivationGainEstimate.schema.json +41 -0
package/schemas/AltEcptLiftReport.schema.json +400 -0
package/schemas/AltLiftBlocker.schema.json +34 -0
package/schemas/AttentionBudgetLedger.schema.json +41 -0
package/schemas/AutocatalyticClosureReport.schema.json +408 -0
package/schemas/AutocatalyticClosureWitness.schema.json +22 -139
package/schemas/BasinReachabilityProxy.schema.json +21 -0
package/schemas/BottleneckClassDiagnosis.schema.json +115 -0
package/schemas/BottleneckInversionCandidate.schema.json +249 -0
package/schemas/BottleneckInversionReport.schema.json +499 -0
package/schemas/CapabilityExpressionPath.schema.json +45 -0
package/schemas/CapitalToPathContribution.schema.json +53 -0
package/schemas/ClosureAbstentionReason.schema.json +25 -0
package/schemas/ClosureCertificateCandidate.schema.json +109 -0
package/schemas/ClosureDefect.schema.json +28 -0
package/schemas/ClosureSupportHyperpath.schema.json +44 -0
package/schemas/CollectivePhaseAbstentionReport.schema.json +591 -0
package/schemas/CollectivePhaseCertificateCandidate.schema.json +688 -0
package/schemas/CrossContextTransferWitness.schema.json +46 -0
package/schemas/DiagnosticReserveReport.schema.json +87 -0
package/schemas/DownstreamSearchCostDelta.schema.json +46 -0
package/schemas/EcologyAutocatalyticClosureWitness.schema.json +187 -0
package/schemas/EffectiveGraphResidualSummary.schema.json +38 -0
package/schemas/EffectivePacketEdge.schema.json +135 -0
package/schemas/EffectivePacketEligibility.schema.json +84 -0
package/schemas/EffectivePacketGraph.schema.json +461 -0
package/schemas/EffectivePacketGraphBuildReport.schema.json +521 -0
package/schemas/EffectivePacketNode.schema.json +199 -0
package/schemas/ExecutableClosureWitness.schema.json +47 -0
package/schemas/ExecutablePathDensityReport.schema.json +314 -0
package/schemas/ExecutionAuthorityStatus.schema.json +28 -0
package/schemas/ExecutionAvailableHyperpath.schema.json +201 -0
package/schemas/ExecutionPathDefect.schema.json +28 -0
package/schemas/ExecutionPathWitness.schema.json +44 -0
package/schemas/FalseLiquidityLoad.schema.json +21 -0
package/schemas/GeneralIntakePolicy.schema.json +1 -1
package/schemas/InversionCertificate.schema.json +56 -0
package/schemas/LiquidityToClosureContribution.schema.json +53 -0
package/schemas/MinimalEnablingCondition.schema.json +48 -0
package/schemas/PacketContributionStatus.schema.json +32 -0
package/schemas/PacketQuarantineDecision.schema.json +50 -0
package/schemas/PhaseCertificateDefect.schema.json +33 -0
package/schemas/PhaseComponentObservation.schema.json +39 -0
package/schemas/PhaseLabEvent.schema.json +123 -0
package/schemas/PhaseLabExportManifest.schema.json +127 -0
package/schemas/PhaseLabIngestReport.schema.json +344 -0
package/schemas/PhaseLabStoreManifest.schema.json +73 -0
package/schemas/PhaseLabWindowIndex.schema.json +78 -0
package/schemas/PhaseThresholdStatus.schema.json +51 -0
package/schemas/PhaseWindow.schema.json +31 -0
package/schemas/PhaseWindowComparison.schema.json +67 -0
package/schemas/PhaseWindowObservation.schema.json +353 -0
package/schemas/PostInversionAuditPlan.schema.json +38 -0
package/schemas/ProductiveClosureWitness.schema.json +49 -0
package/schemas/ProvenanceManifest.schema.json +1 -1
package/schemas/QueueOccupationReport.schema.json +156 -0
package/schemas/QueueRebalancePlan.schema.json +114 -0
package/schemas/ReceiverContextSupport.schema.json +23 -0
package/schemas/ReceiverLiquidityLift.schema.json +58 -0
package/schemas/ReleaseArtifactManifest.schema.json +1 -1
package/schemas/ReversibleSalienceSovereigntyCertificate.schema.json +53 -0
package/schemas/RollbackOrDeactivationPlan.schema.json +38 -0
package/schemas/SBOMManifest.schema.json +1 -1
package/schemas/SalienceObstructionDiagnosis.schema.json +55 -0
package/schemas/SalienceObstructionLoad.schema.json +21 -0
package/schemas/SemanticEdgeEvidence.schema.json +40 -0
package/schemas/TraceAdapterReport.schema.json +405 -0
package/schemas/TraceFrontierDebt.schema.json +43 -0
package/schemas/TraceNormalForm.schema.json +181 -0
package/schemas/TraceToleranceLedger.schema.json +29 -0
package/schemas/TypedActionBoundary.schema.json +58 -0
package/schemas/TypedAgentTrace.schema.json +328 -0
package/schemas/TypedToolCallTrace.schema.json +76 -0
package/schemas/VerificationQueuePressure.schema.json +41 -0
package/schemas/VerificationThroughputWindow.schema.json +21 -0
package/schemas/WasteLoad.schema.json +21 -0
package/schemas/WebFetchPolicy.schema.json +1 -1
package/schemas/bundle.schema.json +11854 -2075
package/schemas/index.json +445 -0
package/schemas/schema-digest.json +733 -289

package/fixtures/python_v050_snapshots/snapshot_show_ecpt.json ADDED Viewed

@@ -0,0 +1,2894 @@
+{
+  "artifact": "Executable Capability Percolation Theory.tex",
+  "artifact_key": "ecpt",
+  "attribution": {
+    "author": "K. Takahashi",
+    "derived_from": "canonical TeX metadata extraction; TeX/PDF source is not vendored",
+    "doi": "10.5281/zenodo.20535654",
+    "license_id": "cc-by-4.0",
+    "source_tex_md5": "c4614418ce96155c605a5b0337b3e99c",
+    "source_tex_sha256": null,
+    "title": "Executable Capability Percolation Theory",
+    "year": 2026
+  },
+  "claims": 35,
+  "coverage_counts": {
+    "external_obligation": 30,
+    "implemented_checker": 48,
+    "implemented_constructive": 18,
+    "implemented_schema": 18,
+    "partial": 0,
+    "unsupported": 0
+  },
+  "coverage_delta": {
+    "external_obligation_total": 30,
+    "implemented_total": 84,
+    "unimplemented_total": 30,
+    "unsupported_total": 0
+  },
+  "definitions": 79,
+  "external_obligation_catalog": {
+    "artifact": "Executable Capability Percolation Theory.tex",
+    "category_summary": {
+      "ecpt-bridge-reserve": 6,
+      "ecpt-ecology-ontology": 3,
+      "ecpt-economics-policy": 6,
+      "ecpt-generator-limit": 5,
+      "ecpt-proxy-target": 3,
+      "ecpt-speculative-channel": 4,
+      "ecpt-trace-diagnostic": 1,
+      "numerical-envelope": 2
+    },
+    "obligations": [
+      {
+        "accepted_evidence_kind": [
+          "diagnostic-projection-certificate",
+          "residual-trace-ledger",
+          "trace-complex-audit"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "diagnostic-projection-unverified",
+          "residual-trace-ledger-incomplete",
+          "trace-complex-audit-missing",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "diagnostic-projection-unverified",
+          "residual-trace-ledger-incomplete",
+          "trace-complex-audit-missing"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:15",
+        "label": "Auxiliary trace-complex diagnostic",
+        "obligation_category": "ecpt-trace-diagnostic",
+        "proof_obligation_ids": [
+          "obligation:definition:15"
+        ],
+        "residual_coordinates": [
+          "residual:definition:15"
+        ],
+        "residual_policy": "charge-trace-diagnostic-residual-until-projection-certified",
+        "safe_default": "diagnostic-with-trace-complex-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.trace_complex.verify_diagnostic_projection"
+      },
+      {
+        "accepted_evidence_kind": [
+          "execution-availability-audit",
+          "policy-counterfactual-report",
+          "value-bound"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "execution-availability-unverified",
+          "policy-counterfactual-missing",
+          "value-bound-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "execution-availability-unverified",
+          "policy-counterfactual-missing",
+          "value-bound-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:18",
+        "label": "Accumulation, availability, liquidity, and execution availability",
+        "obligation_category": "ecpt-economics-policy",
+        "proof_obligation_ids": [
+          "obligation:definition:18"
+        ],
+        "residual_coordinates": [
+          "residual:definition:18"
+        ],
+        "residual_policy": "charge-policy-residual-until-counterfactual-accepted",
+        "safe_default": "diagnostic-with-policy-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.policy.verify_execution_policy"
+      },
+      {
+        "accepted_evidence_kind": [
+          "repair-route-certificate",
+          "speculative-channel-audit",
+          "synergy-lower-bound"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "repair-route-missing",
+          "speculative-channel-unverified",
+          "synergy-bound-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "repair-route-missing",
+          "speculative-channel-unverified",
+          "synergy-bound-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:31",
+        "label": "Speculative execution channel",
+        "obligation_category": "ecpt-speculative-channel",
+        "proof_obligation_ids": [
+          "obligation:definition:31"
+        ],
+        "residual_coordinates": [
+          "residual:definition:31"
+        ],
+        "residual_policy": "charge-speculative-residual-until-channel-certified",
+        "safe_default": "diagnostic-with-speculative-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.speculative.verify_channel_and_repair"
+      },
+      {
+        "accepted_evidence_kind": [
+          "abstraction-map",
+          "domain-semantics-report",
+          "simulation-refinement-witness"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "abstraction-refinement-unverified",
+          "domain-semantics-missing",
+          "ontology-extension-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "abstraction-refinement-unverified",
+          "domain-semantics-missing",
+          "ontology-extension-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:37",
+        "label": "Concrete ecology semantics",
+        "obligation_category": "ecpt-ecology-ontology",
+        "proof_obligation_ids": [
+          "obligation:definition:37"
+        ],
+        "residual_coordinates": [
+          "residual:definition:37"
+        ],
+        "residual_policy": "charge-abstraction-residual-until-domain-witness-accepted",
+        "safe_default": "diagnostic-with-abstraction-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.ecology.verify_domain_abstraction"
+      },
+      {
+        "accepted_evidence_kind": [
+          "abstraction-map",
+          "domain-semantics-report",
+          "simulation-refinement-witness"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "abstraction-refinement-unverified",
+          "domain-semantics-missing",
+          "ontology-extension-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "abstraction-refinement-unverified",
+          "domain-semantics-missing",
+          "ontology-extension-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:38",
+        "label": "Sound finite abstraction",
+        "obligation_category": "ecpt-ecology-ontology",
+        "proof_obligation_ids": [
+          "obligation:definition:38"
+        ],
+        "residual_coordinates": [
+          "residual:definition:38"
+        ],
+        "residual_policy": "charge-abstraction-residual-until-domain-witness-accepted",
+        "safe_default": "diagnostic-with-abstraction-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.ecology.verify_domain_abstraction"
+      },
+      {
+        "accepted_evidence_kind": [
+          "abstraction-map",
+          "domain-semantics-report",
+          "simulation-refinement-witness"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "abstraction-refinement-unverified",
+          "domain-semantics-missing",
+          "ontology-extension-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "abstraction-refinement-unverified",
+          "domain-semantics-missing",
+          "ontology-extension-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "prop:abstraction-soundness",
+        "label": "Abstraction soundness",
+        "obligation_category": "ecpt-ecology-ontology",
+        "proof_obligation_ids": [
+          "obligation:prop:abstraction-soundness"
+        ],
+        "residual_coordinates": [
+          "residual:prop:abstraction-soundness"
+        ],
+        "residual_policy": "charge-abstraction-residual-until-domain-witness-accepted",
+        "safe_default": "diagnostic-with-abstraction-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.ecology.verify_domain_abstraction"
+      },
+      {
+        "accepted_evidence_kind": [
+          "finite-bound-table",
+          "residual-envelope-proof",
+          "tail-bound-certificate"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "finite-envelope-proof-missing",
+          "residual-bound-not-certified",
+          "tail-bound-unverified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "finite-envelope-proof-missing",
+          "residual-bound-not-certified",
+          "tail-bound-unverified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "cor:light-tail-exponential-witness",
+        "label": "Light-tail exponential witness",
+        "obligation_category": "numerical-envelope",
+        "proof_obligation_ids": [
+          "obligation:cor:light-tail-exponential-witness"
+        ],
+        "residual_coordinates": [
+          "residual:cor:light-tail-exponential-witness"
+        ],
+        "residual_policy": "charge-envelope-residual-until-bound-certified",
+        "safe_default": "diagnostic-with-envelope-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "core.adapters.envelope.verify_finite_bound"
+      },
+      {
+        "accepted_evidence_kind": [
+          "execution-availability-audit",
+          "policy-counterfactual-report",
+          "value-bound"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "execution-availability-unverified",
+          "policy-counterfactual-missing",
+          "value-bound-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "execution-availability-unverified",
+          "policy-counterfactual-missing",
+          "value-bound-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:48",
+        "label": "Natural accelerator policy",
+        "obligation_category": "ecpt-economics-policy",
+        "proof_obligation_ids": [
+          "obligation:definition:48"
+        ],
+        "residual_coordinates": [
+          "residual:definition:48"
+        ],
+        "residual_policy": "charge-policy-residual-until-counterfactual-accepted",
+        "safe_default": "diagnostic-with-policy-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.policy.verify_execution_policy"
+      },
+      {
+        "accepted_evidence_kind": [
+          "execution-availability-audit",
+          "policy-counterfactual-report",
+          "value-bound"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "execution-availability-unverified",
+          "policy-counterfactual-missing",
+          "value-bound-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "execution-availability-unverified",
+          "policy-counterfactual-missing",
+          "value-bound-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:49",
+        "label": "Search-friction ledger",
+        "obligation_category": "ecpt-economics-policy",
+        "proof_obligation_ids": [
+          "obligation:definition:49"
+        ],
+        "residual_coordinates": [
+          "residual:definition:49"
+        ],
+        "residual_policy": "charge-policy-residual-until-counterfactual-accepted",
+        "safe_default": "diagnostic-with-policy-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.policy.verify_execution_policy"
+      },
+      {
+        "accepted_evidence_kind": [
+          "execution-availability-audit",
+          "policy-counterfactual-report",
+          "value-bound"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "execution-availability-unverified",
+          "policy-counterfactual-missing",
+          "value-bound-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "execution-availability-unverified",
+          "policy-counterfactual-missing",
+          "value-bound-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:50",
+        "label": "Friction-adjusted action value",
+        "obligation_category": "ecpt-economics-policy",
+        "proof_obligation_ids": [
+          "obligation:definition:50"
+        ],
+        "residual_coordinates": [
+          "residual:definition:50"
+        ],
+        "residual_policy": "charge-policy-residual-until-counterfactual-accepted",
+        "safe_default": "diagnostic-with-policy-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.policy.verify_execution_policy"
+      },
+      {
+        "accepted_evidence_kind": [
+          "execution-availability-audit",
+          "policy-counterfactual-report",
+          "value-bound"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "execution-availability-unverified",
+          "policy-counterfactual-missing",
+          "value-bound-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "execution-availability-unverified",
+          "policy-counterfactual-missing",
+          "value-bound-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "lem:evsi-admission",
+        "label": "EVSI admission",
+        "obligation_category": "ecpt-economics-policy",
+        "proof_obligation_ids": [
+          "obligation:lem:evsi-admission"
+        ],
+        "residual_coordinates": [
+          "residual:lem:evsi-admission"
+        ],
+        "residual_policy": "charge-policy-residual-until-counterfactual-accepted",
+        "safe_default": "diagnostic-with-policy-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.policy.verify_execution_policy"
+      },
+      {
+        "accepted_evidence_kind": [
+          "protocol-comparison-certificate",
+          "proxy-grounding-report",
+          "target-contract"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "protocol-comparison-not-certified",
+          "proxy-grounding-missing",
+          "target-contract-unaccepted",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "protocol-comparison-not-certified",
+          "proxy-grounding-missing",
+          "target-contract-unaccepted"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:51",
+        "label": "Proxy bundle",
+        "obligation_category": "ecpt-proxy-target",
+        "proof_obligation_ids": [
+          "obligation:definition:51"
+        ],
+        "residual_coordinates": [
+          "residual:definition:51"
+        ],
+        "residual_policy": "charge-proxy-target-residual-until-contract-accepted",
+        "safe_default": "diagnostic-with-proxy-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.proxy.verify_target_contract"
+      },
+      {
+        "accepted_evidence_kind": [
+          "protocol-comparison-certificate",
+          "proxy-grounding-report",
+          "target-contract"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "protocol-comparison-not-certified",
+          "proxy-grounding-missing",
+          "target-contract-unaccepted",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "protocol-comparison-not-certified",
+          "proxy-grounding-missing",
+          "target-contract-unaccepted"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:52",
+        "label": "ECPT target",
+        "obligation_category": "ecpt-proxy-target",
+        "proof_obligation_ids": [
+          "obligation:definition:52"
+        ],
+        "residual_coordinates": [
+          "residual:definition:52"
+        ],
+        "residual_policy": "charge-proxy-target-residual-until-contract-accepted",
+        "safe_default": "diagnostic-with-proxy-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.proxy.verify_target_contract"
+      },
+      {
+        "accepted_evidence_kind": [
+          "protocol-comparison-certificate",
+          "proxy-grounding-report",
+          "target-contract"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "protocol-comparison-not-certified",
+          "proxy-grounding-missing",
+          "target-contract-unaccepted",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "protocol-comparison-not-certified",
+          "proxy-grounding-missing",
+          "target-contract-unaccepted"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:54",
+        "label": "Protocol-competitive target acceleration",
+        "obligation_category": "ecpt-proxy-target",
+        "proof_obligation_ids": [
+          "obligation:definition:54"
+        ],
+        "residual_coordinates": [
+          "residual:definition:54"
+        ],
+        "residual_policy": "charge-proxy-target-residual-until-contract-accepted",
+        "safe_default": "diagnostic-with-proxy-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.proxy.verify_target_contract"
+      },
+      {
+        "accepted_evidence_kind": [
+          "repair-route-certificate",
+          "speculative-channel-audit",
+          "synergy-lower-bound"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "repair-route-missing",
+          "speculative-channel-unverified",
+          "synergy-bound-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "repair-route-missing",
+          "speculative-channel-unverified",
+          "synergy-bound-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:57",
+        "label": "Paralysis and repair route",
+        "obligation_category": "ecpt-speculative-channel",
+        "proof_obligation_ids": [
+          "obligation:definition:57"
+        ],
+        "residual_coordinates": [
+          "residual:definition:57"
+        ],
+        "residual_policy": "charge-speculative-residual-until-channel-certified",
+        "safe_default": "diagnostic-with-speculative-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.speculative.verify_channel_and_repair"
+      },
+      {
+        "accepted_evidence_kind": [
+          "finite-envelope",
+          "generator-identification-report",
+          "transition-kernel-audit"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "generator-calibration-missing",
+          "limit-envelope-unverified",
+          "transition-kernel-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "generator-calibration-missing",
+          "limit-envelope-unverified",
+          "transition-kernel-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "cor:scalar-bellman",
+        "label": "Scalar Bellman interface",
+        "obligation_category": "ecpt-generator-limit",
+        "proof_obligation_ids": [
+          "obligation:cor:scalar-bellman"
+        ],
+        "residual_coordinates": [
+          "residual:cor:scalar-bellman"
+        ],
+        "residual_policy": "charge-generator-limit-residual-until-calibration-accepted",
+        "safe_default": "diagnostic-with-generator-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.generators.verify_limit_envelope"
+      },
+      {
+        "accepted_evidence_kind": [
+          "finite-envelope",
+          "generator-identification-report",
+          "transition-kernel-audit"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "generator-calibration-missing",
+          "limit-envelope-unverified",
+          "transition-kernel-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "generator-calibration-missing",
+          "limit-envelope-unverified",
+          "transition-kernel-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "def:markov-additive-raf",
+        "label": "Speculative RAF with Markov additive debt",
+        "obligation_category": "ecpt-generator-limit",
+        "proof_obligation_ids": [
+          "obligation:def:markov-additive-raf"
+        ],
+        "residual_coordinates": [
+          "residual:def:markov-additive-raf"
+        ],
+        "residual_policy": "charge-generator-limit-residual-until-calibration-accepted",
+        "safe_default": "diagnostic-with-generator-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.generators.verify_limit_envelope"
+      },
+      {
+        "accepted_evidence_kind": [
+          "repair-route-certificate",
+          "speculative-channel-audit",
+          "synergy-lower-bound"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "repair-route-missing",
+          "speculative-channel-unverified",
+          "synergy-bound-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "repair-route-missing",
+          "speculative-channel-unverified",
+          "synergy-bound-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:62",
+        "label": "Sparse synergy and residual certificate",
+        "obligation_category": "ecpt-speculative-channel",
+        "proof_obligation_ids": [
+          "obligation:definition:62"
+        ],
+        "residual_coordinates": [
+          "residual:definition:62"
+        ],
+        "residual_policy": "charge-speculative-residual-until-channel-certified",
+        "safe_default": "diagnostic-with-speculative-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.speculative.verify_channel_and_repair"
+      },
+      {
+        "accepted_evidence_kind": [
+          "repair-route-certificate",
+          "speculative-channel-audit",
+          "synergy-lower-bound"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "repair-route-missing",
+          "speculative-channel-unverified",
+          "synergy-bound-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "repair-route-missing",
+          "speculative-channel-unverified",
+          "synergy-bound-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "prop:sparse-synergy-lower-bound",
+        "label": "Sparse synergy lower bound",
+        "obligation_category": "ecpt-speculative-channel",
+        "proof_obligation_ids": [
+          "obligation:prop:sparse-synergy-lower-bound"
+        ],
+        "residual_coordinates": [
+          "residual:prop:sparse-synergy-lower-bound"
+        ],
+        "residual_policy": "charge-speculative-residual-until-channel-certified",
+        "safe_default": "diagnostic-with-speculative-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.speculative.verify_channel_and_repair"
+      },
+      {
+        "accepted_evidence_kind": [
+          "finite-bound-table",
+          "residual-envelope-proof",
+          "tail-bound-certificate"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "finite-envelope-proof-missing",
+          "residual-bound-not-certified",
+          "tail-bound-unverified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "finite-envelope-proof-missing",
+          "residual-bound-not-certified",
+          "tail-bound-unverified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "cor:linear-growth-lower-bound",
+        "label": "Linear growth lower bound",
+        "obligation_category": "numerical-envelope",
+        "proof_obligation_ids": [
+          "obligation:cor:linear-growth-lower-bound"
+        ],
+        "residual_coordinates": [
+          "residual:cor:linear-growth-lower-bound"
+        ],
+        "residual_policy": "charge-envelope-residual-until-bound-certified",
+        "safe_default": "diagnostic-with-envelope-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "core.adapters.envelope.verify_finite_bound"
+      },
+      {
+        "accepted_evidence_kind": [
+          "finite-envelope",
+          "generator-identification-report",
+          "transition-kernel-audit"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "generator-calibration-missing",
+          "limit-envelope-unverified",
+          "transition-kernel-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "generator-calibration-missing",
+          "limit-envelope-unverified",
+          "transition-kernel-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "def:density-dependent-chain",
+        "label": "Regularized density-dependent ECPT family",
+        "obligation_category": "ecpt-generator-limit",
+        "proof_obligation_ids": [
+          "obligation:def:density-dependent-chain"
+        ],
+        "residual_coordinates": [
+          "residual:def:density-dependent-chain"
+        ],
+        "residual_policy": "charge-generator-limit-residual-until-calibration-accepted",
+        "safe_default": "diagnostic-with-generator-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.generators.verify_limit_envelope"
+      },
+      {
+        "accepted_evidence_kind": [
+          "finite-envelope",
+          "generator-identification-report",
+          "transition-kernel-audit"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "generator-calibration-missing",
+          "limit-envelope-unverified",
+          "transition-kernel-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "generator-calibration-missing",
+          "limit-envelope-unverified",
+          "transition-kernel-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "def:identified-generator-calibration",
+        "label": "Intervention-identified generator calibration certificate",
+        "obligation_category": "ecpt-generator-limit",
+        "proof_obligation_ids": [
+          "obligation:def:identified-generator-calibration"
+        ],
+        "residual_coordinates": [
+          "residual:def:identified-generator-calibration"
+        ],
+        "residual_policy": "charge-generator-limit-residual-until-calibration-accepted",
+        "safe_default": "diagnostic-with-generator-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.generators.verify_limit_envelope"
+      },
+      {
+        "accepted_evidence_kind": [
+          "finite-envelope",
+          "generator-identification-report",
+          "transition-kernel-audit"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "generator-calibration-missing",
+          "limit-envelope-unverified",
+          "transition-kernel-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required",
+          "limit-envelope-or-generator-calibration-required"
+        ],
+        "failure_modes": [
+          "generator-calibration-missing",
+          "limit-envelope-unverified",
+          "transition-kernel-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:70",
+        "label": "Regularized macroscopic percolation envelope",
+        "obligation_category": "ecpt-generator-limit",
+        "proof_obligation_ids": [
+          "obligation:definition:70"
+        ],
+        "residual_coordinates": [
+          "residual:definition:70"
+        ],
+        "residual_policy": "charge-generator-limit-residual-until-calibration-accepted",
+        "safe_default": "diagnostic-with-generator-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.generators.verify_limit_envelope"
+      },
+      {
+        "accepted_evidence_kind": [
+          "bridge-map",
+          "machine-readable-capsule-audit",
+          "reserve-invariance-proof"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "bridge-map-unverified",
+          "capsule-projection-not-certified",
+          "reserve-invariance-unaccepted",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "bridge-map-unverified",
+          "capsule-projection-not-certified",
+          "reserve-invariance-unaccepted"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:71",
+        "label": "ALT-compatible packet",
+        "obligation_category": "ecpt-bridge-reserve",
+        "proof_obligation_ids": [
+          "obligation:definition:71"
+        ],
+        "residual_coordinates": [
+          "residual:definition:71"
+        ],
+        "residual_policy": "charge-bridge-residual-until-cross-theory-proof-accepted",
+        "safe_default": "diagnostic-with-bridge-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.bridge.verify_cross_theory_bridge"
+      },
+      {
+        "accepted_evidence_kind": [
+          "execution-availability-audit",
+          "policy-counterfactual-report",
+          "value-bound"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "execution-availability-unverified",
+          "policy-counterfactual-missing",
+          "value-bound-not-certified",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "execution-availability-unverified",
+          "policy-counterfactual-missing",
+          "value-bound-not-certified"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:72",
+        "label": "Liquidity bridge",
+        "obligation_category": "ecpt-economics-policy",
+        "proof_obligation_ids": [
+          "obligation:definition:72"
+        ],
+        "residual_coordinates": [
+          "residual:definition:72"
+        ],
+        "residual_policy": "charge-policy-residual-until-counterfactual-accepted",
+        "safe_default": "diagnostic-with-policy-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.policy.verify_execution_policy"
+      },
+      {
+        "accepted_evidence_kind": [
+          "bridge-map",
+          "machine-readable-capsule-audit",
+          "reserve-invariance-proof"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "bridge-map-unverified",
+          "capsule-projection-not-certified",
+          "reserve-invariance-unaccepted",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "bridge-map-unverified",
+          "capsule-projection-not-certified",
+          "reserve-invariance-unaccepted"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "prop:alt-lift",
+        "label": "ALT lift",
+        "obligation_category": "ecpt-bridge-reserve",
+        "proof_obligation_ids": [
+          "obligation:prop:alt-lift"
+        ],
+        "residual_coordinates": [
+          "residual:prop:alt-lift"
+        ],
+        "residual_policy": "charge-bridge-residual-until-cross-theory-proof-accepted",
+        "safe_default": "diagnostic-with-bridge-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.bridge.verify_cross_theory_bridge"
+      },
+      {
+        "accepted_evidence_kind": [
+          "bridge-map",
+          "machine-readable-capsule-audit",
+          "reserve-invariance-proof"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "bridge-map-unverified",
+          "capsule-projection-not-certified",
+          "reserve-invariance-unaccepted",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "bridge-map-unverified",
+          "capsule-projection-not-certified",
+          "reserve-invariance-unaccepted"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "definition:73",
+        "label": "SQOT-compatible reserve certificate",
+        "obligation_category": "ecpt-bridge-reserve",
+        "proof_obligation_ids": [
+          "obligation:definition:73"
+        ],
+        "residual_coordinates": [
+          "residual:definition:73"
+        ],
+        "residual_policy": "charge-bridge-residual-until-cross-theory-proof-accepted",
+        "safe_default": "diagnostic-with-bridge-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.bridge.verify_cross_theory_bridge"
+      },
+      {
+        "accepted_evidence_kind": [
+          "bridge-map",
+          "machine-readable-capsule-audit",
+          "reserve-invariance-proof"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "bridge-map-unverified",
+          "capsule-projection-not-certified",
+          "reserve-invariance-unaccepted",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "bridge-map-unverified",
+          "capsule-projection-not-certified",
+          "reserve-invariance-unaccepted"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "prop:sqot-reserve-invariance",
+        "label": "SQOT reserve invariance",
+        "obligation_category": "ecpt-bridge-reserve",
+        "proof_obligation_ids": [
+          "obligation:prop:sqot-reserve-invariance"
+        ],
+        "residual_coordinates": [
+          "residual:prop:sqot-reserve-invariance"
+        ],
+        "residual_policy": "charge-bridge-residual-until-cross-theory-proof-accepted",
+        "safe_default": "diagnostic-with-bridge-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.bridge.verify_cross_theory_bridge"
+      },
+      {
+        "accepted_evidence_kind": [
+          "bridge-map",
+          "machine-readable-capsule-audit",
+          "reserve-invariance-proof"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "bridge-map-unverified",
+          "capsule-projection-not-certified",
+          "reserve-invariance-unaccepted",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "bridge-map-unverified",
+          "capsule-projection-not-certified",
+          "reserve-invariance-unaccepted"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "def:publication-capsule",
+        "label": "Publication and machine-readable capsule",
+        "obligation_category": "ecpt-bridge-reserve",
+        "proof_obligation_ids": [
+          "obligation:def:publication-capsule"
+        ],
+        "residual_coordinates": [
+          "residual:def:publication-capsule"
+        ],
+        "residual_policy": "charge-bridge-residual-until-cross-theory-proof-accepted",
+        "safe_default": "diagnostic-with-bridge-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.bridge.verify_cross_theory_bridge"
+      },
+      {
+        "accepted_evidence_kind": [
+          "bridge-map",
+          "machine-readable-capsule-audit",
+          "reserve-invariance-proof"
+        ],
+        "artifact": "Executable Capability Percolation Theory.tex",
+        "checker_ref": null,
+        "checker_refs": [],
+        "coverage_status": "external_obligation",
+        "external_failure_modes": [
+          "bridge-map-unverified",
+          "capsule-projection-not-certified",
+          "reserve-invariance-unaccepted",
+          "no-implicit-settled-promotion",
+          "external-verifier-hook-required"
+        ],
+        "failure_modes": [
+          "bridge-map-unverified",
+          "capsule-projection-not-certified",
+          "reserve-invariance-unaccepted"
+        ],
+        "implementation_maturity": "unsupported_no_interface",
+        "implementation_ref": "core.ExternalProofObligation",
+        "implementation_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "item_id": "thm:protocol-relative-soundness",
+        "label": "Protocol-relative soundness",
+        "obligation_category": "ecpt-bridge-reserve",
+        "proof_obligation_ids": [
+          "obligation:thm:protocol-relative-soundness"
+        ],
+        "residual_coordinates": [
+          "residual:thm:protocol-relative-soundness"
+        ],
+        "residual_policy": "charge-bridge-residual-until-cross-theory-proof-accepted",
+        "safe_default": "diagnostic-with-bridge-obligation",
+        "schema_ref": "core.ExternalProofObligation",
+        "schema_refs": [
+          "core.ExternalProofObligation"
+        ],
+        "verifier_contract": {
+          "input": "ExternalProofObligation plus domain evidence matching accepted_evidence_kind",
+          "output": "ExternalVerifierHook with accepted/rejected obligation ids",
+          "promotion_rule": "accepted hooks may discharge obligations but cannot bypass finite checker status derivation"
+        },
+        "verifier_route": "ecpt.adapters.bridge.verify_cross_theory_bridge"
+      }
+    ],
+    "verifier_route_summary": {
+      "core.adapters.envelope.verify_finite_bound": 2,
+      "ecpt.adapters.bridge.verify_cross_theory_bridge": 6,
+      "ecpt.adapters.ecology.verify_domain_abstraction": 3,
+      "ecpt.adapters.generators.verify_limit_envelope": 5,
+      "ecpt.adapters.policy.verify_execution_policy": 6,
+      "ecpt.adapters.proxy.verify_target_contract": 3,
+      "ecpt.adapters.speculative.verify_channel_and_repair": 4,
+      "ecpt.adapters.trace_complex.verify_diagnostic_projection": 1
+    }
+  },
+  "external_obligation_category_summary": {
+    "ecpt-bridge-reserve": 6,
+    "ecpt-ecology-ontology": 3,
+    "ecpt-economics-policy": 6,
+    "ecpt-generator-limit": 5,
+    "ecpt-proxy-target": 3,
+    "ecpt-speculative-channel": 4,
+    "ecpt-trace-diagnostic": 1,
+    "numerical-envelope": 2
+  },
+  "external_verifier_route_summary": {
+    "core.adapters.envelope.verify_finite_bound": 2,
+    "ecpt.adapters.bridge.verify_cross_theory_bridge": 6,
+    "ecpt.adapters.ecology.verify_domain_abstraction": 3,
+    "ecpt.adapters.generators.verify_limit_envelope": 5,
+    "ecpt.adapters.policy.verify_execution_policy": 6,
+    "ecpt.adapters.proxy.verify_target_contract": 3,
+    "ecpt.adapters.speculative.verify_channel_and_repair": 4,
+    "ecpt.adapters.trace_complex.verify_diagnostic_projection": 1
+  },
+  "item_mappings": [
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.ObservationProtocol"
+      ],
+      "item_id": "definition:1",
+      "label": "Observation protocol",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.ConstraintFrame"
+      ],
+      "item_id": "definition:2",
+      "label": "Constraint frame",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.DiagnosticOrder"
+      ],
+      "item_id": "definition:3",
+      "label": "Diagnostic order",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_admissibility_grade"
+      ],
+      "item_id": "definition:4",
+      "label": "Admissibility grade",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.CertificateShell"
+      ],
+      "item_id": "definition:5",
+      "label": "Operable certificate shell",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.TargetValidityStatus"
+      ],
+      "item_id": "definition:6",
+      "label": "Target-validity status",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.ObservationProtocol"
+      ],
+      "item_id": "definition:7",
+      "label": "Baseline protocol",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_protocol_functor_certificate"
+      ],
+      "item_id": "definition:8",
+      "label": "Protocol functor and ontology-extension certificate",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_protocol_functor_certificate"
+      ],
+      "item_id": "prop:protocol-functor-soundness",
+      "label": "Protocol-functor soundness",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_finite_phase_control_certificate"
+      ],
+      "item_id": "def:phase-control-system",
+      "label": "Finite and thermodynamic phase-control system",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_phase_control_envelope"
+      ],
+      "item_id": "definition:10",
+      "label": "Control surface and phase response",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.CapabilityPacket"
+      ],
+      "item_id": "definition:11",
+      "label": "Capability packet",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_capability_state_vector"
+      ],
+      "item_id": "definition:12",
+      "label": "Capability-state vector",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.FiniteTraceLaw"
+      ],
+      "item_id": "definition:13",
+      "label": "Finite trace law",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.split_certified_quotient_error"
+      ],
+      "item_id": "def:variational-relaxation-quotient",
+      "label": "Split-certified empirical quotient",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.split_certified_quotient_error"
+      ],
+      "item_id": "proposition:2",
+      "label": "Finite quotient construction interface",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:15",
+      "label": "Auxiliary trace-complex diagnostic",
+      "obligation_category": "ecpt-trace-diagnostic",
+      "verifier_route": "ecpt.adapters.trace_complex.verify_diagnostic_projection"
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_capability_state_vector"
+      ],
+      "item_id": "definition:16",
+      "label": "Empirical relaxed density and duplicate mass",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.split_certified_quotient_error"
+      ],
+      "item_id": "def:boundary-aware-quotient",
+      "label": "Split-certified boundary-aware quotient witness",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:18",
+      "label": "Accumulation, availability, liquidity, and execution availability",
+      "obligation_category": "ecpt-economics-policy",
+      "verifier_route": "ecpt.adapters.policy.verify_execution_policy"
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.split_certified_quotient_error"
+      ],
+      "item_id": "thm:boundary-aware-quotient",
+      "label": "Split-certified boundary-aware quotient error",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_capability_state_vector"
+      ],
+      "item_id": "lem:no-probabilistic-duplicate-inflation",
+      "label": "No probabilistic duplicate inflation",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_packet_atlas"
+      ],
+      "item_id": "definition:19",
+      "label": "Stratified statistical packet atlas",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_information_projection_quotient"
+      ],
+      "item_id": "definition:20",
+      "label": "Stratified information-projection quotient",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_information_projection_quotient"
+      ],
+      "item_id": "prop:information-projection-distortion",
+      "label": "Stratified information-projection distortion",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.CapabilityPacket"
+      ],
+      "item_id": "definition:21",
+      "label": "Capability packet hypergraph",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.CapabilityEdge"
+      ],
+      "item_id": "definition:22",
+      "label": "Edge types",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_constraint_frame"
+      ],
+      "item_id": "definition:23",
+      "label": "Hard-domain edge",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_activation_threshold_certificate"
+      ],
+      "item_id": "def:free-energy-activation",
+      "label": "Global free-energy activation problem",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_activation_threshold_certificate"
+      ],
+      "item_id": "prop:free-energy-activation-optimality",
+      "label": "Global free-energy activation optimality",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_activation_construction"
+      ],
+      "item_id": "def:activation-construction",
+      "label": "Activation construction certificate",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.finite_gibbs_phase_response"
+      ],
+      "item_id": "thm:finite-gibbs-phase-response",
+      "label": "Finite Gibbs phase-response",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_phase_control_envelope"
+      ],
+      "item_id": "def:phase-response-control-step",
+      "label": "Certified phase-response control step",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.finite_gibbs_phase_response"
+      ],
+      "item_id": "thm:finite-gibbs-response-control",
+      "label": "Finite Gibbs response-control improvement",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_path_law_policy"
+      ],
+      "item_id": "def:response-policy-certificate",
+      "label": "Constructed path-law response policy certificate",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_path_law_policy"
+      ],
+      "item_id": "thm:response-policy-improvement",
+      "label": "Constructed path-law response-policy improvement",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_activation_threshold_certificate"
+      ],
+      "item_id": "definition:28",
+      "label": "Activation field",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.reachable_mass"
+      ],
+      "item_id": "definition:29",
+      "label": "Activated closure law",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.reachable_mass"
+      ],
+      "item_id": "definition:30",
+      "label": "Execution-available hyperpath",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:31",
+      "label": "Speculative execution channel",
+      "obligation_category": "ecpt-speculative-channel",
+      "verifier_route": "ecpt.adapters.speculative.verify_channel_and_repair"
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_cycle_monitor"
+      ],
+      "item_id": "definition:32",
+      "label": "Seed and cyclic support",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_queue_certificate"
+      ],
+      "item_id": "definition:33",
+      "label": "Queue layer",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.CapabilityHypergraph"
+      ],
+      "item_id": "definition:34",
+      "label": "Effective packet hypergraph",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.DiagnosticOrder"
+      ],
+      "item_id": "definition:35",
+      "label": "Waste, false liquidity, obstruction, and paralysis",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_inner_viability_kernel"
+      ],
+      "item_id": "definition:36",
+      "label": "Constraint viability band",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_constraint_frame"
+      ],
+      "item_id": "prop:constraint-band-requirement",
+      "label": "Constraint-band requirement",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:37",
+      "label": "Concrete ecology semantics",
+      "obligation_category": "ecpt-ecology-ontology",
+      "verifier_route": "ecpt.adapters.ecology.verify_domain_abstraction"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:38",
+      "label": "Sound finite abstraction",
+      "obligation_category": "ecpt-ecology-ontology",
+      "verifier_route": "ecpt.adapters.ecology.verify_domain_abstraction"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "prop:abstraction-soundness",
+      "label": "Abstraction soundness",
+      "obligation_category": "ecpt-ecology-ontology",
+      "verifier_route": "ecpt.adapters.ecology.verify_domain_abstraction"
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_capability_state_vector"
+      ],
+      "item_id": "definition:39",
+      "label": "ECPT state",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_inner_viability_kernel"
+      ],
+      "item_id": "definition:40",
+      "label": "Local viability set",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.ActionGrammar"
+      ],
+      "item_id": "definition:41",
+      "label": "Action grammar",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.PostconditionObligation"
+      ],
+      "item_id": "definition:42",
+      "label": "Postcondition obligations",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_controlled_transition"
+      ],
+      "item_id": "definition:43",
+      "label": "Operable action correspondence",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_controlled_transition"
+      ],
+      "item_id": "definition:44",
+      "label": "Controlled transition",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_inner_viability_kernel"
+      ],
+      "item_id": "definition:45",
+      "label": "Exact and inner viability kernels",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_inner_viability_kernel"
+      ],
+      "item_id": "prop:inner-kernel-invariance",
+      "label": "Inner-kernel invariance",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.self_normalized_margin_risk"
+      ],
+      "item_id": "definition:46",
+      "label": "Self-normalized margin witness",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "trc.check_risk_gate"
+      ],
+      "item_id": "definition:47",
+      "label": "Risk margin process",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "trc.check_risk_gate"
+      ],
+      "item_id": "thm:self-normalized-margin-risk",
+      "label": "Self-normalized margin risk",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "cor:light-tail-exponential-witness",
+      "label": "Light-tail exponential witness",
+      "obligation_category": "numerical-envelope",
+      "verifier_route": "core.adapters.envelope.verify_finite_bound"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:48",
+      "label": "Natural accelerator policy",
+      "obligation_category": "ecpt-economics-policy",
+      "verifier_route": "ecpt.adapters.policy.verify_execution_policy"
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "trc.ExecutableTraceNormalForm"
+      ],
+      "item_id": "prop:typed-trace-accounting",
+      "label": "Typed trace accounting",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:49",
+      "label": "Search-friction ledger",
+      "obligation_category": "ecpt-economics-policy",
+      "verifier_route": "ecpt.adapters.policy.verify_execution_policy"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:50",
+      "label": "Friction-adjusted action value",
+      "obligation_category": "ecpt-economics-policy",
+      "verifier_route": "ecpt.adapters.policy.verify_execution_policy"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "lem:evsi-admission",
+      "label": "EVSI admission",
+      "obligation_category": "ecpt-economics-policy",
+      "verifier_route": "ecpt.adapters.policy.verify_execution_policy"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:51",
+      "label": "Proxy bundle",
+      "obligation_category": "ecpt-proxy-target",
+      "verifier_route": "ecpt.adapters.proxy.verify_target_contract"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:52",
+      "label": "ECPT target",
+      "obligation_category": "ecpt-proxy-target",
+      "verifier_route": "ecpt.adapters.proxy.verify_target_contract"
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.hitting_time_acceleration"
+      ],
+      "item_id": "definition:53",
+      "label": "Target hitting time",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:54",
+      "label": "Protocol-competitive target acceleration",
+      "obligation_category": "ecpt-proxy-target",
+      "verifier_route": "ecpt.adapters.proxy.verify_target_contract"
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.hitting_time_acceleration"
+      ],
+      "item_id": "prop:hitting-time-acceleration",
+      "label": "Hitting-time acceleration certificate",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.FrontierRecord"
+      ],
+      "item_id": "definition:55",
+      "label": "Certified value vector",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.pareto_frontier"
+      ],
+      "item_id": "definition:56",
+      "label": "Pareto frontier recursion",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.pareto_frontier"
+      ],
+      "item_id": "prop:pareto-operability",
+      "label": "Pareto operability",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:57",
+      "label": "Paralysis and repair route",
+      "obligation_category": "ecpt-speculative-channel",
+      "verifier_route": "ecpt.adapters.speculative.verify_channel_and_repair"
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.pareto_frontier"
+      ],
+      "item_id": "prop:pareto-empty-suspension",
+      "label": "Pareto-empty suspension",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "cor:scalar-bellman",
+      "label": "Scalar Bellman interface",
+      "obligation_category": "ecpt-generator-limit",
+      "verifier_route": "ecpt.adapters.generators.verify_limit_envelope"
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ProjectionAudit"
+      ],
+      "item_id": "prop:raw-relaxed-separation",
+      "label": "Raw-relaxed separation",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.MonotoneMap"
+      ],
+      "item_id": "prop:friction-charged-monotone-intervention",
+      "label": "Friction-charged monotone intervention",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "def:markov-additive-raf",
+      "label": "Speculative RAF with Markov additive debt",
+      "obligation_category": "ecpt-generator-limit",
+      "verifier_route": "ecpt.adapters.generators.verify_limit_envelope"
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_cycle_monitor"
+      ],
+      "item_id": "definition:59",
+      "label": "Cycle monitor and stopped runtime certificate",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_settlement_return_raf_certificate"
+      ],
+      "item_id": "def:debt-solvency-kernel",
+      "label": "Settlement-return kernel",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_settlement_return_raf_certificate"
+      ],
+      "item_id": "def:settlement-event-algebra",
+      "label": "Settlement-return event algebra",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_settlement_return_raf_certificate"
+      ],
+      "item_id": "thm:debt-solvency-speculative-raf-emergence",
+      "label": "Settlement-return speculative RAF emergence",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:62",
+      "label": "Sparse synergy and residual certificate",
+      "obligation_category": "ecpt-speculative-channel",
+      "verifier_route": "ecpt.adapters.speculative.verify_channel_and_repair"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "prop:sparse-synergy-lower-bound",
+      "label": "Sparse synergy lower bound",
+      "obligation_category": "ecpt-speculative-channel",
+      "verifier_route": "ecpt.adapters.speculative.verify_channel_and_repair"
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_resource_normalized_cut"
+      ],
+      "item_id": "definition:63",
+      "label": "Resource normalization ledger",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_resource_normalized_cut"
+      ],
+      "item_id": "thm:resource-cut",
+      "label": "Resource-normalized cut bound",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_activation_threshold_certificate"
+      ],
+      "item_id": "definition:64",
+      "label": "AND-support finite-size and thermodynamic activation certificate",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_activation_threshold_certificate"
+      ],
+      "item_id": "thm:finite-size-activation-threshold",
+      "label": "AND-support finite-size activation threshold",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.backpressure_reserve_loss"
+      ],
+      "item_id": "definition:65",
+      "label": "Verification backpressure",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.backpressure_reserve_loss"
+      ],
+      "item_id": "prop:backpressure-reserve-loss",
+      "label": "Backpressure reserve loss",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.bottleneck_shadow_price"
+      ],
+      "item_id": "prop:bottleneck-shadow-price",
+      "label": "Bottleneck shadow price",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "bit.SelectivePotentialResult"
+      ],
+      "item_id": "definition:66",
+      "label": "Linear lower-bound abstraction",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "cor:linear-growth-lower-bound",
+      "label": "Linear growth lower bound",
+      "obligation_category": "numerical-envelope",
+      "verifier_route": "core.adapters.envelope.verify_finite_bound"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "def:density-dependent-chain",
+      "label": "Regularized density-dependent ECPT family",
+      "obligation_category": "ecpt-generator-limit",
+      "verifier_route": "ecpt.adapters.generators.verify_limit_envelope"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "def:identified-generator-calibration",
+      "label": "Intervention-identified generator calibration certificate",
+      "obligation_category": "ecpt-generator-limit",
+      "verifier_route": "ecpt.adapters.generators.verify_limit_envelope"
+    },
+    {
+      "coverage_status": "implemented_constructive",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.reachable_mass"
+      ],
+      "item_id": "def:attainable-inclusion-response",
+      "label": "Reachable mass recursion certificate",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:70",
+      "label": "Regularized macroscopic percolation envelope",
+      "obligation_category": "ecpt-generator-limit",
+      "verifier_route": "ecpt.adapters.generators.verify_limit_envelope"
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_mean_field_envelope"
+      ],
+      "item_id": "thm:mean-field-envelope-soundness",
+      "label": "Intervention-identified generator-to-mean-field envelope soundness",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:71",
+      "label": "ALT-compatible packet",
+      "obligation_category": "ecpt-bridge-reserve",
+      "verifier_route": "ecpt.adapters.bridge.verify_cross_theory_bridge"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:72",
+      "label": "Liquidity bridge",
+      "obligation_category": "ecpt-economics-policy",
+      "verifier_route": "ecpt.adapters.policy.verify_execution_policy"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "prop:alt-lift",
+      "label": "ALT lift",
+      "obligation_category": "ecpt-bridge-reserve",
+      "verifier_route": "ecpt.adapters.bridge.verify_cross_theory_bridge"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:73",
+      "label": "SQOT-compatible reserve certificate",
+      "obligation_category": "ecpt-bridge-reserve",
+      "verifier_route": "ecpt.adapters.bridge.verify_cross_theory_bridge"
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "ecpt.check_queue_certificate"
+      ],
+      "item_id": "definition:74",
+      "label": "Queue morphism",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "prop:sqot-reserve-invariance",
+      "label": "SQOT reserve invariance",
+      "obligation_category": "ecpt-bridge-reserve",
+      "verifier_route": "ecpt.adapters.bridge.verify_cross_theory_bridge"
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExtractorOutput"
+      ],
+      "item_id": "definition:75",
+      "label": "Claim extractor",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ClaimRecord"
+      ],
+      "item_id": "def:machine-readable-claim-record",
+      "label": "Machine-readable claim record",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "def:publication-capsule",
+      "label": "Publication and machine-readable capsule",
+      "obligation_category": "ecpt-bridge-reserve",
+      "verifier_route": "ecpt.adapters.bridge.verify_cross_theory_bridge"
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ProjectionAudit"
+      ],
+      "item_id": "prop:capsule-projection",
+      "label": "Capsule projection",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_schema",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.Certificate"
+      ],
+      "item_id": "definition:78",
+      "label": "ECPT certificate",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.CheckerContext"
+      ],
+      "item_id": "definition:79",
+      "label": "Checker",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "implemented_checker",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.StatusRule"
+      ],
+      "item_id": "prop:no-status-promotion",
+      "label": "No status promotion",
+      "obligation_category": null,
+      "verifier_route": null
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "thm:protocol-relative-soundness",
+      "label": "Protocol-relative soundness",
+      "obligation_category": "ecpt-bridge-reserve",
+      "verifier_route": "ecpt.adapters.bridge.verify_cross_theory_bridge"
+    }
+  ],
+  "mr_records": 0,
+  "representative_items": [
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:15",
+      "label": "Auxiliary trace-complex diagnostic",
+      "obligation_category": "ecpt-trace-diagnostic",
+      "verifier_route": "ecpt.adapters.trace_complex.verify_diagnostic_projection"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:18",
+      "label": "Accumulation, availability, liquidity, and execution availability",
+      "obligation_category": "ecpt-economics-policy",
+      "verifier_route": "ecpt.adapters.policy.verify_execution_policy"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:31",
+      "label": "Speculative execution channel",
+      "obligation_category": "ecpt-speculative-channel",
+      "verifier_route": "ecpt.adapters.speculative.verify_channel_and_repair"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:37",
+      "label": "Concrete ecology semantics",
+      "obligation_category": "ecpt-ecology-ontology",
+      "verifier_route": "ecpt.adapters.ecology.verify_domain_abstraction"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:38",
+      "label": "Sound finite abstraction",
+      "obligation_category": "ecpt-ecology-ontology",
+      "verifier_route": "ecpt.adapters.ecology.verify_domain_abstraction"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "prop:abstraction-soundness",
+      "label": "Abstraction soundness",
+      "obligation_category": "ecpt-ecology-ontology",
+      "verifier_route": "ecpt.adapters.ecology.verify_domain_abstraction"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "cor:light-tail-exponential-witness",
+      "label": "Light-tail exponential witness",
+      "obligation_category": "numerical-envelope",
+      "verifier_route": "core.adapters.envelope.verify_finite_bound"
+    },
+    {
+      "coverage_status": "external_obligation",
+      "implementation_maturity": "snapshot_metadata_only",
+      "implementation_refs": [
+        "core.ExternalProofObligation"
+      ],
+      "item_id": "definition:48",
+      "label": "Natural accelerator policy",
+      "obligation_category": "ecpt-economics-policy",
+      "verifier_route": "ecpt.adapters.policy.verify_execution_policy"
+    }
+  ],
+  "schema_version": "theory-snapshot-1.0"
+}