Refactor artifact file handling in evidence.py

Author: BryceWDesign

ix/evidence.py

@@ -42,6 +42,26 @@ def write_bundle(
         generated_at = datetime.now(UTC).isoformat().replace("+00:00", "Z")
         source_hash = self._sha256_file(source_file)
         result_payload = result.to_dict()
+        contract_metadata = self._contract_metadata(result)
+        contract_counts = self._contract_counts(contract_metadata)
+
+        artifact_files = [
+            "summary.json",
+            "trace.json",
+            "policies.json",
+            "tool-results.json",
+            "handoffs.json",
+            "branches.json",
+            "approvals-required.json",
+            "contract.json",
+            "obligations.json",
+            "falsification-gates.json",
+            "claim-boundaries.json",
+            "outputs.txt",
+            "replies.txt",
+            "assurance-claims.md",
+            "limitations.md",
+        ]
 
         files: list[Path] = []
         files.append(
@@ -55,19 +75,7 @@ def write_bundle(
                     "source_file": str(source_file),
                     "source_sha256": source_hash,
                     "status": result.status,
-                    "artifact_files": [
-                        "summary.json",
-                        "trace.json",
-                        "policies.json",
-                        "tool-results.json",
-                        "handoffs.json",
-                        "branches.json",
-                        "approvals-required.json",
-                        "outputs.txt",
-                        "replies.txt",
-                        "assurance-claims.md",
-                        "limitations.md",
-                    ],
+                    "artifact_files": artifact_files,
                 },
             )
         )
@@ -88,6 +96,14 @@ def write_bundle(
                         "handoffs": len(result.handoffs),
                         "branches": len(result.branches),
                         "approvals_required": len(result.approvals_required),
+                        "contract_attempts": contract_counts["attempts"],
+                        "contract_obligations": contract_counts["obligations"],
+                        "contract_evidence_requirements": contract_counts[
+                            "evidence_requirements"
+                        ],
+                        "contract_falsification_gates": contract_counts[
+                            "falsification_gates"
+                        ],
                     },
                     "variables": result_payload["variables"],
                     "memory": result_payload["memory"],
