loopx 0.4.8__py3-none-any.whl

loopx/cli_commands/benchmark_run_ledger_maintenance_registration.py

@@ -0,0 +1,342 @@
+from __future__ import annotations
+
+import argparse
+
+from ..benchmark_ledger import BENCHMARK_RUN_LEDGER_DEFAULT_PATH
+
+
+def register_benchmark_run_ledger_maintenance_commands(
+    benchmark_subparsers: argparse._SubParsersAction,
+) -> None:
+    benchmark_run_ledger_archive_parser = benchmark_subparsers.add_parser(
+        "run-ledger-archive",
+        help=(
+            "Mark matching benchmark_run_ledger_v0 rows archived. Archived rows "
+            "remain in JSON but are excluded from default current-case views."
+        ),
+    )
+    benchmark_run_ledger_archive_parser.add_argument(
+        "--run-ledger-path",
+        default=str(BENCHMARK_RUN_LEDGER_DEFAULT_PATH),
+        help="Path to benchmark_run_ledger_v0 JSON. Markdown is rendered next to it.",
+    )
+    benchmark_run_ledger_archive_parser.add_argument(
+        "--benchmark-id",
+        required=True,
+        help="Benchmark id whose matching runs should be archived.",
+    )
+    benchmark_run_ledger_archive_parser.add_argument(
+        "--reason",
+        required=True,
+        help="Public-safe reason recorded on archived rows.",
+    )
+    benchmark_run_ledger_archive_parser.add_argument(
+        "--archive-batch-id",
+        help="Optional stable archive batch id. Defaults to a deterministic short id.",
+    )
+    benchmark_run_ledger_archive_parser.add_argument(
+        "--run-group-contains",
+        action="append",
+        default=[],
+        help=(
+            "Archive runs whose run_group_id contains this substring. May be "
+            "passed multiple times."
+        ),
+    )
+    benchmark_run_ledger_archive_parser.add_argument(
+        "--keep-run-group-contains",
+        action="append",
+        default=[],
+        help=(
+            "Keep runs whose run_group_id contains this substring even when "
+            "they match the broader archive scope. May be passed multiple times."
+        ),
+    )
+    benchmark_run_ledger_archive_parser.add_argument(
+        "--case-id",
+        action="append",
+        default=[],
+        help="Archive only this case id. May be passed multiple times.",
+    )
+    benchmark_run_ledger_archive_parser.add_argument(
+        "--arm-id",
+        action="append",
+        default=[],
+        help="Archive only this arm id. May be passed multiple times.",
+    )
+    benchmark_run_ledger_archive_parser.add_argument(
+        "--archive-all-matching-benchmark",
+        action="store_true",
+        help=(
+            "Allow archiving every run in --benchmark-id except explicit keep "
+            "filters. Required when no narrower positive filter is supplied."
+        ),
+    )
+    benchmark_run_ledger_archive_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview archive update without writing. This is the default.",
+    )
+    benchmark_run_ledger_archive_parser.add_argument(
+        "--execute",
+        action="store_true",
+        help="Write the archive update and regenerated Markdown view.",
+    )
+
+    benchmark_run_ledger_upsert_parser = benchmark_subparsers.add_parser(
+        "run-ledger-upsert",
+        help=(
+            "Upsert benchmark_run_ledger_v0 from an existing compact "
+            "benchmark_run_v0 JSON file. This does not read raw runner artifacts."
+        ),
+    )
+    benchmark_run_ledger_upsert_parser.add_argument(
+        "--benchmark-run-json",
+        help="Path to a compact benchmark_run_v0 JSON object. Use '-' to read stdin.",
+    )
+    benchmark_run_ledger_upsert_parser.add_argument(
+        "--post-launch-json",
+        help=(
+            "Path to a compact terminal_bench_post_launch_materialization_v0 "
+            "object. Use '-' to read stdin. This records result-finalization "
+            "or post-launch failure markers without reading raw runner artifacts."
+        ),
+    )
+    benchmark_run_ledger_upsert_parser.add_argument(
+        "--run-ledger-path",
+        default=str(BENCHMARK_RUN_LEDGER_DEFAULT_PATH),
+        help="Path to benchmark_run_ledger_v0 JSON. Markdown is rendered next to it.",
+    )
+    benchmark_run_ledger_upsert_parser.add_argument(
+        "--run-group-id",
+        help="Optional stable run group id for the ledger row.",
+    )
+    benchmark_run_ledger_upsert_parser.add_argument(
+        "--arm-id",
+        help="Optional arm id override for the ledger row.",
+    )
+    benchmark_run_ledger_upsert_parser.add_argument(
+        "--compact-artifact-ref",
+        help="Optional public-safe relative reference to the compact run artifact.",
+    )
+    benchmark_run_ledger_upsert_parser.add_argument(
+        "--run-ledger-note",
+        help="Optional compact note for the ledger row.",
+    )
+    benchmark_run_ledger_upsert_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview ledger update without writing. This is the default.",
+    )
+    benchmark_run_ledger_upsert_parser.add_argument(
+        "--execute",
+        action="store_true",
+        help="Write the benchmark run ledger update.",
+    )
+
+    benchmark_run_ledger_merge_parser = benchmark_subparsers.add_parser(
+        "run-ledger-merge",
+        help=(
+            "Merge multiple public benchmark_run_ledger_v0 JSON files into one "
+            "canonical ledger. This reads compact ledger rows only."
+        ),
+    )
+    benchmark_run_ledger_merge_parser.add_argument(
+        "--run-ledger-path",
+        default=str(BENCHMARK_RUN_LEDGER_DEFAULT_PATH),
+        help="Target benchmark_run_ledger_v0 JSON. Markdown is rendered next to it.",
+    )
+    benchmark_run_ledger_merge_parser.add_argument(
+        "--source-run-ledger-path",
+        action="append",
+        default=[],
+        help="Source benchmark_run_ledger_v0 JSON. May be passed multiple times.",
+    )
+    benchmark_run_ledger_merge_parser.add_argument(
+        "--source-run-ledger-glob",
+        action="append",
+        default=[],
+        help=(
+            "Glob for source benchmark_run_ledger_v0 JSON files. May be passed "
+            "multiple times; matched source paths are not recorded in the output."
+        ),
+    )
+    benchmark_run_ledger_merge_parser.add_argument(
+        "--benchmark-id",
+        action="append",
+        default=[],
+        help="Only merge runs for this benchmark id. May be passed multiple times.",
+    )
+    benchmark_run_ledger_merge_parser.add_argument(
+        "--run-group-contains",
+        action="append",
+        default=[],
+        help=(
+            "Only merge runs whose run_group_id contains this public-safe token. "
+            "May be passed multiple times."
+        ),
+    )
+    benchmark_run_ledger_merge_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview merge update without writing. This is the default.",
+    )
+    benchmark_run_ledger_merge_parser.add_argument(
+        "--execute",
+        action="store_true",
+        help="Write the merged benchmark run ledger.",
+    )
+
+    benchmark_run_ledger_aggregate_parser = benchmark_subparsers.add_parser(
+        "run-ledger-aggregate",
+        help=(
+            "Build a current-case aggregate from benchmark_run_ledger_v0 rows. "
+            "Countable official results outrank later missing or infra rows."
+        ),
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--run-ledger-path",
+        default=str(BENCHMARK_RUN_LEDGER_DEFAULT_PATH),
+        help="Primary benchmark_run_ledger_v0 JSON.",
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--source-run-ledger-path",
+        action="append",
+        default=[],
+        help="Additional source benchmark_run_ledger_v0 JSON. May be passed multiple times.",
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--source-run-ledger-glob",
+        action="append",
+        default=[],
+        help=(
+            "Glob for additional source benchmark_run_ledger_v0 JSON files. "
+            "Matched paths are counted but not recorded in output."
+        ),
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--benchmark-id",
+        default="skillsbench@1.1",
+        help="Benchmark id to aggregate.",
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--canonical-case-id",
+        action="append",
+        default=[],
+        help="Canonical case id. May be passed multiple times.",
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--canonical-case-ids-file",
+        help="Text file with one canonical case id per line.",
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--canonical-case-root",
+        help=(
+            "Directory whose immediate child directories are canonical case ids. "
+            "Use this for benchmark task roots so sanity/preflight tasks outside "
+            "the canonical root do not enter the denominator."
+        ),
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--active-case-id",
+        action="append",
+        default=[],
+        help=(
+            "Case id for a currently running or reserved case that should not be "
+            "selected as runnable missing work. May be repeated."
+        ),
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--active-case-ids-file",
+        help="Text file with one currently running or reserved case id per line.",
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--include-noncanonical-sanity-sources",
+        action="store_true",
+        help=(
+            "Keep explicit canonical ids whose ledger rows prove they came from "
+            "sanity/noncanonical task sources. Formal SkillsBench aggregates "
+            "leave this off so sanity fixtures do not enter the denominator."
+        ),
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--target-lane-id",
+        help=(
+            "Optional public-safe label for a target lane aggregate, such as "
+            "codex-cli-goal-xhigh. This is metadata; matching is controlled by "
+            "the run-group substring flags."
+        ),
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--target-run-group-contains",
+        action="append",
+        default=[],
+        help=(
+            "Run-group substring for runs in the target lane. May be repeated. "
+            "When target backfill substrings are also set, matching target runs "
+            "that do not match backfill are treated as current evidence."
+        ),
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--target-current-run-group-contains",
+        action="append",
+        default=[],
+        help=(
+            "Run-group substring for current evidence inside the target lane. "
+            "May be repeated. Use this only when current evidence cannot be "
+            "expressed as target minus backfill."
+        ),
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--target-backfill-run-group-contains",
+        action="append",
+        default=[],
+        help=(
+            "Run-group substring for lower-priority backfill evidence inside "
+            "the target lane, such as skillsbench-codex-cli-goal-xhigh-full87-."
+        ),
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--output-json",
+        help="Optional output JSON path for the aggregate.",
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview aggregate without writing. This is the default.",
+    )
+    benchmark_run_ledger_aggregate_parser.add_argument(
+        "--execute",
+        action="store_true",
+        help="Write --output-json.",
+    )
+
+    benchmark_run_ledger_check_parser = benchmark_subparsers.add_parser(
+        "run-ledger-check",
+        help=(
+            "Compare compact benchmark_run_v0 run history with the public "
+            "benchmark_run_ledger_v0. This reads compact history only."
+        ),
+    )
+    benchmark_run_ledger_check_parser.add_argument(
+        "--goal-id",
+        required=True,
+        help="Goal id whose compact benchmark run history should be checked.",
+    )
+    benchmark_run_ledger_check_parser.add_argument(
+        "--run-ledger-path",
+        default=str(BENCHMARK_RUN_LEDGER_DEFAULT_PATH),
+        help="Path to benchmark_run_ledger_v0 JSON.",
+    )
+    benchmark_run_ledger_check_parser.add_argument(
+        "--history-limit",
+        type=int,
+        default=500,
+        help="Maximum recent compact run-history rows to compare.",
+    )
+    benchmark_run_ledger_check_parser.add_argument(
+        "--limit",
+        type=int,
+        default=20,
+        help="Maximum missing rows to include in output.",
+    )

