| |
| """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") |
| |
| |
| 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") |
| |
| 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") |
| |
| 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: |
| |
| |
| 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(): |
| |
| 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) |
| |
| 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() |
|
|
