Add HO-DET-001 runtime truth spine contract

contracts/examples/ho-det-001-runtime-contract.sample.json

@@ -17,6 +17,63 @@
   "ai_may_promote": false,
   "ai_may_close": false,
   "human_review_required": true,
+  "runtime_truth_spine": {
+    "source_truth": {
+      "state": "SOURCE_EXISTS",
+      "owner": "hawkinsoperations-detections",
+      "refs": [
+        "hawkinsoperations-detections/detections/successor/ho-det-001/rule.yml",
+        "hawkinsoperations-detections/detections/successor/ho-det-001/splunk.spl"
+      ]
+    },
+    "validation_truth": {
+      "state": "CONTROLLED_TEST_VALIDATED",
+      "owner": "hawkinsoperations-validation",
+      "refs": [
+        "hawkinsoperations-validation/reports/ho-det-001/validation-result.json",
+        "hawkinsoperations-validation/reports/ho-det-001/pipeline-proof.json"
+      ]
+    },
+    "runtime_truth": {
+      "state": "RUNTIME_EVIDENCE_VERIFIED_PRIVATE",
+      "public_runtime_claim_status": "PUBLIC_RUNTIME_BLOCKED",
+      "verified_runtime_evidence_refs": [
+        "HawkinsOperations/hawkinsoperations-validation#22",
+        "hawkinsoperations-validation/scripts/verify-ho-det-001-runtime-packet.py"
+      ]
+    },
+    "signal_truth": {
+      "state": "SIGNAL_OBSERVED_PRIVATE",
+      "public_signal_claim_status": "PUBLIC_RUNTIME_BLOCKED",
+      "verified_signal_record_refs": [
+        "HawkinsOperations/hawkinsoperations-validation#22",
+        "proof/records/HO-DET-001.md#controlled-runtime-signal-packet-001"
+      ]
+    },
+    "evidence_truth": {
+      "state": "RUNTIME_EVIDENCE_VERIFIED_PRIVATE",
+      "raw_private_evidence_public_safe": false,
+      "repo_contains_raw_private_evidence": false,
+      "hash_only_private_refs": true
+    },
+    "ai_triage_truth": {
+      "support_state": "AI_SUPPORT_ONLY",
+      "triage_output_state": "AI_TRIAGE_OUTPUT_PRIVATE",
+      "authority_state": "AI_NOT_AUTHORITY",
+      "ai_decided_disposition": false,
+      "human_review_required": true
+    },
+    "public_proof_truth": {
+      "state": "PUBLIC_RUNTIME_BLOCKED",
+      "proof_ceiling": "CONTROLLED_TEST_VALIDATED",
+      "public_safe_status": "NOT_PUBLIC_SAFE"
+    },
+    "human_review_truth": {
+      "state": "HUMAN_REVIEW_REQUIRED",
+      "public_runtime_summary_state": "PUBLIC_RUNTIME_BLOCKED",
+      "approval_required_for_public_summary": true
+    }
+  },
   "allowed_claims": [
     "validation PR #18 clone-runnable proof pack merged",
     "platform runtime contract enforcement exists",

contracts/schemas/ho-det-001-runtime-contract.schema.json

@@ -23,6 +23,7 @@
     "ai_may_promote",
     "ai_may_close",
     "human_review_required",
+    "runtime_truth_spine",
     "allowed_claims",
     "blocked_claims",
     "privacy_boundary",
@@ -91,6 +92,181 @@
       "type": "boolean",
       "const": true
     },
