CC: prepare generic VISION package candidate

tools/validate_visual_evidence_contract.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""Validate the Visual Evidence contract and pure adapter proof."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "src"))
+
+REQUIRED_FIELDS = [
+    "producing_package_id",
+    "producing_tool_id",
+    "capability_surface",
+    "source_reference",
+    "provider_mode",
+    "retention_disclosure",
+    "observed_content_summary",
+    "extracted_claims",
+    "confidence",
+    "caveats",
+    "timestamp",
+    "validation_status",
+]
+
+
+def main() -> int:
+    errors: list[str] = []
+    required = [
+        "docs/VISUAL-EVIDENCE-CONTRACT.md",
+        "candidate-manifests/visual-evidence-contract.json",
+        "src/svrnty_vision/visual_evidence.py",
+        "tests/test_visual_evidence.py",
+    ]
+    for rel in required:
+        if not (ROOT / rel).exists():
+            errors.append(f"missing:{rel}")
+
+    manifest = _read_json(ROOT / "candidate-manifests/visual-evidence-contract.json", errors)
+    if manifest:
+        _expect(manifest.get("required_fields") == REQUIRED_FIELDS, "required_fields_mismatch", errors)
+        proof = manifest.get("first_vertical_proof", {})
+        _expect(proof.get("source_tool_id") == "vision.image_analyze", "proof_tool_mismatch", errors)
+        _expect(proof.get("live_provider_call_required") is False, "live_provider_required", errors)
+        handoff = manifest.get("research_handoff", {})
+        _expect(handoff.get("research_may_consume_visual_evidence") is True, "research_handoff_missing", errors)
+        _expect(handoff.get("vision_may_write_research_capsules") is False, "vision_writes_capsules", errors)
+        _expect(handoff.get("vision_may_perform_research_synthesis") is False, "vision_research_synthesis", errors)
+
+    _check_snippets(
+        "docs/VISUAL-EVIDENCE-CONTRACT.md",
+        [
+            "`producing_package_id`",
+            "Research owns synthesis and capsule writing",
+            "does not call a live provider",
+        ],
+        errors,
+    )
+    _validate_adapter(errors)
+
+    result = {
+        "ok": not errors,
+        "validator": "visual-evidence-contract-v1",
+        "checked": required,
+        "errors": errors,
+        "warnings": [],
+    }
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0 if result["ok"] else 1
+
+
+def _validate_adapter(errors: list[str]) -> None:
+    try:
+        from types import SimpleNamespace
+
+        from svrnty_vision.visual_evidence import visual_evidence_from_vlm_response
+    except Exception as exc:  # pragma: no cover - validator import report
+        errors.append(f"adapter_import_failed:{type(exc).__name__}:{exc}")
+        return
+
+    response = SimpleNamespace(
+        rubric_mode="raw",
+        justification="",
+        model_id="qwen-test",
+        raw_scores_json='{"description":"solid red square","objects":["red square"],"detected_text":[]}',
+    )
+    evidence = visual_evidence_from_vlm_response(
+        response,
+        source_reference="fixture://red-square.png",
+        provider_mode="sovereign",
+        retention_disclosure="synchronous_no_async_persistence",
+        timestamp="2026-06-06T00:00:00Z",
+    )
+    dumped = evidence.model_dump()
+    for field in REQUIRED_FIELDS:
+        if field not in dumped:
+            errors.append(f"adapter_missing_field:{field}")
+    _expect(dumped.get("producing_package_id") == "visual-perception-package-candidate", "adapter_package_mismatch", errors)
+    _expect(dumped.get("producing_tool_id") == "vision.image_analyze", "adapter_tool_mismatch", errors)
+    _expect(dumped.get("observed_content_summary") == "solid red square", "adapter_summary_mismatch", errors)
+    _expect("description: solid red square" in dumped.get("extracted_claims", []), "adapter_claim_missing", errors)
+
+
+def _read_json(path: Path, errors: list[str]) -> dict | None:
+    if not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        errors.append(f"{path.relative_to(ROOT)}:json:{exc}")
+        return None
+
+
+def _check_snippets(rel: str, snippets: list[str], errors: list[str]) -> None:
+    path = ROOT / rel
+    if not path.exists():
+        return
+    text = path.read_text(encoding="utf-8")
+    for snippet in snippets:
+        if snippet not in text:
+            errors.append(f"{rel}:missing:{snippet}")
+
+
+def _expect(condition: bool, error: str, errors: list[str]) -> None:
+    if not condition:
+        errors.append(error)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())