kibi-cli 0.19.0 → 2.0.0

package/dist/schemas/entity.schema.json

@@ -7,63 +7,129 @@
             "oneOf": [
                 {
                     "type": "object",
-                    "required": ["kind", "name", "type"],
+                    "required": [
+                        "kind",
+                        "name",
+                        "type"
+                    ],
                     "properties": {
-                        "kind": { "const": "var" },
-                        "name": { "type": "string", "pattern": "^[A-Z][A-Za-z0-9_]*$" },
-                        "type": { "type": "string", "pattern": "^[a-z][a-z0-9_:.\\/-]*$" }
+                        "kind": {
+                            "const": "var"
+                        },
+                        "name": {
+                            "type": "string",
+                            "pattern": "^[A-Z][A-Za-z0-9_]*$"
+                        },
+                        "type": {
+                            "type": "string",
+                            "pattern": "^[a-z][a-z0-9_:.\\/-]*$"
+                        }
                     },
                     "additionalProperties": false
                 },
                 {
                     "type": "object",
-                    "required": ["kind", "value"],
+                    "required": [
+                        "kind",
+                        "value"
+                    ],
                     "properties": {
-                        "kind": { "const": "const" },
-                        "value": { "type": "string", "minLength": 1 },
-                        "type": { "type": "string", "pattern": "^[a-z][a-z0-9_:.\\/-]*$" }
+                        "kind": {
+                            "const": "const"
+                        },
+                        "value": {
+                            "type": "string",
+                            "minLength": 1
+                        },
+                        "type": {
+                            "type": "string",
+                            "pattern": "^[a-z][a-z0-9_:.\\/-]*$"
+                        }
                     },
                     "additionalProperties": false
                 },
                 {
                     "type": "object",
-                    "required": ["kind", "value"],
+                    "required": [
+                        "kind",
+                        "value"
+                    ],
                     "properties": {
-                        "kind": { "const": "number" },
-                        "value": { "type": "number" },
-                        "unit": { "type": "string", "pattern": "^[a-z][a-z0-9_:.\\/-]*$" }
+                        "kind": {
+                            "const": "number"
+                        },
+                        "value": {
+                            "type": "number"
+                        },
+                        "unit": {
+                            "type": "string",
+                            "pattern": "^[a-z][a-z0-9_:.\\/-]*$"
+                        }
                     },
                     "additionalProperties": false
                 },
                 {
                     "type": "object",
-                    "required": ["kind", "value", "unit"],
+                    "required": [
+                        "kind",
+                        "value",
+                        "unit"
+                    ],
                     "properties": {
-                        "kind": { "const": "duration" },
-                        "value": { "type": "number", "minimum": 0 },
+                        "kind": {
+                            "const": "duration"
+                        },
+                        "value": {
+                            "type": "number",
+                            "minimum": 0
+                        },
                         "unit": {
                             "type": "string",
-                            "enum": ["ms", "s", "m", "h", "d", "w"]
+                            "enum": [
+                                "ms",
+                                "s",
+                                "m",
+                                "h",
+                                "d",
+                                "w"
+                            ]
                         }
                     },
                     "additionalProperties": false
                 },
                 {
                     "type": "object",
-                    "required": ["kind", "value"],
+                    "required": [
+                        "kind",
+                        "value"
+                    ],
                     "properties": {
-                        "kind": { "const": "timestamp" },
-                        "value": { "type": "string" }
+                        "kind": {
+                            "const": "timestamp"
+                        },
+                        "value": {
+                            "type": "string"
+                        }
                     },
                     "additionalProperties": false
                 },
                 {
                     "type": "object",
-                    "required": ["kind", "start", "end"],
+                    "required": [
+                        "kind",
+                        "start",
+                        "end"
+                    ],
                     "properties": {
-                        "kind": { "const": "interval" },
-                        "start": { "type": "string" },
-                        "end": { "type": "string" }
+                        "kind": {
+                            "const": "interval"
+                        },
+                        "start": {
+                            "type": "string"
+                        },
+                        "end": {
+                            "type": "string"
+                        }
                     },
                     "additionalProperties": false
                 }
@@ -71,74 +137,162 @@
         },
         "logicAtom": {
             "type": "object",
-            "required": ["kind", "name", "args"],
+            "required": [
+                "kind",
+                "name",
+                "args"
+            ],
             "properties": {
-                "kind": { "const": "atom" },
-                "namespace": { "type": "string", "pattern": "^[a-z][a-z0-9_:.\\/-]*$" },
-                "name": { "type": "string", "pattern": "^[a-z][a-z0-9_:.\\/-]*$" },
+                "kind": {
+                    "const": "atom"
+                },
+                "namespace": {
+                    "type": "string",
+                    "pattern": "^[a-z][a-z0-9_:.\\/-]*$"
+                },
+                "name": {
+                    "type": "string",
+                    "pattern": "^[a-z][a-z0-9_:.\\/-]*$"
+                },
                 "args": {
                     "type": "array",
                     "maxItems": 8,
-                    "items": { "$ref": "#/$defs/logicTerm" }
+                    "items": {
+                        "$ref": "#/$defs/logicTerm"
+                    }
+                },
+                "polarity": {
+                    "enum": [
+                        "positive",
+                        "negative"
+                    ]
                 },
-                "polarity": { "enum": ["positive", "negative"] },
-                "closedWorld": { "type": "boolean" }
+                "closedWorld": {
+                    "type": "boolean"
+                }
             },
             "additionalProperties": false
         },
         "logicExpression": {
             "oneOf": [
-                { "$ref": "#/$defs/logicAtom" },
+                {
+                    "$ref": "#/$defs/logicAtom"
+                },
                 {
                     "type": "object",
-                    "required": ["kind", "items"],
+                    "required": [
+                        "kind",
+                        "items"
+                    ],
                     "properties": {
-                        "kind": { "enum": ["all", "any"] },
+                        "kind": {
+                            "enum": [
+                                "all",
+                                "any"
+                            ]
+                        },
                         "items": {
                             "type": "array",
                             "minItems": 1,
                             "maxItems": 32,
-                            "items": { "$ref": "#/$defs/logicExpression" }
+                            "items": {
+                                "$ref": "#/$defs/logicExpression"
+                            }
                         }
                     },
                     "additionalProperties": false
                 },
                 {
                     "type": "object",
-                    "required": ["kind", "item"],
+                    "required": [
+                        "kind",
+                        "item"
+                    ],
                     "properties": {
-                        "kind": { "const": "not" },
-                        "item": { "$ref": "#/$defs/logicAtom" }
+                        "kind": {
+                            "const": "not"
+                        },
+                        "item": {
+                            "$ref": "#/$defs/logicAtom"
+                        }
                     },
                     "additionalProperties": false
                 },
                 {
                     "type": "object",
-                    "required": ["kind", "operator", "left", "right"],
+                    "required": [
+                        "kind",
+                        "operator",
+                        "left",
+                        "right"
+                    ],
                     "properties": {
-                        "kind": { "const": "compare" },
-                        "operator": { "enum": ["eq", "neq", "lt", "lte", "gt", "gte"] },
-                        "left": { "$ref": "#/$defs/logicTerm" },
-                        "right": { "$ref": "#/$defs/logicTerm" }
+                        "kind": {
+                            "const": "compare"
+                        },
+                        "operator": {
+                            "enum": [
+                                "eq",
+                                "neq",
+                                "lt",
+                                "lte",
+                                "gt",
+                                "gte"
+                            ]
+                        },
+                        "left": {
+                            "$ref": "#/$defs/logicTerm"
+                        },
+                        "right": {
+                            "$ref": "#/$defs/logicTerm"
+                        }
                     },
                     "additionalProperties": false
                 },
                 {
                     "type": "object",
-                    "required": ["kind", "atom", "operator", "value"],
+                    "required": [
+                        "kind",
+                        "atom",
+                        "operator",
+                        "value"
+                    ],
                     "properties": {
-                        "kind": { "const": "count" },
-                        "atom": { "$ref": "#/$defs/logicAtom" },
-                        "operator": { "enum": ["eq", "neq", "lt", "lte", "gt", "gte"] },
-                        "value": { "type": "integer", "minimum": 0 }
+                        "kind": {
+                            "const": "count"
+                        },
+                        "atom": {
+                            "$ref": "#/$defs/logicAtom"
+                        },
+                        "operator": {
+                            "enum": [
+                                "eq",
+                                "neq",
+                                "lt",
+                                "lte",
+                                "gt",
+                                "gte"
+                            ]
+                        },
+                        "value": {
+                            "type": "integer",
+                            "minimum": 0
+                        }
                     },
                     "additionalProperties": false
                 },
                 {
                     "type": "object",
-                    "required": ["kind", "relation", "left", "right"],
+                    "required": [
+                        "kind",
+                        "relation",
+                        "left",
+                        "right"
+                    ],
                     "properties": {
-                        "kind": { "const": "temporal" },
+                        "kind": {
+                            "const": "temporal"
+                        },
                         "relation": {
                             "enum": [
                                 "before",
@@ -149,8 +303,12 @@
                                 "finishes"
                             ]
                         },
-                        "left": { "$ref": "#/$defs/logicTerm" },
-                        "right": { "$ref": "#/$defs/logicTerm" }
+                        "left": {
+                            "$ref": "#/$defs/logicTerm"
+                        },
+                        "right": {
+                            "$ref": "#/$defs/logicTerm"
+                        }
                     },
                     "additionalProperties": false
                 }
@@ -158,28 +316,61 @@
         },
         "logicRule": {
             "type": "object",
-            "required": ["version", "kind", "modality"],
+            "required": [
+                "version",
+                "kind",
+                "modality"
+            ],
             "properties": {
-                "version": { "const": "kibi.logic.v1" },
-                "kind": { "enum": ["atom", "rule", "constraint"] },
+                "version": {
+                    "const": "kibi.logic.v1"
+                },
+                "kind": {
+                    "enum": [
+                        "atom",
+                        "rule",
+                        "constraint"
+                    ]
+                },
                 "modality": {
-                    "enum": ["assert", "deny", "oblige", "permit", "forbid"]
+                    "enum": [
+                        "assert",
+                        "deny",
+                        "oblige",
+                        "permit",
+                        "forbid"
+                    ]
+                },
+                "head": {
+                    "$ref": "#/$defs/logicAtom"
+                },
+                "body": {
+                    "$ref": "#/$defs/logicExpression"
                 },
-                "head": { "$ref": "#/$defs/logicAtom" },
-                "body": { "$ref": "#/$defs/logicExpression" },
                 "variables": {
                     "type": "array",
                     "maxItems": 32,
                     "items": {
                         "type": "object",
-                        "required": ["name", "type"],
+                        "required": [
+                            "name",
+                            "type"
+                        ],
                         "properties": {
-                            "name": { "type": "string", "pattern": "^[A-Z][A-Za-z0-9_]*$" },
+                            "name": {
+                                "type": "string",
+                                "pattern": "^[A-Z][A-Za-z0-9_]*$"
+                            },
                             "type": {
                                 "type": "string",
                                 "pattern": "^[a-z][a-z0-9_:.\\/-]*$"
                             },
-                            "quantifier": { "enum": ["forall", "exists"] }
+                            "quantifier": {
+                                "enum": [
+                                    "forall",
+                                    "exists"
+                                ]
+                            }
                         },
                         "additionalProperties": false
                     }
@@ -187,27 +378,49 @@
                 "exceptions": {
                     "type": "array",
                     "maxItems": 16,
-                    "items": { "$ref": "#/$defs/logicExpression" }
+                    "items": {
+                        "$ref": "#/$defs/logicExpression"
+                    }
                 },
                 "scope": {
                     "type": "object",
                     "properties": {
-                        "authority": { "type": "string" },
-                        "name": { "type": "string" },
-                        "tags": { "type": "array", "items": { "type": "string" } }
+                        "authority": {
+                            "type": "string"
+                        },
+                        "name": {
+                            "type": "string"
+                        },
+                        "tags": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        }
                     },
                     "additionalProperties": false
                 },
-                "validFrom": { "type": "string" },
-                "validTo": { "type": "string" },
-                "ruleSchemaId": { "type": "string", "minLength": 1 }
+                "validFrom": {
+                    "type": "string"
+                },
+                "validTo": {
+                    "type": "string"
+                },
+                "ruleSchemaId": {
+                    "type": "string",
+                    "minLength": 1
+                }
             },
             "additionalProperties": false
         }
     },
     "properties": {
-        "id": { "type": "string" },
-        "title": { "type": "string" },
+        "id": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
         "status": {
             "type": "string",
             "enum": [
@@ -232,15 +445,48 @@
                 "removed"
             ]
         },
-        "created_at": { "type": "string" },
-        "updated_at": { "type": "string" },
-        "source": { "type": "string" },
-        "tags": { "type": "array", "items": { "type": "string" } },
-        "owner": { "type": "string" },
-        "priority": { "type": "string" },
-        "severity": { "type": "string" },
-        "links": { "type": "array", "items": { "type": "string" } },
-        "text_ref": { "type": "string" },
+        "created_at": {
+            "type": "string"
+        },
+        "updated_at": {
+            "type": "string"
+        },
+        "source": {
+            "type": "string"
+        },
+        "tags": {
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        },
+        "owner": {
+            "type": "string"
+        },
+        "priority": {
+            "type": "string"
+        },
+        "severity": {
+            "type": "string"
+        },
+        "links": {
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        },
+        "text_ref": {
+            "type": "string"
+        },
+        "proof_exempt": {
+            "type": "boolean",
+            "description": "Requirement-only. Marks a current requirement as intentionally outside E2E-proof scope; requires proof_exempt_reason."
+        },
+        "proof_exempt_reason": {
+            "type": "string",
+            "minLength": 1,
+            "description": "Requirement-only. Required when proof_exempt is true; surfaces as the applicability reason in coverage rows."
+        },
         "semantic_text": {
             "type": "string",
             "description": "Requirement-only authored prose whose exact UTF-8 bytes anchor the semantic inventory without replacing text_ref evidence."
@@ -249,12 +495,18 @@
             "type": "array",
             "minItems": 1,
             "uniqueItems": true,
-            "items": { "type": "string", "pattern": "^CLAIM-[A-F0-9]{16}$" }
+            "items": {
+                "type": "string",
+                "pattern": "^CLAIM-[A-F0-9]{16}$"
+            }
         },
         "semantic_clauses": {
             "type": "array",
             "minItems": 1,
-            "items": { "type": "string", "minLength": 1 }
+            "items": {
+                "type": "string",
+                "minLength": 1
+            }
         },
         "semantic_inventory_version": {
             "type": "string",
@@ -262,7 +514,11 @@
         },
         "semantic_source_field": {
             "type": "string",
-            "enum": ["semantic_text", "text_ref", "title"]
+            "enum": [
+                "semantic_text",
+                "text_ref",
+                "title"
+            ]
         },
         "semantic_source_hash": {
             "type": "string",
@@ -272,10 +528,22 @@
             "type": "array",
             "items": {
                 "type": "object",
-                "required": ["claim_key", "claim_text", "role", "status", "span"],
+                "required": [
+                    "claim_key",
+                    "claim_text",
+                    "role",
+                    "status",
+                    "span"
+                ],
                 "properties": {
-                    "claim_key": { "type": "string", "pattern": "^CLAIM-[A-F0-9]{16}$" },
-                    "claim_text": { "type": "string", "minLength": 1 },
+                    "claim_key": {
+                        "type": "string",
+                        "pattern": "^CLAIM-[A-F0-9]{16}$"
+                    },
+                    "claim_text": {
+                        "type": "string",
+                        "minLength": 1
+                    },
                     "role": {
                         "type": "string",
                         "enum": [
@@ -301,28 +569,46 @@
                     },
                     "span": {
                         "type": "object",
-                        "required": ["start", "end"],
+                        "required": [
+                            "start",
+                            "end"
+                        ],
                         "properties": {
-                            "start": { "type": "integer", "minimum": 0 },
-                            "end": { "type": "integer", "minimum": 0 }
+                            "start": {
+                                "type": "integer",
+                                "minimum": 0
+                            },
+                            "end": {
+                                "type": "integer",
+                                "minimum": 0
+                            }
                         },
                         "additionalProperties": false
                     },
-                    "semantic_key": { "type": "string" },
-                    "payload_hash": { "type": "string" },
-                    "reason": { "type": "string" }
+                    "semantic_key": {
+                        "type": "string"
+                    },
+                    "payload_hash": {
+                        "type": "string"
+                    },
+                    "reason": {
+                        "type": "string"
+                    }
                 },
                 "additionalProperties": false
             }
         },
-        "sourceFile": { "type": "string" },
+        "sourceFile": {
+            "type": "string"
+        },
         "granularity_reason": {
             "type": "string",
             "enum": [
                 "config-artifact",
                 "module-level-behavior",
                 "extractor-miss",
-                "legacy-link"
+                "legacy-link",
+                "test-suite"
             ]
         },
         "symbol_role": {
@@ -338,50 +624,167 @@
         },
         "verification_scope": {
             "type": "string",
-            "enum": ["unit", "integration", "end_to_end"]
+            "enum": [
+                "unit",
+                "integration",
+                "end_to_end"
+            ]
         },
         "verification_perspective": {
             "type": "string",
-            "enum": ["internal", "consumer"]
+            "enum": [
+                "internal",
+                "consumer"
+            ]
+        },
+        "proof_contract": {
+            "type": "object",
+            "description": "Semantic proof contract binding a test to explicit proof obligations executed by a configured integration.",
+            "required": [
+                "version",
+                "integration",
+                "required_proofs",
+                "success_policy"
+            ],
+            "properties": {
+                "version": {
+                    "type": "string",
+                    "const": "kibi.proof-contract.v1"
+                },
+                "integration": {
+                    "type": "string",
+                    "minLength": 1
+                },
+                "required_proofs": {
+                    "type": "array",
+                    "minItems": 1,
+                    "maxItems": 1000,
+                    "items": {
+                        "type": "object",
+                        "required": [
+                            "symbol_id",
+                            "target"
+                        ],
+                        "properties": {
+                            "symbol_id": {
+                                "type": "string",
+                                "minLength": 1
+                            },
+                            "target": {
+                                "type": "string",
+                                "minLength": 1
+                            }
+                        },
+                        "additionalProperties": false
+                    }
+                },
+                "success_policy": {
+                    "type": "string",
+                    "enum": [
+                        "all_required_first_attempt"
+                    ]
+                }
+            },
+            "additionalProperties": false
+        },
+        "proof_bindings": {
+            "type": "array",
+            "description": "Optional native-runner bindings for proof obligations. Bindings are provenance metadata; they never replace the semantic proof contract.",
+            "items": {
+                "type": "object",
+                "required": [
+                    "symbol_id",
+                    "target"
+                ],
+                "properties": {
+                    "symbol_id": {
+                        "type": "string",
+                        "minLength": 1
+                    },
+                    "target": {
+                        "type": "string",
+                        "minLength": 1
+                    },
+                    "native_id": {
+                        "type": "string",
+                        "minLength": 1
+                    },
+                    "aliases": {
+                        "type": "array",
+                        "items": {
+                            "type": "string",
+                            "minLength": 1
+                        }
+                    },
+                    "source_file": {
+                        "type": "string",
+                        "minLength": 1
+                    },
+                    "line": {
+                        "type": "integer",
+                        "minimum": 1
+                    }
+                },
+                "additionalProperties": false
+            }
         },
-        "verification_receipts": {
+        "proof_receipts": {
             "type": "array",
-            "maxItems": 50,
             "items": {
                 "type": "object",
+                "description": "Kibi-derived kibi.proof-receipt.v1. Receipts are never caller-authored; kb_ingest_proof derives them from kibi.proof-run.v1 artifacts.",
                 "required": [
                     "version",
                     "receipt_id",
                     "test_id",
-                    "runner",
-                    "command",
                     "scope",
                     "outcome",
                     "code_snapshot",
                     "environment_hash",
                     "started_at",
                     "finished_at",
-                    "artifact_digest"
+                    "artifact_digest",
+                    "contract_hash",
+                    "fingerprint",
+                    "fingerprint_components",
+                    "integration_id",
+                    "producer",
+                    "command_argv",
+                    "run_outcome",
+                    "proof_results"
                 ],
                 "properties": {
                     "version": {
                         "type": "string",
-                        "const": "kibi.verification-receipt.v1"
+                        "const": "kibi.proof-receipt.v1"
                     },
                     "receipt_id": {
                         "type": "string",
-                        "pattern": "^VR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$"
+                        "pattern": "^PR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$"
+                    },
+                    "test_id": {
+                        "type": "string",
+                        "minLength": 1
                     },
-                    "test_id": { "type": "string", "minLength": 1 },
-                    "runner": { "type": "string", "minLength": 1 },
-                    "command": { "type": "string", "minLength": 1 },
                     "scope": {
                         "type": "string",
-                        "enum": ["unit", "integration", "end_to_end"]
+                        "enum": [
+                            "unit",
+                            "integration",
+                            "end_to_end"
+                        ]
                     },
                     "outcome": {
                         "type": "string",
-                        "enum": ["passed", "failed", "errored", "cancelled", "skipped"]
+                        "enum": [
+                            "passed",
+                            "failed",
+                            "errored",
+                            "cancelled",
+                            "skipped",
+                            "timed_out",
+                            "interrupted"
+                        ]
                     },
                     "code_snapshot": {
                         "type": "string",
@@ -391,11 +794,236 @@
                         "type": "string",
                         "pattern": "^[a-f0-9]{64}$"
                     },
-                    "started_at": { "type": "string", "minLength": 1 },
-                    "finished_at": { "type": "string", "minLength": 1 },
+                    "started_at": {
+                        "type": "string",
+                        "minLength": 1
+                    },
+                    "finished_at": {
+                        "type": "string",
+                        "minLength": 1
+                    },
                     "artifact_digest": {
                         "type": "string",
                         "pattern": "^[a-f0-9]{64}$"
+                    },
+                    "contract_hash": {
+                        "type": "string",
+                        "pattern": "^[a-f0-9]{64}$"
+                    },
+                    "binding_hash": {
+                        "type": "string",
+                        "pattern": "^[a-f0-9]{64}$"
+                    },
+                    "fingerprint": {
+                        "type": "string",
+                        "pattern": "^[a-f0-9]{64}$"
+                    },
+                    "fingerprint_components": {
+                        "type": "object",
+                        "required": [
+                            "contract",
+                            "integration",
+                            "command",
+                            "bindings",
+                            "producer"
+                        ],
+                        "additionalProperties": false,
+                        "properties": {
+                            "contract": {
+                                "type": "string",
+                                "pattern": "^[a-f0-9]{64}$"
+                            },
+                            "integration": {
+                                "type": "string",
+                                "pattern": "^[a-f0-9]{64}$"
+                            },
+                            "command": {
+                                "type": "string",
+                                "pattern": "^[a-f0-9]{64}$"
+                            },
+                            "bindings": {
+                                "type": "string",
+                                "pattern": "^[a-f0-9]{64}$"
+                            },
+                            "producer": {
+                                "type": "string",
+                                "pattern": "^[a-f0-9]{64}$"
+                            }
+                        }
+                    },
+                    "integration_id": {
+                        "type": "string",
+                        "minLength": 1
+                    },
+                    "producer": {
+                        "type": "object",
+                        "required": [
+                            "name"
+                        ],
+                        "properties": {
+                            "name": {
+                                "type": "string",
+                                "minLength": 1
+                            },
+                            "version": {
+                                "type": "string",
+                                "minLength": 1
+                            }
+                        },
+                        "additionalProperties": false
+                    },
+                    "command_argv": {
+                        "type": "array",
+                        "minItems": 1,
+                        "items": {
+                            "type": "string",
+                            "minLength": 1
+                        }
+                    },
+                    "run_outcome": {
+                        "type": "string",
+                        "enum": [
+                            "passed",
+                            "failed",
+                            "errored",
+                            "cancelled",
+                            "timed_out",
+                            "interrupted",
+                            "no_results"
+                        ]
+                    },
+                    "proof_results": {
+                        "type": "array",
+                        "minItems": 0,
+                        "maxItems": 1000,
+                        "items": {
+                            "type": "object",
+                            "required": [
+                                "symbol_id",
+                                "target",
+                                "outcome",
+                                "binding",
+                                "attempts"
+                            ],
+                            "properties": {
+                                "symbol_id": {
+                                    "type": "string",
+                                    "minLength": 1
+                                },
+                                "target": {
+                                    "type": "string",
+                                    "minLength": 1
+                                },
+                                "outcome": {
+                                    "type": "string",
+                                    "enum": [
+                                        "passed",
+                                        "failed",
+                                        "timed_out",
+                                        "skipped",
+                                        "interrupted",
+                                        "errored"
+                                    ]
+                                },
+                                "binding": {
+                                    "type": "string",
+                                    "enum": [
+                                        "native_case",
+                                        "aggregate_run"
+                                    ]
+                                },
+                                "native_id": {
+                                    "type": "string",
+                                    "minLength": 1
+                                },
+                                "attempts": {
+                                    "oneOf": [
+                                        {
+                                            "type": "object",
+                                            "required": [
+                                                "status",
+                                                "entries"
+                                            ],
+                                            "properties": {
+                                                "status": {
+                                                    "type": "string",
+                                                    "const": "complete"
+                                                },
+                                                "entries": {
+                                                    "type": "array",
+                                                    "minItems": 1,
+                                                    "items": {
+                                                        "type": "object",
+                                                        "required": [
+                                                            "outcome"
+                                                        ],
+                                                        "properties": {
+                                                            "outcome": {
+                                                                "type": "string",
+                                                                "enum": [
+                                                                    "passed",
+                                                                    "failed",
+                                                                    "timed_out",
+                                                                    "skipped",
+                                                                    "interrupted",
+                                                                    "errored"
+                                                                ]
+                                                            },
+                                                            "duration_ms": {
+                                                                "type": "number",
+                                                                "minimum": 0
+                                                            }
+                                                        },
+                                                        "additionalProperties": false
+                                                    }
+                                                }
+                                            },
+                                            "additionalProperties": false
+                                        },
+                                        {
+                                            "type": "object",
+                                            "required": [
+                                                "status"
+                                            ],
+                                            "properties": {
+                                                "status": {
+                                                    "type": "string",
+                                                    "const": "unavailable"
+                                                }
+                                            },
+                                            "additionalProperties": false
+                                        }
+                                    ]
+                                }
+                            },
+                            "additionalProperties": false
+                        }
+                    },
+                    "gaps": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "required": [
+                                "symbol_id",
+                                "target",
+                                "reason"
+                            ],
+                            "properties": {
+                                "symbol_id": {
+                                    "type": "string",
+                                    "minLength": 1
+                                },
+                                "target": {
+                                    "type": "string",
+                                    "minLength": 1
+                                },
+                                "reason": {
+                                    "type": "string",
+                                    "minLength": 1
+                                }
+                            },
+                            "additionalProperties": false
+                        }
                     }
                 },
                 "additionalProperties": false
@@ -427,51 +1055,151 @@
                 "rule"
             ]
         },
-        "subject_key": { "type": "string" },
-        "property_key": { "type": "string" },
+        "subject_key": {
+            "type": "string"
+        },
+        "property_key": {
+            "type": "string"
+        },
         "operator": {
             "type": "string",
-            "enum": ["eq", "neq", "lt", "lte", "gt", "gte"]
+            "enum": [
+                "eq",
+                "neq",
+                "lt",
+                "lte",
+                "gt",
+                "gte"
+            ]
         },
         "value_type": {
             "type": "string",
-            "enum": ["string", "int", "number", "bool"]
-        },
-        "value_string": { "type": "string" },
-        "value_int": { "type": "integer" },
-        "value_number": { "type": "number" },
-        "value_bool": { "type": "boolean" },
-        "unit": { "type": "string" },
-        "scope": { "type": "string" },
+            "enum": [
+                "string",
+                "int",
+                "number",
+                "bool"
+            ]
+        },
+        "value_string": {
+            "type": "string"
+        },
+        "value_int": {
+            "type": "integer"
+        },
+        "value_number": {
+            "type": "number"
+        },
+        "value_bool": {
+            "type": "boolean"
+        },
+        "unit": {
+            "type": "string"
+        },
+        "scope": {
+            "type": "string"
+        },
         "polarity": {
             "type": "string",
-            "enum": ["require", "forbid", "assert", "deny"]
-        },
-        "closed_world": { "type": "boolean" },
-        "valid_from": { "type": "string" },
-        "valid_to": { "type": "string" },
-        "canonical_key": { "type": "string" },
-        "claim_key": { "type": "string", "pattern": "^CLAIM-[A-F0-9]{16}$" },
-        "claim_text": { "type": "string" },
-        "predicate_name": { "type": "string" },
-        "predicate_namespace": { "type": "string" },
-        "predicate_arity": { "type": "integer", "minimum": 1 },
-        "argument_names": { "type": "array", "items": { "type": "string" } },
-        "argument_types": { "type": "array", "items": { "type": "string" } },
+            "enum": [
+                "require",
+                "forbid",
+                "assert",
+                "deny"
+            ]
+        },
+        "closed_world": {
+            "type": "boolean"
+        },
+        "valid_from": {
+            "type": "string"
+        },
+        "valid_to": {
+            "type": "string"
+        },
+        "canonical_key": {
+            "type": "string"
+        },
+        "claim_key": {
+            "type": "string",
+            "pattern": "^CLAIM-[A-F0-9]{16}$"
+        },
+        "claim_text": {
+            "type": "string"
+        },
+        "predicate_name": {
+            "type": "string"
+        },
+        "predicate_namespace": {
+            "type": "string"
+        },
+        "predicate_arity": {
+            "type": "integer",
+            "minimum": 1
+        },
+        "argument_names": {
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        },
+        "argument_types": {
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        },
         "argument_descriptions": {
             "type": "array",
-            "items": { "type": "string" }
-        },
-        "aliases": { "type": "array", "items": { "type": "string" } },
-        "examples": { "type": "array", "items": { "type": "string" } },
-        "predicate_args": { "type": "array", "items": { "type": "string" } },
-        "rule_ir": { "$ref": "#/$defs/logicRule" },
-        "rule_hash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
-        "rule_schema_id": { "type": "string", "minLength": 1 },
-        "rule_name": { "type": "string", "minLength": 1 },
-        "semantic_key": { "type": "string", "pattern": "^SEM-[A-F0-9]{24}$" },
-        "claim_span_start": { "type": "integer", "minimum": 0 },
-        "claim_span_end": { "type": "integer", "minimum": 0 }
+            "items": {
+                "type": "string"
+            }
+        },
+        "aliases": {
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        },
+        "examples": {
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        },
+        "predicate_args": {
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        },
+        "rule_ir": {
+            "$ref": "#/$defs/logicRule"
+        },
+        "rule_hash": {
+            "type": "string",
+            "pattern": "^[a-f0-9]{64}$"
+        },
+        "rule_schema_id": {
+            "type": "string",
+            "minLength": 1
+        },
+        "rule_name": {
+            "type": "string",
+            "minLength": 1
+        },
+        "semantic_key": {
+            "type": "string",
+            "pattern": "^SEM-[A-F0-9]{24}$"
+        },
+        "claim_span_start": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "claim_span_end": {
+            "type": "integer",
+            "minimum": 0
+        }
     },
     "required": [
         "id",
@@ -485,137 +1213,348 @@
     "allOf": [
         {
             "if": {
-                "properties": { "type": { "const": "req" } }
-            },
-            "then": {},
-            "else": { "not": { "required": ["logic_claims"] } }
-        },
-        {
-            "if": {
-                "anyOf": [{ "required": ["claim_key"] }, { "required": ["claim_text"] }]
+                "properties": {
+                    "type": {
+                        "const": "req"
+                    }
+                }
             },
-            "then": { "required": ["claim_key", "claim_text"] }
+            "else": {
+                "not": {
+                    "required": [
+                        "logic_claims"
+                    ]
+                }
+            }
         },
         {
             "if": {
-                "properties": { "type": { "const": "test" } }
+                "properties": {
+                    "type": {
+                        "const": "fact"
+                    }
+                }
             },
-            "then": {},
             "else": {
                 "not": {
                     "anyOf": [
-                        { "required": ["verification_scope"] },
-                        { "required": ["verification_perspective"] },
-                        { "required": ["verification_receipts"] }
+                        {
+                            "required": [
+                                "fact_kind"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "subject_key"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "property_key"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "operator"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "value_type"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "value_string"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "value_int"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "value_number"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "value_bool"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "unit"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "scope"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "polarity"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "closed_world"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "valid_from"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "valid_to"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "canonical_key"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "claim_key"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "claim_text"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "predicate_name"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "predicate_namespace"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "predicate_arity"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "argument_names"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "argument_types"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "argument_descriptions"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "aliases"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "examples"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "predicate_args"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "rule_ir"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "rule_hash"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "rule_schema_id"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "rule_name"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "semantic_key"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "claim_span_start"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "claim_span_end"
+                            ]
+                        }
                     ]
                 }
             }
         },
-        {
-            "if": { "required": ["verification_receipts"] },
-            "then": { "required": ["verification_scope"] }
-        },
         {
             "if": {
                 "properties": {
-                    "type": { "const": "fact" },
-                    "fact_kind": { "const": "rule_schema" }
-                },
-                "required": ["type", "fact_kind"]
+                    "type": {
+                        "const": "test"
+                    }
+                }
             },
-            "then": {
-                "required": ["rule_name", "argument_names", "argument_types"]
+            "else": {
+                "not": {
+                    "anyOf": [
+                        {
+                            "required": [
+                                "verification_scope"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "verification_perspective"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "proof_contract"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "proof_bindings"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "proof_receipts"
+                            ]
+                        }
+                    ]
+                }
             }
         },
         {
             "if": {
-                "properties": {
-                    "type": { "const": "fact" },
-                    "fact_kind": { "const": "rule" }
-                },
-                "required": ["type", "fact_kind"]
+                "required": [
+                    "proof_receipts"
+                ]
             },
             "then": {
                 "required": [
-                    "rule_ir",
-                    "rule_hash",
-                    "rule_schema_id",
-                    "rule_name",
-                    "semantic_key"
+                    "verification_scope"
                 ]
             }
         },
         {
             "if": {
-                "properties": { "type": { "const": "fact" } }
+                "properties": {
+                    "type": {
+                        "const": "req"
+                    }
+                }
             },
-            "then": {},
             "else": {
                 "not": {
                     "anyOf": [
-                        { "required": ["fact_kind"] },
-                        { "required": ["subject_key"] },
-                        { "required": ["property_key"] },
-                        { "required": ["operator"] },
-                        { "required": ["value_type"] },
-                        { "required": ["value_string"] },
-                        { "required": ["value_int"] },
-                        { "required": ["value_number"] },
-                        { "required": ["value_bool"] },
-                        { "required": ["unit"] },
-                        { "required": ["scope"] },
-                        { "required": ["polarity"] },
-                        { "required": ["closed_world"] },
-                        { "required": ["valid_from"] },
-                        { "required": ["valid_to"] },
-                        { "required": ["canonical_key"] },
-                        { "required": ["claim_key"] },
-                        { "required": ["claim_text"] },
-                        { "required": ["predicate_name"] },
-                        { "required": ["predicate_namespace"] },
-                        { "required": ["predicate_arity"] },
-                        { "required": ["argument_names"] },
-                        { "required": ["argument_types"] },
-                        { "required": ["argument_descriptions"] },
-                        { "required": ["aliases"] },
-                        { "required": ["examples"] },
-                        { "required": ["predicate_args"] },
-                        { "required": ["rule_ir"] },
-                        { "required": ["rule_hash"] },
-                        { "required": ["rule_schema_id"] },
-                        { "required": ["rule_name"] },
-                        { "required": ["semantic_key"] },
-                        { "required": ["claim_span_start"] },
-                        { "required": ["claim_span_end"] }
+                        {
+                            "required": [
+                                "semantic_inventory"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "semantic_clauses"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "semantic_text"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "semantic_inventory_version"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "semantic_source_field"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "semantic_source_hash"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "proof_exempt"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "proof_exempt_reason"
+                            ]
+                        }
                     ]
                 }
             }
         },
         {
             "if": {
-                "properties": { "type": { "const": "req" } }
+                "anyOf": [
+                    {
+                        "required": [
+                            "claim_key"
+                        ]
+                    },
+                    {
+                        "required": [
+                            "claim_text"
+                        ]
+                    }
+                ]
             },
-            "then": {},
-            "else": {
-                "not": {
-                    "anyOf": [
-                        { "required": ["semantic_inventory"] },
-                        { "required": ["semantic_clauses"] },
-                        { "required": ["semantic_text"] },
-                        { "required": ["semantic_inventory_version"] },
-                        { "required": ["semantic_source_field"] },
-                        { "required": ["semantic_source_hash"] }
-                    ]
-                }
+            "then": {
+                "required": [
+                    "claim_key",
+                    "claim_text"
+                ]
             }
         },
         {
             "if": {
                 "properties": {
-                    "type": { "const": "fact" },
-                    "fact_kind": { "const": "predicate_schema" }
+                    "type": {
+                        "const": "fact"
+                    },
+                    "fact_kind": {
+                        "const": "predicate_schema"
+                    }
                 },
-                "required": ["type", "fact_kind"]
+                "required": [
+                    "type",
+                    "fact_kind"
+                ]
             },
             "then": {
                 "required": [
@@ -629,29 +1568,105 @@
         {
             "if": {
                 "properties": {
-                    "type": { "const": "fact" },
-                    "fact_kind": { "const": "predicate" }
+                    "type": {
+                        "const": "fact"
+                    },
+                    "fact_kind": {
+                        "const": "predicate"
+                    }
                 },
-                "required": ["type", "fact_kind"]
+                "required": [
+                    "type",
+                    "fact_kind"
+                ]
             },
             "then": {
-                "required": ["predicate_name", "predicate_args", "canonical_key"],
+                "required": [
+                    "predicate_name",
+                    "predicate_args",
+                    "canonical_key"
+                ],
                 "properties": {
-                    "polarity": { "enum": ["assert", "deny"] }
+                    "polarity": {
+                        "enum": [
+                            "assert",
+                            "deny"
+                        ]
+                    }
                 }
             }
         },
         {
             "if": {
                 "properties": {
-                    "type": { "const": "fact" },
-                    "fact_kind": { "const": "property_value" }
+                    "type": {
+                        "const": "fact"
+                    },
+                    "fact_kind": {
+                        "const": "rule_schema"
+                    }
                 },
-                "required": ["type", "fact_kind"]
+                "required": [
+                    "type",
+                    "fact_kind"
+                ]
             },
             "then": {
+                "required": [
+                    "rule_name",
+                    "argument_names",
+                    "argument_types"
+                ]
+            }
+        },
+        {
+            "if": {
                 "properties": {
-                    "polarity": { "enum": ["require", "forbid"] }
+                    "type": {
+                        "const": "fact"
+                    },
+                    "fact_kind": {
+                        "const": "rule"
+                    }
+                },
+                "required": [
+                    "type",
+                    "fact_kind"
+                ]
+            },
+            "then": {
+                "required": [
+                    "rule_ir",
+                    "rule_hash",
+                    "rule_schema_id",
+                    "rule_name",
+                    "semantic_key"
+                ]
+            }
+        },
+        {
+            "if": {
+                "properties": {
+                    "type": {
+                        "const": "fact"
+                    },
+                    "fact_kind": {
+                        "const": "property_value"
+                    }
+                },
+                "required": [
+                    "type",
+                    "fact_kind"
+                ]
+            },
+            "then": {
+                "properties": {
+                    "polarity": {
+                        "enum": [
+                            "require",
+                            "forbid"
+                        ]
+                    }
                 }
             }
         }