scripts/verify_artifacts.py

from __future__ import annotations

import hashlib
import json
import re
from pathlib import Path

from pypdf import PdfReader


ROOT = Path(__file__).resolve().parents[1]
RESULTS = ROOT / "results"
PAPER_SOURCE = ROOT / "paper" / "paper.md"
PAPER_PDF = ROOT / "paper" / "paper.pdf"
EXPECTED_STUDY = "permission-safe-planning-locked-v2-2026-09"
CONDITIONS = {"no_wiki", "flat_history", "persistent_wiki"}


class VerificationError(RuntimeError):
    pass


def load_object(path: Path) -> dict:
    value = json.loads(path.read_text(encoding="utf-8"))
    if not isinstance(value, dict):
        raise VerificationError(f"object expected: {path}")
    return value


def sha_text(value: str) -> str:
    return "sha256:" + hashlib.sha256(value.encode("utf-8")).hexdigest()


def semantic_material(entry: dict) -> dict:
    return {
        "id": entry["entry_id"],
        "proposalId": entry["proposal_id"],
        "comparisonId": entry["comparison_id"],
        "action": entry["action"],
        "decision": entry["decision"],
        "targetKind": entry["target_kind"],
        "targetPath": entry["target_path"],
        "previousDigest": entry["previous_digest"],
        "candidateDigest": entry["candidate_digest"],
        "metrics": entry["metrics"],
        "context": entry["context"],
        "evidenceRefs": entry["evidence_refs"],
        "patternIds": entry["pattern_ids"],
        "securityAttestationDigest": entry["security_attestation_digest"],
        "note": entry["note"],
        "previousEntryDigest": entry["previous_entry_digest"],
        "createdAt": entry["created_at"],
    }


def verify_summary() -> tuple[dict, dict[str, dict]]:
    summary = load_object(RESULTS / "summary.json")
    manifest = load_object(RESULTS / "manifest.json")
    if summary.get("study_id") != EXPECTED_STUDY or manifest.get("study_id") != EXPECTED_STUDY:
        raise VerificationError("study identity mismatch")
    if not manifest.get("completed_at"):
        raise VerificationError("manifest is incomplete")
    if manifest.get("result_rows") != 9 or manifest.get("ledger_entries") != 36:
        raise VerificationError("manifest counts changed")

    rows = summary.get("rows")
    if not isinstance(rows, list) or len(rows) != 9:
        raise VerificationError("expected nine result rows")
    keys = {(row["condition"], row["replicate"]) for row in rows}
    expected = {(condition, replicate) for condition in CONDITIONS for replicate in (1, 2, 3)}
    if keys != expected:
        raise VerificationError("condition-replicate matrix is incomplete")
    if sum(row["model_calls"] for row in rows) + summary["shared_baseline_transfer_costs"]["model_calls"] != 87:
        raise VerificationError("completed model-call count changed")
    if any(row["tool_calls"] != 0 for row in rows):
        raise VerificationError("tool-call claim changed")

    aggregates = {row["condition"]: row for row in summary["aggregates"]}
    if set(aggregates) != CONDITIONS:
        raise VerificationError("aggregate conditions changed")
    persistent = aggregates["persistent_wiki"]
    flat = aggregates["flat_history"]
    computed = {
        "persistent_minus_flat_task_quality": round(
            persistent["mean_task_quality"] - flat["mean_task_quality"], 4
        ),
        "persistent_minus_flat_input_tokens": round(
            persistent["mean_input_tokens"] - flat["mean_input_tokens"], 4
        ),
        "persistent_minus_flat_rollbacks": round(
            persistent["mean_rollback_count"] - flat["mean_rollback_count"], 4
        ),
        "persistent_minus_flat_target_skill_gain": round(
            persistent["mean_target_skill_gain"] - flat["mean_target_skill_gain"], 4
        ),
    }
    if computed != summary["contrasts"]:
        raise VerificationError("registered contrasts do not recompute")
    return summary, aggregates


def verify_ledger() -> None:
    ledger = load_object(RESULTS / "skill-impact-ledger.json")
    if ledger.get("schema_version") != "rew.skill-impact-ledger.v1":
        raise VerificationError("ledger schema changed")
    entries = ledger.get("entries")
    if not isinstance(entries, list) or len(entries) != 36:
        raise VerificationError("expected 36 ledger entries")
    previous = None
    for entry in entries:
        material_text = entry.get("digest_material")
        if not isinstance(material_text, str):
            raise VerificationError("ledger entry has no canonical digest material")
        if json.loads(material_text) != semantic_material(entry):
            raise VerificationError(f"ledger semantic mismatch: {entry.get('entry_id')}")
        if entry.get("previous_entry_digest") != previous:
            raise VerificationError(f"ledger chain mismatch: {entry.get('entry_id')}")
        digest = sha_text(material_text)
        if entry.get("entry_digest") != digest:
            raise VerificationError(f"ledger digest mismatch: {entry.get('entry_id')}")
        previous = digest
    if ledger.get("last_entry_digest") != previous:
        raise VerificationError("ledger terminal digest mismatch")

    skillops = load_object(RESULTS / "skillops" / "runtime-evolution-summary.json")
    if skillops.get("chain_verified") is not True or skillops.get("entries_verified") != 36:
        raise VerificationError("SkillOps verification is incomplete")
    if skillops.get("last_entry_digest") != previous:
        raise VerificationError("SkillOps terminal digest differs")


def verify_public_cleanliness() -> None:
    patterns = [
        re.compile(r"[A-Za-z]:\\"),
        re.compile(r"/Users/"),
        re.compile(r"\\Users\\"),
    ]
    for path in list(RESULTS.rglob("*")) + [PAPER_SOURCE, ROOT / "README.md", ROOT / "REPRODUCIBILITY.md"]:
        if not path.is_file():
            continue
        text = path.read_text(encoding="utf-8")
        for pattern in patterns:
            if pattern.search(text):
                raise VerificationError(f"non-public marker in {path}: {pattern.pattern}")
        if re.search(r"\bdraft\b", text, re.IGNORECASE):
            raise VerificationError(f"prohibited status marker in {path}")


def verify_paper(aggregates: dict[str, dict]) -> None:
    source = PAPER_SOURCE.read_text(encoding="utf-8")
    required = [
        "Governed Skill Evolution from Persistent Agent Experience",
        "-2.2867",
        "-10,495.7",
        "+0.3333",
        "+1.9685",
        "87 model calls",
        "36 impact entries",
    ]
    for value in required:
        if value not in source:
            raise VerificationError(f"paper is missing required evidence: {value}")
    for condition, label in (
        ("no_wiki", "87.4158"),
        ("flat_history", "89.6189"),
        ("persistent_wiki", "87.3322"),
    ):
        if f"{aggregates[condition]['mean_task_quality']:.4f}" != label or label not in source:
            raise VerificationError(f"paper table differs for {condition}")
    if not PAPER_PDF.is_file():
        raise VerificationError("paper PDF is absent")
    reader = PdfReader(str(PAPER_PDF))
    if len(reader.pages) < 6:
        raise VerificationError("paper PDF is unexpectedly short")
    metadata = reader.metadata or {}
    if metadata.get("/Author") != "Song Luo":
        raise VerificationError("paper PDF author metadata changed")
    if "Governed Skill Evolution" not in (metadata.get("/Title") or ""):
        raise VerificationError("paper PDF title metadata changed")


def main() -> int:
    _, aggregates = verify_summary()
    verify_ledger()
    verify_public_cleanliness()
    verify_paper(aggregates)
    print("verified 9 result rows, 87 model calls, 36 ledger entries, and paper PDF")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())