loopx/cli_commands/benchmark_run_ledger_maintenance_rendering.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+
+def render_benchmark_run_ledger_upsert_markdown(payload: dict[str, object]) -> str:
+    ledger = (
+        payload.get("benchmark_run_ledger")
+        if isinstance(payload.get("benchmark_run_ledger"), dict)
+        else {}
+    )
+    entry = ledger.get("entry") if isinstance(ledger.get("entry"), dict) else {}
+    decision = (
+        ledger.get("case_decision")
+        if isinstance(ledger.get("case_decision"), dict)
+        else {}
+    )
+    read_boundary = (
+        payload.get("read_boundary")
+        if isinstance(payload.get("read_boundary"), dict)
+        else {}
+    )
+    lines = [
+        "# Benchmark Run Ledger Upsert",
+        "",
+        f"- ok: `{payload.get('ok')}`",
+        f"- dry_run: `{payload.get('dry_run')}`",
+        f"- updated: `{ledger.get('updated')}`",
+        f"- benchmark: `{entry.get('benchmark_id')}`",
+        f"- case: `{entry.get('case_id')}`",
+        f"- arm: `{entry.get('arm_id')}`",
+        f"- score: `{entry.get('official_score')}`",
+        f"- failure: `{entry.get('failure_class')}`",
+        f"- decision: `{decision.get('decision')}`",
+        f"- ledger: `{ledger.get('ledger_path')}`",
+        f"- compact only: `{read_boundary.get('compact_only')}`",
+        f"- raw logs read: `{read_boundary.get('raw_logs_read')}`",
+        f"- task text read: `{read_boundary.get('task_text_read')}`",
+    ]
+    if payload.get("error"):
+        lines.append(f"- error: {payload.get('error')}")
+    return "\n".join(lines) + "\n"
+
+
+def render_benchmark_run_ledger_check_markdown(payload: dict[str, object]) -> str:
+    drift = (
+        payload.get("benchmark_run_ledger_drift")
+        if isinstance(payload.get("benchmark_run_ledger_drift"), dict)
+        else {}
+    )
+    lines = [
+        "# Benchmark Run Ledger Drift Check",
+        "",
+        f"- ok: `{payload.get('ok')}`",
+        f"- drift_detected: `{drift.get('drift_detected')}`",
+        f"- checked_history_run_count: `{drift.get('checked_history_run_count')}`",
+        f"- terminal_history_run_count: `{drift.get('terminal_history_run_count')}`",
+        f"- matched_history_run_count: `{drift.get('matched_history_run_count')}`",
+        f"- missing_ledger_run_count: `{drift.get('missing_ledger_run_count')}`",
+        f"- non_terminal_skipped_count: `{drift.get('non_terminal_skipped_count')}`",
+        f"- ledger_run_count: `{drift.get('ledger_run_count')}`",
+    ]
+    missing_runs = (
+        drift.get("missing_runs") if isinstance(drift.get("missing_runs"), list) else []
+    )
+    if missing_runs:
+        lines.extend(
+            [
+                "",
+                "## Missing Compact Runs",
+                "",
+                "| Benchmark | Case | Arm | Score | Failure | Catch-up |",
+                "| --- | --- | --- | --- | --- | --- |",
+            ]
+        )
+        for run in missing_runs:
+            if not isinstance(run, dict):
+                continue
+            lines.append(
+                "| "
+                f"`{run.get('benchmark_id')}` | "
+                f"`{run.get('case_id')}` | "
+                f"`{run.get('arm_id')}` | "
+                f"`{run.get('official_score')}` | "
+                f"`{run.get('failure_class')}` | "
+                f"`{run.get('catch_up_command_template')}` |"
+            )
+    if payload.get("error"):
+        lines.append(f"- error: {payload.get('error')}")
+    return "\n".join(lines) + "\n"
+
+
+def render_benchmark_run_ledger_archive_markdown(payload: dict[str, object]) -> str:
+    archive = payload.get("archive") if isinstance(payload.get("archive"), dict) else {}
+    samples = (
+        archive.get("archived_samples")
+        if isinstance(archive.get("archived_samples"), list)
+        else []
+    )
+    lines = [
+        "# Benchmark Run Ledger Archive",
+        "",
+        f"- ok: `{payload.get('ok')}`",
+        f"- dry_run: `{payload.get('dry_run')}`",
+        f"- updated: `{payload.get('updated')}`",
+        f"- benchmark: `{archive.get('benchmark_id')}`",
+        f"- archive_batch_id: `{archive.get('archive_batch_id')}`",
+        f"- matched_run_count: `{archive.get('matched_run_count')}`",
+        f"- newly_archived_run_count: `{archive.get('newly_archived_run_count')}`",
+        f"- already_archived_run_count: `{archive.get('already_archived_run_count')}`",
+        f"- kept_run_count: `{archive.get('kept_run_count')}`",
+        f"- ledger: `{payload.get('ledger_path')}`",
+    ]
+    reason = archive.get("reason")
+    if reason:
+        lines.append(f"- reason: {reason}")
+    if samples:
+        lines.extend(
+            [
+                "",
+                "## Archived Samples",
+                "",
+                "| Case | Arm | Run Group | Score | Failure |",
+                "| --- | --- | --- | --- | --- |",
+            ]
+        )
+        for sample in samples:
+            if not isinstance(sample, dict):
+                continue
+            lines.append(
+                "| "
+                f"`{sample.get('case_id')}` | "
+                f"`{sample.get('arm_id')}` | "
+                f"`{sample.get('run_group_id')}` | "
+                f"`{sample.get('official_score')}` | "
+                f"`{sample.get('failure_class')}` |"
+            )
+    if archive.get("truncated"):
+        lines.append("")
+        lines.append("Archived samples are truncated.")
+    if payload.get("error"):
+        lines.append(f"- error: {payload.get('error')}")
+    return "\n".join(lines) + "\n"
+
+
+def render_benchmark_run_ledger_merge_markdown(payload: dict[str, object]) -> str:
+    merge = payload.get("merge") if isinstance(payload.get("merge"), dict) else {}
+    read_boundary = (
+        payload.get("read_boundary")
+        if isinstance(payload.get("read_boundary"), dict)
+        else {}
+    )
+    lines = [
+        "# Benchmark Run Ledger Merge",
+        "",
+        f"- ok: `{payload.get('ok')}`",
+        f"- dry_run: `{payload.get('dry_run')}`",
+        f"- updated: `{payload.get('updated')}`",
+        f"- source_ledger_count: `{merge.get('source_ledger_count')}`",
+        f"- source_run_count: `{merge.get('source_run_count')}`",
+        f"- considered_run_count: `{merge.get('considered_run_count')}`",
+        f"- merged_run_count: `{merge.get('merged_run_count')}`",
+        f"- new_run_id_count: `{merge.get('new_run_id_count')}`",
+        f"- target_run_count: `{merge.get('target_run_count')}`",
+        f"- source paths recorded: `{merge.get('source_paths_recorded')}`",
+        f"- ledger: `{payload.get('ledger_path')}`",
+        f"- compact only: `{read_boundary.get('compact_only')}`",
+        f"- raw logs read: `{read_boundary.get('raw_logs_read')}`",
+        f"- task text read: `{read_boundary.get('task_text_read')}`",
+    ]
+    if merge.get("skipped_by_reason"):
+        lines.append(f"- skipped_by_reason: `{merge.get('skipped_by_reason')}`")
+    if payload.get("error"):
+        lines.append(f"- error: {payload.get('error')}")
+    return "\n".join(lines) + "\n"
+
+
+def render_benchmark_run_ledger_aggregate_markdown(payload: dict[str, object]) -> str:
+    aggregate = payload.get("aggregate") if isinstance(payload.get("aggregate"), dict) else {}
+    distribution = (
+        aggregate.get("distribution")
+        if isinstance(aggregate.get("distribution"), dict)
+        else {}
+    )
+    score_summary = (
+        aggregate.get("countable_score_summary")
+        if isinstance(aggregate.get("countable_score_summary"), dict)
+        else {}
+    )
+    standard_case_sets = (
+        aggregate.get("standard_case_sets")
+        if isinstance(aggregate.get("standard_case_sets"), dict)
+        else {}
+    )
+    selection_policy = (
+        aggregate.get("selection_policy")
+        if isinstance(aggregate.get("selection_policy"), dict)
+        else {}
+    )
+    target_lane = (
+        selection_policy.get("target_lane")
+        if isinstance(selection_policy.get("target_lane"), dict)
+        else {}
+    )
+
+    def _list_count(value: object) -> int:
+        return len(value) if isinstance(value, list) else 0
+
+    lines = [
+        "# Benchmark Run Ledger Current Aggregate",
+        "",
+        f"- ok: `{payload.get('ok')}`",
+        f"- dry_run: `{payload.get('dry_run')}`",
+        f"- updated: `{payload.get('updated')}`",
+        f"- benchmark: `{aggregate.get('benchmark_id')}`",
+        f"- canonical_covered: `{aggregate.get('canonical_covered')}` / `{aggregate.get('canonical_total')}`",
+        f"- countable_cases: `{score_summary.get('countable_case_count')}`",
+        f"- countable_score_sum: `{score_summary.get('countable_score_sum')}`",
+        f"- countable_score_mean: `{score_summary.get('countable_score_mean')}`",
+        f"- accepted_case_count: `{_list_count(standard_case_sets.get('accepted_case_ids'))}`",
+        f"- missing_case_count: `{_list_count(standard_case_sets.get('missing_case_ids'))}`",
+        f"- blocked_uncountable_case_count: `{_list_count(standard_case_sets.get('blocked_uncountable_case_ids'))}`",
+        f"- active_case_count: `{_list_count(standard_case_sets.get('active_case_ids'))}`",
+        f"- runnable_missing_case_count: `{_list_count(standard_case_sets.get('runnable_missing_case_ids'))}`",
+        f"- distribution: `{distribution}`",
+        f"- selection_rule: `{selection_policy.get('rule')}`",
+        f"- target_lane_enabled: `{target_lane.get('enabled')}`",
+        f"- target_lane_id: `{target_lane.get('lane_id')}`",
+        f"- deduped_run_count: `{aggregate.get('deduped_run_count')}`",
+        f"- source_ledger_files: `{aggregate.get('source_ledger_files')}`",
+        f"- output_json: `{payload.get('output_json')}`",
+    ]
+    if payload.get("error"):
+        lines.append(f"- error: {payload.get('error')}")
+    return "\n".join(lines) + "\n"