+    "runtime_truth_spine": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "source_truth",
+        "validation_truth",
+        "runtime_truth",
+        "signal_truth",
+        "evidence_truth",
+        "ai_triage_truth",
+        "public_proof_truth",
+        "human_review_truth"
+      ],
+      "properties": {
+        "source_truth": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["state", "owner", "refs"],
+          "properties": {
+            "state": { "const": "SOURCE_EXISTS" },
+            "owner": { "const": "hawkinsoperations-detections" },
+            "refs": {
+              "type": "array",
+              "minItems": 2,
+              "items": { "type": "string" }
+            }
+          }
+        },
+        "validation_truth": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["state", "owner", "refs"],
+          "properties": {
+            "state": { "const": "CONTROLLED_TEST_VALIDATED" },
+            "owner": { "const": "hawkinsoperations-validation" },
+            "refs": {
+              "type": "array",
+              "minItems": 2,
+              "items": { "type": "string" }
+            }
+          }
+        },
+        "runtime_truth": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["state", "public_runtime_claim_status", "verified_runtime_evidence_refs"],
+          "properties": {
+            "state": {
+              "enum": [
+                "RUNTIME_NOT_CAPTURED",
+                "RUNTIME_CAPTURE_STAGED_PRIVATE",
+                "RUNTIME_EVIDENCE_VERIFIED_PRIVATE"
+              ]
+            },
+            "public_runtime_claim_status": {
+              "enum": [
+                "PUBLIC_RUNTIME_BLOCKED",
+                "PUBLIC_RUNTIME_SUMMARY_ELIGIBLE",
+                "PUBLIC_RUNTIME_SUMMARY_APPROVED"
+              ]
+            },
+            "verified_runtime_evidence_refs": {
+              "type": "array",
+              "minItems": 2,
+              "items": { "type": "string" }
+            }
+          }
+        },
+        "signal_truth": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["state", "public_signal_claim_status", "verified_signal_record_refs"],
+          "properties": {
+            "state": {
+              "enum": [
+                "SIGNAL_NOT_OBSERVED",
+                "SIGNAL_OBSERVED_PRIVATE"
+              ]
+            },
+            "public_signal_claim_status": {
+              "enum": [
+                "PUBLIC_RUNTIME_BLOCKED",
+                "PUBLIC_RUNTIME_SUMMARY_ELIGIBLE",
+                "PUBLIC_RUNTIME_SUMMARY_APPROVED"
+              ]
+            },
+            "verified_signal_record_refs": {
+              "type": "array",
+              "minItems": 2,
+              "items": { "type": "string" }
+            }
+          }
+        },
+        "evidence_truth": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "state",
+            "raw_private_evidence_public_safe",
+            "repo_contains_raw_private_evidence",
+            "hash_only_private_refs"
+          ],
+          "properties": {
+            "state": {
+              "enum": [
+                "RUNTIME_NOT_CAPTURED",
+                "RUNTIME_CAPTURE_STAGED_PRIVATE",
+                "RUNTIME_EVIDENCE_VERIFIED_PRIVATE"
+              ]
+            },
+            "raw_private_evidence_public_safe": { "type": "boolean", "const": false },
+            "repo_contains_raw_private_evidence": { "type": "boolean", "const": false },
+            "hash_only_private_refs": { "type": "boolean", "const": true }
+          }
+        },
+        "ai_triage_truth": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "support_state",
+            "triage_output_state",
+            "authority_state",
+            "ai_decided_disposition",
+            "human_review_required"
+          ],
+          "properties": {
+            "support_state": {
+              "enum": ["AI_NOT_USED", "AI_SUPPORT_ONLY"]
+            },
+            "triage_output_state": {
+              "enum": ["AI_NOT_USED", "AI_TRIAGE_OUTPUT_PRIVATE", "AI_TRIAGE_REVIEWED"]
+            },
+            "authority_state": { "const": "AI_NOT_AUTHORITY" },
+            "ai_decided_disposition": { "type": "boolean", "const": false },
+            "human_review_required": { "type": "boolean", "const": true }
+          }
+        },
+        "public_proof_truth": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["state", "proof_ceiling", "public_safe_status"],
+          "properties": {
+            "state": {
+              "enum": [
+                "PUBLIC_RUNTIME_BLOCKED",
+                "PUBLIC_RUNTIME_SUMMARY_ELIGIBLE",
+                "PUBLIC_RUNTIME_SUMMARY_APPROVED"
+              ]
+            },
+            "proof_ceiling": { "const": "CONTROLLED_TEST_VALIDATED" },
+            "public_safe_status": { "const": "NOT_PUBLIC_SAFE" }
+          }
+        },
+        "human_review_truth": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "state",
+            "public_runtime_summary_state",
+            "approval_required_for_public_summary"
+          ],
+          "properties": {
+            "state": { "const": "HUMAN_REVIEW_REQUIRED" },
+            "public_runtime_summary_state": {
+              "enum": [
+                "PUBLIC_RUNTIME_BLOCKED",
+                "PUBLIC_RUNTIME_SUMMARY_ELIGIBLE",
+                "PUBLIC_RUNTIME_SUMMARY_APPROVED"
+              ]
+            },
+            "approval_required_for_public_summary": { "type": "boolean", "const": true }
+          }
+        }
+      }
+    },
     "allowed_claims": {
       "type": "array",
       "minItems": 4,

scripts/verify-ho-det-001-runtime-contract.py

@@ -30,6 +30,17 @@
     "human_review_required": True,
 }
 