@@ -99,14 +115,136 @@ def write_bundle(
         files.append(self._write_json(output_dir / "tool-results.json", result.tool_results))
         files.append(self._write_json(output_dir / "handoffs.json", result.handoffs))
         files.append(self._write_json(output_dir / "branches.json", result.branches))
-        files.append(self._write_json(output_dir / "approvals-required.json", result.approvals_required))
+        files.append(
+            self._write_json(output_dir / "approvals-required.json", result.approvals_required)
+        )
+        files.append(self._write_json(output_dir / "contract.json", contract_metadata))
+        files.append(
+            self._write_json(
+                output_dir / "obligations.json",
+                self._obligations_payload(contract_metadata),
+            )
+        )
+        files.append(
+            self._write_json(
+                output_dir / "falsification-gates.json",
+                self._falsification_payload(contract_metadata),
+            )
+        )
+        files.append(
+            self._write_json(
+                output_dir / "claim-boundaries.json",
+                self._claim_boundaries_payload(contract_metadata),
+            )
+        )
         files.append(self._write_text(output_dir / "outputs.txt", "\n".join(result.outputs) + "\n"))
         files.append(self._write_text(output_dir / "replies.txt", "\n".join(result.replies) + "\n"))
         files.append(self._write_text(output_dir / "assurance-claims.md", self._claims_text(result)))
         files.append(self._write_text(output_dir / "limitations.md", self._limitations_text()))
 
         return EvidenceBundle(output_dir=output_dir, files=tuple(files))
 
+    def _contract_metadata(self, result: ExecutionResult) -> dict[str, Any]:
+        metadata = getattr(result, "contract_metadata", None)
+        if isinstance(metadata, dict):
+            return metadata
+        return {
+            "contract_type": "ix.cognition.contracts",
+            "schema_version": "1.0",
+            "runtime_semantics": "metadata_only_not_executed",
+            "counts": {
+                "attempts": 0,
+                "obligations": 0,
+                "evidence_requirements": 0,
+                "falsification_gates": 0,
+            },
+            "attempts": [],
+        }
+
+    def _contract_counts(self, metadata: dict[str, Any]) -> dict[str, int]:
+        counts = metadata.get("counts", {})
+        if not isinstance(counts, dict):
+            counts = {}
+        return {
+            "attempts": int(counts.get("attempts", 0)),
+            "obligations": int(counts.get("obligations", 0)),
+            "evidence_requirements": int(counts.get("evidence_requirements", 0)),
+            "falsification_gates": int(counts.get("falsification_gates", 0)),
+        }
+
+    def _obligations_payload(self, metadata: dict[str, Any]) -> dict[str, Any]:
+        obligations: list[dict[str, Any]] = []
+        for attempt in self._attempts(metadata):
+            attempt_name = str(attempt.get("name", ""))
+            for obligation in self._obligations(attempt):
+                obligations.append(
+                    {
+                        "attempt": attempt_name,
+                        "id": obligation.get("id"),
+                        "source": obligation.get("source"),
+                        "evidence_required": list(obligation.get("evidence_required", [])),
+                        "falsify_if": list(obligation.get("falsify_if", [])),
+                    }
+                )
+        return {
+            "schema_version": "1.0",
+            "runtime_semantics": metadata.get("runtime_semantics"),
+            "obligations": obligations,
+        }
+
+    def _falsification_payload(self, metadata: dict[str, Any]) -> dict[str, Any]:
+        gates: list[dict[str, Any]] = []
+        for attempt in self._attempts(metadata):
+            attempt_name = str(attempt.get("name", ""))
+            for obligation in self._obligations(attempt):
+                obligation_id = obligation.get("id")
+                for condition in obligation.get("falsify_if", []):
+                    gates.append(
+                        {
+                            "attempt": attempt_name,
+                            "obligation": obligation_id,
+                            "condition": condition,
+                        }
+                    )
+        return {
+            "schema_version": "1.0",
+            "runtime_semantics": metadata.get("runtime_semantics"),
+            "falsification_gates": gates,
+        }
+
+    def _claim_boundaries_payload(self, metadata: dict[str, Any]) -> dict[str, Any]:
+        attempts: list[dict[str, Any]] = []
+        for attempt in self._attempts(metadata):
+            attempts.append(
+                {
+                    "attempt": attempt.get("name"),
+                    "purpose": list(attempt.get("purpose", [])),
+                    "non_goals": list(attempt.get("non_goals", [])),
+                    "claim_boundaries": list(attempt.get("claim_boundaries", [])),
+                    "human_approval_required": list(
+                        attempt.get("human_approval_required", [])
+                    ),
+                    "handoff_contracts": list(attempt.get("handoff_contracts", [])),
+                }
+            )
+        return {
+            "schema_version": "1.0",
+            "runtime_semantics": metadata.get("runtime_semantics"),
+            "attempts": attempts,
+        }
+
+    def _attempts(self, metadata: dict[str, Any]) -> list[dict[str, Any]]:
+        attempts = metadata.get("attempts", [])
+        if not isinstance(attempts, list):
+            return []
+        return [attempt for attempt in attempts if isinstance(attempt, dict)]
+
+    def _obligations(self, attempt: dict[str, Any]) -> list[dict[str, Any]]:
+        obligations = attempt.get("obligations", [])
+        if not isinstance(obligations, list):
+            return []
+        return [obligation for obligation in obligations if isinstance(obligation, dict)]
+
     def _write_json(self, path: Path, payload: Any) -> Path:
         path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
         return path
@@ -123,6 +261,8 @@ def _sha256_file(self, path: Path) -> str:
         return digest.hexdigest()
 
     def _claims_text(self, result: ExecutionResult) -> str:
+        contract_metadata = self._contract_metadata(result)
+        contract_counts = self._contract_counts(contract_metadata)
         return (
             "# IX Assurance Claims\n\n"
             "This evidence bundle supports only bounded, runtime-observed claims.\n\n"
@@ -133,10 +273,14 @@ def _claims_text(self, result: ExecutionResult) -> str:
             f"- Tool results captured: {len(result.tool_results)}.\n"
             f"- Agent handoffs captured: {len(result.handoffs)}.\n"
             f"- Conditional branches captured: {len(result.branches)}.\n"
-            f"- Human approval requirements captured: {len(result.approvals_required)}.\n\n"
+            f"- Human approval requirements captured: {len(result.approvals_required)}.\n"
+            f"- Cognition attempt contracts captured: {contract_counts['attempts']}.\n"
+            f"- Cognition obligations captured: {contract_counts['obligations']}.\n\n"
             "## Not claimed\n\n"
             "- This bundle does not certify the script as safe, complete, lawful, or production-ready.\n"
             "- This bundle does not prove external system behavior beyond the deterministic IX runtime output.\n"
+            "- This bundle does not execute or certify cognition-contract obligations.\n"
+            "- This bundle does not certify AGI, AGI-candidate status, or deployment readiness.\n"
             "- This bundle does not replace human review.\n"
         )
 
@@ -149,5 +293,9 @@ def _limitations_text(self) -> str:
             "automation, or legal compliance.\n\n"
             "Current IX built-in tools are deterministic and side-effect free. External network, "
             "email, filesystem mutation, procurement, deployment, and real-world actuation tools "
-            "are intentionally not part of this bundle model.\n"
+            "are intentionally not part of this bundle model.\n\n"
+            "Cognition-contract artifacts are declarative metadata. They record the contract, "
+            "obligations, claim boundaries, and falsification gates that a downstream cognition "
+            "system may later attempt. They do not execute cognition, prove learning, prove "
+            "transfer, certify AGI, or authorize self-approval.\n"
         )