loopx/cli_commands/benchmark_run_ledger_parity.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Callable
+from pathlib import Path
+
+from ..benchmark_core import (
+    build_codex_app_parity_posthoc_check,
+    render_codex_app_parity_posthoc_check_markdown,
+)
+from ..status import compact_benchmark_run
+
+
+PrintPayload = Callable[
+    [dict[str, object], str, Callable[[dict[str, object]], str]],
+    None,
+]
+OutputFormat = Callable[[argparse.Namespace], str]
+
+BENCHMARK_RUN_LEDGER_PARITY_COMMANDS = {"parity-check"}
+
+
+def register_benchmark_run_ledger_parity_commands(
+    benchmark_subparsers: argparse._SubParsersAction,
+    add_subcommand_format: Callable[[argparse.ArgumentParser], None],
+) -> None:
+    benchmark_parity_check_parser = benchmark_subparsers.add_parser(
+        "parity-check",
+        help=(
+            "Posthoc-check whether a compact benchmark_run_v0 has enough "
+            "public-safe evidence to support Codex App product-path attribution."
+        ),
+    )
+    add_subcommand_format(benchmark_parity_check_parser)
+    benchmark_parity_check_parser.add_argument(
+        "--benchmark-run-json",
+        required=True,
+        help="Path to a compact benchmark_run_v0 JSON object. Use '-' to read stdin.",
+    )
+
+
+def handle_benchmark_run_ledger_parity_command(
+    args: argparse.Namespace,
+    *,
+    print_payload: PrintPayload,
+    output_format: OutputFormat,
+) -> int | None:
+    if args.benchmark_command not in BENCHMARK_RUN_LEDGER_PARITY_COMMANDS:
+        return None
+
+    if args.benchmark_command == "parity-check":
+        try:
+            if args.benchmark_run_json == "-":
+                run_input = json.loads(sys.stdin.read())
+            else:
+                run_input = json.loads(
+                    Path(args.benchmark_run_json).expanduser().read_text(
+                        encoding="utf-8"
+                    )
+                )
+            benchmark_run = compact_benchmark_run(run_input)
+            if not benchmark_run:
+                raise ValueError(
+                    "--benchmark-run-json did not contain a compactable benchmark_run_v0 object"
+                )
+            payload = {
+                "ok": True,
+                "codex_app_parity_posthoc_check": (
+                    build_codex_app_parity_posthoc_check(benchmark_run)
+                ),
+            }
+        except Exception as exc:
+            payload = {
+                "ok": False,
+                "codex_app_parity_posthoc_check": {
+                    "full_product_claim_allowed": False,
+                    "claim_level": "invalid_or_unreadable_compact_benchmark_run",
+                },
+                "error": str(exc),
+            }
+        print_payload(
+            payload,
+            output_format(args),
+            lambda value: render_codex_app_parity_posthoc_check_markdown(
+                value["codex_app_parity_posthoc_check"]
+            ),
+        )
+        return 0 if payload.get("ok") else 1
+
+    return None