#!/usr/bin/env python3 """Snapshot participant campaign coverage; infrastructure diagnostics have no score here.""" from __future__ import annotations import argparse import csv from datetime import datetime, timezone import hashlib import importlib.util import json from pathlib import Path import re def local_module(name: str, relative: str): spec = importlib.util.spec_from_file_location(name, Path(__file__).parent / relative) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module audit = local_module("coverage_record_audit", "../audits/closed_run.py") progress = local_module("coverage_progress", "progress.py") FIELDS = ( "case_index", "task", "protocol_version", "reference_horizon", "reference_horizon_source", "decision_limit", "control_limit", "replan_prefix", "attempt_status", "record_consistency", "episode_status", "native_final_success", "controls", "decisions", "first_success_control", "first_success_decision", "complete_step_coverage", "termination_reason", "issue", "evidence_caveats", ) def bounded_text(value, limit: int) -> bool: return (isinstance(value, str) and bool(value.strip()) and len(value) <= limit and not any(0xD800 <= ord(char) <= 0xDFFF for char in value)) def same_json(left, right) -> bool: """Keep boolean, integer and floating-point declarations distinct.""" return json.dumps(left, sort_keys=True, allow_nan=False) == json.dumps(right, sort_keys=True, allow_nan=False) def infrastructure_diagnostic(manifest: dict) -> bool: policy = manifest.get("policy", {}) policy = policy if isinstance(policy, dict) else {} parameters = policy.get("parameters", {}) parameters = parameters if isinstance(parameters, dict) else {} return (manifest.get("purpose") == "infrastructure_validation_only" or parameters.get("purpose") == "infrastructure_validation_only" or policy.get("name") == "constant-action-diagnostic") def bind_policy(source: dict, manifest: dict) -> None: """Compare retained declarations, without loading a model or rewriting old schemas.""" expected, actual = manifest.get("policy"), source.get("policy") audit.require(isinstance(expected, dict) and isinstance(actual, dict), "missing campaign/run policy identity") for key in ("name", "kind"): audit.require(isinstance(expected.get(key), str) and bool(expected[key].strip()) and same_json(actual.get(key), expected[key]), f"campaign/run policy {key} mismatch") # Old campaigns do not declare the transport version; only bind optional # fields they actually contain. Missing model/provider remains unknown. for key in (set(expected) | {"model", "provider"}) - {"name", "kind", "parameters"}: audit.require(same_json(actual.get(key), expected.get(key)), f"campaign/run policy {key} mismatch") declared, parameters = expected.get("parameters", {}), actual.get("parameters", {}) audit.require(isinstance(declared, dict) and isinstance(parameters, dict), "invalid campaign/run policy parameters") for key, value in declared.items(): audit.require(key in parameters and same_json(parameters[key], value), f"campaign/run policy parameter {key} mismatch") audit.require(same_json(parameters.get("purpose"), declared.get("purpose")), "campaign/run policy diagnostic purpose mismatch") audit.require(not infrastructure_diagnostic(source), "infrastructure diagnostic run cannot count as participant coverage") for key in ("model_profile", "policy_stop_rule"): if key in manifest or key in parameters: audit.require(isinstance(manifest.get(key), dict) and isinstance(parameters.get(key), dict) and same_json(parameters[key], manifest[key]), f"campaign/run {key} mismatch") if "policy_prompt" in manifest or "policy_prompt_sha256" in manifest: prompt_hash = manifest.get("policy_prompt_sha256") if "policy_prompt" in manifest: prompt = manifest["policy_prompt"] audit.require(isinstance(prompt, str), "invalid campaign policy prompt") computed = hashlib.sha256(prompt.encode("utf-8")).hexdigest() audit.require(prompt_hash is None or prompt_hash == computed, "campaign policy prompt digest mismatch") prompt_hash = computed audit.require(isinstance(prompt_hash, str) and re.fullmatch(r"[0-9a-f]{64}", prompt_hash) and parameters.get("prompt_sha256") == prompt_hash, "campaign/run policy prompt mismatch") if "policy_parameters" in manifest: settings = manifest["policy_parameters"] audit.require(isinstance(settings, dict), "invalid campaign policy configuration") for key, value in settings.items(): recorded = (parameters.get("policy_stop_rule", {}) if key == "min_action_decisions_before_give_up" else parameters) audit.require(isinstance(recorded, dict) and key in recorded and same_json(recorded[key], value), f"campaign/run policy configuration {key} mismatch") # Historical v1 stopping metadata stays in its original protocol domain. protocol = source["protocol"] for key in ("min_action_decisions_before_give_up", "stop_constraint_version", "early_policy_stop_exception"): if key in manifest or key in protocol: default = 0 if key == "min_action_decisions_before_give_up" else None audit.require(same_json(protocol.get(key, default), manifest.get(key, default)), f"campaign/run historical policy configuration {key} mismatch") def attach_caveats(rows: list[dict], campaign: Path, campaign_digest: str, source: Path | None) -> dict | None: """Attach operator annotations without changing a result or following evidence links.""" if source is None: return None source = source.absolute() audit.require(not source.resolve().is_relative_to(campaign), "caveat source must be outside campaign") files = audit.ClosedFiles(source.parent) payload = files.raw(source.name) audit.require(len(payload) <= 1024 * 1024, "caveat source exceeds 1 MiB") document = audit.decode(payload.decode("utf-8")) audit.require(isinstance(document, dict) and set(document) == { "schema_version", "campaign_sha256", "entries"}, "invalid caveat document fields") audit.require(document["schema_version"] == "starvla-rsi.evidence-caveats/v1", "unsupported caveat schema") audit.require(document["campaign_sha256"] == campaign_digest, "caveat campaign mismatch") entries = document["entries"] audit.require(isinstance(entries, list) and len(entries) <= len(rows) * 16, "invalid caveat entry list") seen = set() for entry in entries: audit.require(isinstance(entry, dict) and set(entry) == { "case_index", "category", "note", "declared_evidence"}, "invalid caveat entry fields") index, category = entry["case_index"], entry["category"] audit.require(type(index) is int and 0 <= index < len(rows), "invalid caveat case index") audit.require(rows[index]["attempt_status"] in ("completed", "infrastructure_or_policy_error"), "caveats require a validated terminal outcome; active/unattempted/invalid cases are not annotated") audit.require(isinstance(category, str) and re.fullmatch(r"[a-z][a-z0-9_]{0,63}", category), "invalid caveat category") audit.require((index, category) not in seen, "duplicate case/category caveat") seen.add((index, category)) audit.require(len(rows[index]["evidence_caveats"]) < 16, "too many caveats for one case") audit.require(bounded_text(entry["note"], 2048), "invalid caveat note") evidence = entry["declared_evidence"] audit.require(isinstance(evidence, list) and 0 < len(evidence) <= 16, "invalid caveat evidence list") for item in evidence: audit.require(isinstance(item, dict) and set(item) == {"reference", "sha256"}, "invalid declared evidence fields") audit.require(bounded_text(item["reference"], 512), "invalid declared evidence reference") audit.require(isinstance(item["sha256"], str) and re.fullmatch(r"[0-9a-f]{64}", item["sha256"]), "invalid declared evidence hash") # Deliberately never merge arbitrary input keys into the score/counter row. rows[index]["evidence_caveats"].append(entry) files.verify_unchanged() return {"path": str(files.root / source.name), "sha256": files.hashes[source.name], "entries": len(entries), "annotated_cases": len({index for index, _ in seen}), "interpretation": "Operator annotations only; evidence references/hashes are declared, not followed or verified here; no score or denominator is changed."} def closed_case(files, case: dict, manifest: dict, digest: str) -> dict: directory = case["case_id"] attempt = files.json(f"{directory}/attempt.json") audit.require(attempt["case_index"] == case["index"] and attempt["attempt"] == 1 and attempt["campaign_sha256"] == digest, "attempt/campaign mismatch") outcome = files.json(f"{directory}/outcome.json") audit.require(outcome["case_index"] == case["index"], "outcome case mismatch") audit.require(outcome["status"] in ("completed", "infrastructure_or_policy_error"), "unsupported terminal outcome") row = {"attempt_status": outcome["status"], "record_consistency": "unavailable"} run = files.root / directory / "run" status_path = run / "status.json" if not status_path.exists(): audit.require(outcome["status"] != "completed", "completed outcome has no closed run") return {**row, "issue": "terminal error has no closed runner record; attempt retained"} status = files.json(f"{directory}/run/status.json") audit.require(isinstance(status, dict), "closed runner status must be a JSON object") if status.get("status") not in ("completed", "completed_with_errors"): audit.require(outcome["status"] != "completed", "completed outcome has an unclosed run") return {**row, "issue": "terminal error has an incomplete runner record; attempt retained"} checked = audit.audit_run(run) for relative, expected in checked["read_file_sha256"].items(): bound = f"{directory}/run/{relative}" files.raw(bound) audit.require(files.hashes[bound] == expected, "closed evidence changed after audit") records = files.jsonl(f"{directory}/run/episodes.jsonl") audit.require(len(records) == 1 and records[0]["episode"] == case["episode"], "run episode differs from frozen case") source = files.json(f"{directory}/run/manifest.json") bind_policy(source, manifest) audit.require(source["benchmark"] == case["descriptor"] and source["benchmark"]["name"] == manifest["benchmark"], "benchmark descriptor mismatch") for key in ("seed", "budget_mode", "max_policy_calls", "replan_interval", "max_steps"): audit.require(source["protocol"][key] == manifest[key], f"frozen {key} mismatch") audit.require(source["harness_source"]["inventory_sha256"] == manifest["harness_source"]["inventory_sha256"], "campaign/run source mismatch") summary = files.json(f"{directory}/run/summary.json") audit.require(outcome["summary"] == summary, "outcome/run summary mismatch") expected = (outcome["returncode"] == 0 and not outcome["timed_out"] and summary["errors"] == 0) audit.require((outcome["status"] == "completed") == expected, "outcome lifecycle mismatch") timing = progress.summarize_progress(run)["episodes"] audit.require(len(timing) == 1 and timing[0]["episode"] == records[0]["episode"], "progress episode mismatch") timing = timing[0] record = records[0] return {**row, "record_consistency": "passed", "episode_status": record["status"], "native_final_success": record["success"], "controls": record["environment_steps"], "decisions": record["policy_calls"], "first_success_control": timing["first_native_success_step"], "first_success_decision": timing["policy_call_at_first_native_success"], "complete_step_coverage": timing["complete_step_coverage"], "termination_reason": record["termination_reason"], "record_auditor_sha256": checked["auditor"]["sha256"]} def summarize(campaign: Path, caveats: Path | None = None) -> dict: # An external reporter may intentionally use campaign-frozen audit modules. # Record the actual loaded locations instead of assuming one repository root. tool_paths = {"benchkit/audits/closed_run.py": Path(audit.__file__).resolve(), "benchkit/reports/progress.py": Path(progress.__file__).resolve(), "benchkit/reports/coverage.py": Path(__file__).resolve()} tool_hashes = {relative: hashlib.sha256(path.read_bytes()).hexdigest() for relative, path in tool_paths.items()} files = audit.ClosedFiles(campaign) manifest = files.json("campaign.json") digest = files.hashes["campaign.json"] audit.require(files.json("campaign_digest.json")["sha256"] == digest, "campaign digest mismatch") audit.require(manifest["schema_version"] in {"starvla-rsi.campaign/v1", "starvla-rsi.campaign/v2", "starvla-rsi.campaign/v3"}, "unsupported campaign") audit.require(not infrastructure_diagnostic(manifest), "participant coverage does not accept infrastructure diagnostic campaigns; preserve their raw records separately") cases = manifest["cases"] audit.require(len(cases) == manifest["planned_cases"] and len(cases) > 0, "denominator mismatch") audit.require([case["index"] for case in cases] == list(range(len(cases))), "case order mismatch") audit.require([case["case_id"] for case in cases] == [f"case-{i:03d}" for i in range(len(cases))], "unsafe or mismatched case identity") audit.require(not {p.name for p in files.root.glob("case-*")} - {c["case_id"] for c in cases}, "unplanned case claim outside frozen denominator") rows = [] for case in cases: row = {key: None for key in FIELDS} row["evidence_caveats"] = [] metadata = case["episode"].get("metadata", {}) row.update(case_index=case["index"], task=case["episode"]["task"], protocol_version=case["descriptor"]["protocol_version"], reference_horizon=metadata.get("native_horizon", metadata.get("reference_native_horizon")), reference_horizon_source=metadata.get("native_horizon_source"), decision_limit=manifest["max_policy_calls"], control_limit=manifest["max_steps"], replan_prefix=manifest["replan_interval"]) directory = files.root / case["case_id"] if not directory.exists() and not directory.is_symlink(): row.update(attempt_status="unattempted", record_consistency="not_checked") elif directory.is_symlink() or not directory.is_dir(): row.update(attempt_status="invalid_evidence", record_consistency="failed", issue="case claim is not a plain directory") elif not (directory / "outcome.json").exists() and not (directory / "outcome.json").is_symlink(): # No episode/event reads while the attempt may still be active. row.update(attempt_status="claimed_without_terminal_outcome", record_consistency="not_checked") else: try: row.update(closed_case(files, case, manifest, digest)) except (ValueError, OSError, KeyError, TypeError, IndexError, AttributeError) as exc: row.update(attempt_status="invalid_evidence", record_consistency="failed", issue=f"{type(exc).__name__}: {exc}") rows.append(row) caveat_source = attach_caveats(rows, files.root, digest, caveats) files.verify_unchanged() for relative, digest_now in tool_hashes.items(): audit.require(hashlib.sha256(tool_paths[relative].read_bytes()).hexdigest() == digest_now, "reporting tool changed during snapshot") counts = {name: sum(row["attempt_status"] == name for row in rows) for name in ( "completed", "infrastructure_or_policy_error", "claimed_without_terminal_outcome", "unattempted", "invalid_evidence")} counts.update(planned=len(rows), native_successes=sum(row["native_final_success"] is True for row in rows), native_failures=sum(row["native_final_success"] is False for row in rows)) return {"schema_version": "starvla-rsi.coverage-snapshot/v1", "created_at": datetime.now(timezone.utc).isoformat(), "campaign": str(files.root), "campaign_sha256": digest, "benchmark": manifest["benchmark"], "counts": counts, "tool_source_paths": {relative: str(path) for relative, path in tool_paths.items()}, "cases": rows, "read_file_sha256": files.hashes, "caveat_source": caveat_source, "tool_sha256": tool_hashes, "limitations": [ "Non-atomic live-campaign snapshot: unattempted/active cases may advance after inspection.", "Only terminal closed runner records are inspected; no simulator, scorer, mailbox or video is read.", "Declared policy identity, profile, prompt and stopping settings are bound to the campaign; mailbox/timeout/chunk settings require a separate policy/artifact audit.", "Full frozen denominator retained; invalid or incomplete evidence is not a retry or exclusion.", "Optional caveats preserve raw native outcomes; missing/empty caveats do not certify clean evidence or rendering quality.", "First success is diagnostic, not final scoring; null is unknown or no logged success, never zero.", "No named provider score, native parity, OS isolation or actor-context blinding attestation."]} def csv_value(value): if value is None: return "null" if type(value) is bool: return "true" if value else "false" if isinstance(value, list): return json.dumps(value, ensure_ascii=False, separators=(",", ":")) text = str(value) # Spreadsheet formula prevention; exact original strings remain in JSON. return "'" + text if text.lstrip().startswith(("=", "+", "-", "@")) else text def write_snapshot(report: dict, output: Path) -> None: audit.require(not output.resolve().is_relative_to(Path(report["campaign"]).resolve()), "snapshot directory must be outside the source campaign") output.mkdir(parents=True, exist_ok=False) with (output / "coverage.json").open("x") as handle: json.dump(report, handle, indent=2, sort_keys=True) handle.write("\n") with (output / "tasks.csv").open("x", newline="") as handle: writer = csv.DictWriter(handle, fieldnames=FIELDS) writer.writeheader() writer.writerows({key: csv_value(row.get(key)) for key in FIELDS} for row in report["cases"]) def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--campaign", required=True, type=Path) parser.add_argument("--output-dir", required=True, type=Path, help="new private directory outside source campaign") parser.add_argument("--caveats", type=Path, help="optional external campaign-bound operator annotations; never score edits") args = parser.parse_args() report = summarize(args.campaign, args.caveats) write_snapshot(report, args.output_dir) print(json.dumps(report["counts"], sort_keys=True)) if __name__ == "__main__": main()