+REQUIRED_TRUTH_PLANES = {
+    "source_truth",
+    "validation_truth",
+    "runtime_truth",
+    "signal_truth",
+    "evidence_truth",
+    "ai_triage_truth",
+    "public_proof_truth",
+    "human_review_truth",
+}
+
 BLOCKED_ALLOWED_CLAIM_PATTERNS = [
     r"runtime-active",
     r"signal-observed",
@@ -159,12 +170,64 @@ def require_blocked_claim_inventory(sample: dict) -> None:
         fail(f"missing blocked_claims entries: {', '.join(missing)}")
 
 
+def require_truth_spine(sample: dict) -> None:
+    spine = sample.get("runtime_truth_spine")
+    if not isinstance(spine, dict):
+        fail("runtime_truth_spine must be an object")
+    missing = sorted(REQUIRED_TRUTH_PLANES - set(spine))
+    if missing:
+        fail(f"runtime_truth_spine missing truth planes: {', '.join(missing)}")
+
+    if spine["runtime_truth"].get("state") != "RUNTIME_EVIDENCE_VERIFIED_PRIVATE":
+        fail("runtime_truth.state must remain RUNTIME_EVIDENCE_VERIFIED_PRIVATE")
+    if spine["runtime_truth"].get("public_runtime_claim_status") != "PUBLIC_RUNTIME_BLOCKED":
+        fail("runtime_truth.public_runtime_claim_status must remain PUBLIC_RUNTIME_BLOCKED")
+    if len(spine["runtime_truth"].get("verified_runtime_evidence_refs", [])) < 2:
+        fail("runtime_truth requires verified runtime evidence refs before any runtime summary change")
+
+    if spine["signal_truth"].get("state") != "SIGNAL_OBSERVED_PRIVATE":
+        fail("signal_truth.state must remain SIGNAL_OBSERVED_PRIVATE")
+    if spine["signal_truth"].get("public_signal_claim_status") != "PUBLIC_RUNTIME_BLOCKED":
+        fail("signal_truth.public_signal_claim_status must remain PUBLIC_RUNTIME_BLOCKED")
+    if len(spine["signal_truth"].get("verified_signal_record_refs", [])) < 2:
+        fail("signal_truth requires verified signal record refs before any signal summary change")
+
+    evidence = spine["evidence_truth"]
+    if evidence.get("repo_contains_raw_private_evidence") is not False:
+        fail("evidence_truth.repo_contains_raw_private_evidence must remain false")
+    if evidence.get("raw_private_evidence_public_safe") is not False:
+        fail("evidence_truth.raw_private_evidence_public_safe must remain false")
+
+    ai = spine["ai_triage_truth"]
+    if ai.get("support_state") != "AI_SUPPORT_ONLY":
+        fail("ai_triage_truth.support_state must remain AI_SUPPORT_ONLY")
+    if ai.get("triage_output_state") != "AI_TRIAGE_OUTPUT_PRIVATE":
+        fail("ai_triage_truth.triage_output_state must remain AI_TRIAGE_OUTPUT_PRIVATE")
+    if ai.get("authority_state") != "AI_NOT_AUTHORITY":
+        fail("ai_triage_truth.authority_state must remain AI_NOT_AUTHORITY")
+    if ai.get("ai_decided_disposition") is not False:
+        fail("ai_triage_truth.ai_decided_disposition must remain false")
+
+    public = spine["public_proof_truth"]
+    if public.get("state") != "PUBLIC_RUNTIME_BLOCKED":
+        fail("public_proof_truth.state must remain PUBLIC_RUNTIME_BLOCKED")
+    if public.get("public_safe_status") != "NOT_PUBLIC_SAFE":
+        fail("public_proof_truth.public_safe_status must remain NOT_PUBLIC_SAFE")
+
+    human = spine["human_review_truth"]
+    if human.get("public_runtime_summary_state") != "PUBLIC_RUNTIME_BLOCKED":
+        fail("human_review_truth.public_runtime_summary_state must remain PUBLIC_RUNTIME_BLOCKED")
+    if human.get("approval_required_for_public_summary") is not True:
+        fail("human_review_truth.approval_required_for_public_summary must remain true")
+
+
 def main() -> int:
     sample = load_json(SAMPLE_PATH)
     schema = load_json(SCHEMA_PATH)
 
     validate_schema_if_possible(sample, schema)
     require_expected_values(sample)
+    require_truth_spine(sample)
     require_privacy_boundary(sample)
     require_blocked_claim_inventory(sample)
     reject_promoted_allowed_claims(sample)
@@ -177,6 +240,8 @@ def main() -> int:
     print("PROMOTION_STATUS=BLOCKED")
     print("RUNTIME_ACTIVE=false")
     print("SIGNAL_OBSERVED=false")
+    print("PUBLIC_RUNTIME_CLAIM_STATUS=PUBLIC_RUNTIME_BLOCKED")
+    print("AI_TRIAGE_TRUTH=AI_SUPPORT_ONLY/AI_TRIAGE_OUTPUT_PRIVATE/AI_NOT_AUTHORITY")
     print("AI_DECIDED_DISPOSITION=false")
     return 0