devlyn-cli 3.2.0 → 3.3.0

package/benchmark/auto-resolve/scripts/build-pair-eligible-manifest.py

@@ -1,306 +0,0 @@
-#!/usr/bin/env python3
-"""Build the iter-0033c pair-eligible manifest (Codex R0/R0.5 + R0-infra/R0.5-infra).
-
-Manifest captures the immutable Gate-3 input to iter-0033c-compare.py:
-  - which fixtures are pair-eligible (high-value ∪ L1≤L0 ∪ F9-if-iter-0033a-passed)
-  - what the Gate-3 threshold count is
-  - sha256 over the canonical document so any post-write tampering is detectable
-
-Hashing pattern is the pre-stamp form lifted from
-benchmark/auto-resolve/scripts/pair-plan-lint.py:81-91 — deep-copy the manifest,
-zero out `manifest_sha256`, serialize with `sort_keys=True, separators=(",",":"),
-ensure_ascii=False, allow_nan=False`, then sha256 the bytes.
-
-Inputs (all required):
-  --c1-summary <path>        iter-0033 (C1) summary.json (selection grounds; never a comparison baseline)
-  --f9-judge <path>          iter-0033a F9 judge.json (F9 inclusion proof)
-  --l1-rerun-summary <path>  L1 rerun summary archived for provenance, not selection
-  --output <path>            destination .devlyn/manifests/iter-0033c-pair-eligible.json
-
-Selection rule (frozen pre-registration, iter-0033c §"Pair-eligible fixture set"):
-  high_value = {F2, F3, F4, F6, F7}
-  promoted_by_l1_le_l0 = {f ∈ C1 summary | solo_claude.score ≤ bare.score}
-  conditional_excluded = {F1, F5}    # promoted only if L1≤L0
-  reporting_only = {F8}              # excluded from Gate 3
-  pair_eligible = high_value ∪ promoted_by_l1_le_l0 ∪ {F9 if iter-0033a passed}
-                  − reporting_only
-                  − conditional_excluded that did not get promoted
-                  − current rejected/ceiling registry
-"""
-import argparse
-import copy
-import hashlib
-import json
-import re
-import subprocess
-import sys
-from pathlib import Path
-
-SCRIPT_DIR = Path(__file__).resolve().parent
-if str(SCRIPT_DIR) not in sys.path:
-    sys.path.insert(0, str(SCRIPT_DIR))
-
-from pair_evidence_contract import is_score, reject_json_constant
-
-HIGH_VALUE = ["F2", "F3", "F4", "F6", "F7"]
-CONDITIONAL = ["F1", "F5"]
-REPORTING_ONLY = ["F8"]
-REJECTED_REGISTRY = Path(__file__).with_name("pair-rejected-fixtures.sh")
-
-
-def exact_bool(value: object) -> bool | None:
-    return value if isinstance(value, bool) else None
-
-
-def disqualifier_flag(value: object, *, default: bool = False) -> bool:
-    if value is None:
-        return default
-    parsed = exact_bool(value)
-    return parsed if parsed is not None else True
-
-
-def file_sha256(path: Path) -> str:
-    return hashlib.sha256(path.read_bytes()).hexdigest()
-
-
-def canonical_manifest_sha256(manifest: dict) -> str:
-    """Pre-stamp hash per pair-plan-lint.py:81-91 — zero out the stamp, then sha256."""
-    pre = copy.deepcopy(manifest)
-    pre["manifest_sha256"] = ""
-    s = json.dumps(
-        pre,
-        sort_keys=True,
-        separators=(",", ":"),
-        ensure_ascii=False,
-        allow_nan=False,
-    )
-    return hashlib.sha256(s.encode("utf-8")).hexdigest()
-
-
-def fixture_short_id(full: str) -> str:
-    """'F3-backend-contract-risk' -> 'F3'. Pure prefix; matches existing convention."""
-    return full.split("-", 1)[0] if "-" in full else full
-
-
-def load_rejected_fixture_reasons(path: Path) -> dict[str, str]:
-    if not path.is_file():
-        raise ValueError(f"rejected fixture registry not found: {path}")
-    rejected: dict[str, str] = {}
-    current: str | None = None
-    for line in path.read_text().splitlines():
-        match = re.match(r"\s*([FS]\d+)-\*\|([FS]\d+)\)", line)
-        if match and match.group(1) == match.group(2):
-            current = match.group(1)
-            continue
-        reason = re.match(r'\s*echo "([^"]+)"', line)
-        if current and reason:
-            rejected[current] = reason.group(1)
-            current = None
-    return dict(sorted(rejected.items(), key=lambda item: (item[0][0], int(item[0][1:]))))
-
-
-def load_rejected_short_ids(path: Path) -> list[str]:
-    return list(load_rejected_fixture_reasons(path))
-
-
-def load_json_object(path: Path, label: str) -> dict:
-    try:
-        data = json.loads(path.read_text(), parse_constant=reject_json_constant)
-    except (ValueError, json.JSONDecodeError) as exc:
-        raise ValueError(f"{label} malformed: invalid JSON") from exc
-    if not isinstance(data, dict):
-        raise ValueError(f"{label} malformed: expected object")
-    return data
-
-
-def compute_promoted_l1_le_l0(c1_rows: list) -> list:
-    """Return short fixture IDs (e.g. 'F3') where solo_claude.score ≤ bare.score in C1."""
-    promoted = []
-    for row in c1_rows:
-        if not isinstance(row, dict):
-            continue
-        raw_arms = row.get("arms")
-        arms = raw_arms if isinstance(raw_arms, dict) else {}
-        raw_solo = arms.get("solo_claude")
-        raw_bare = arms.get("bare")
-        solo_arm = raw_solo if isinstance(raw_solo, dict) else {}
-        bare_arm = raw_bare if isinstance(raw_bare, dict) else {}
-        if (
-            disqualifier_flag(solo_arm.get("disqualifier"))
-            or disqualifier_flag(bare_arm.get("disqualifier"))
-        ):
-            continue
-        solo = solo_arm.get("score")
-        bare = bare_arm.get("score")
-        if not is_score(solo) or not is_score(bare):
-            continue
-        if solo <= bare:
-            fixture = row.get("fixture")
-            if isinstance(fixture, str):
-                promoted.append(fixture_short_id(fixture))
-    return promoted
-
-
-def mapped_score(judge: dict, arm: str) -> int | None:
-    mapping = judge.get("_blind_mapping")
-    if not isinstance(mapping, dict):
-        return None
-    letter = next((slot for slot, mapped in mapping.items() if mapped == arm), None)
-    if letter is None:
-        return None
-    raw_scores = judge.get("scores_by_arm")
-    scores = raw_scores if isinstance(raw_scores, dict) else {}
-    score = scores.get(arm)
-    if is_score(score):
-        return score
-    legacy = judge.get(f"{letter.lower()}_score")
-    return legacy if is_score(legacy) else None
-
-
-def mapped_disqualifier(judge: dict, arm: str) -> bool:
-    mapping = judge.get("_blind_mapping")
-    if not isinstance(mapping, dict):
-        return True
-    letter = next((slot for slot, mapped in mapping.items() if mapped == arm), None)
-    if letter is None:
-        return True
-    raw_by_arm = judge.get("disqualifiers_by_arm")
-    if raw_by_arm is not None and not isinstance(raw_by_arm, dict):
-        return True
-    by_arm = raw_by_arm if isinstance(raw_by_arm, dict) else {}
-    if arm in by_arm:
-        entry = by_arm.get(arm)
-        return disqualifier_flag(
-            entry.get("disqualifier") if isinstance(entry, dict) else entry
-        )
-    raw_legacy = judge.get("disqualifiers")
-    if raw_legacy is not None and not isinstance(raw_legacy, dict):
-        return True
-    legacy = raw_legacy if isinstance(raw_legacy, dict) else {}
-    return disqualifier_flag(legacy.get(letter))
-
-
-def f9_passed(f9_judge: dict) -> bool:
-    """iter-0033a passed iff solo_claude beats bare and solo is not disqualified."""
-    solo = mapped_score(f9_judge, "solo_claude")
-    bare = mapped_score(f9_judge, "bare")
-    if solo is None or bare is None:
-        return False
-    return solo > bare and not mapped_disqualifier(f9_judge, "solo_claude")
-
-
-def head_sha() -> str:
-    try:
-        out = subprocess.check_output(
-            ["git", "rev-parse", "HEAD"], stderr=subprocess.DEVNULL
-        )
-        return out.decode().strip()
-    except Exception:
-        return ""
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--c1-summary", required=True)
-    ap.add_argument("--f9-judge", required=True)
-    ap.add_argument("--l1-rerun-summary", required=True)
-    ap.add_argument("--output", required=True)
-    args = ap.parse_args()
-
-    c1_path = Path(args.c1_summary)
-    f9_path = Path(args.f9_judge)
-    l1_path = Path(args.l1_rerun_summary)
-    out_path = Path(args.output)
-
-    for p, label in [(c1_path, "c1-summary"), (f9_path, "f9-judge"), (l1_path, "l1-rerun-summary")]:
-        if not p.is_file():
-            print(f"error: {label} not found: {p}", file=sys.stderr)
-            return 2
-
-    try:
-        c1 = load_json_object(c1_path, "c1-summary")
-        f9 = load_json_object(f9_path, "f9-judge")
-        rejected_reasons = load_rejected_fixture_reasons(REJECTED_REGISTRY)
-        rejected_short_ids = list(rejected_reasons)
-    except ValueError as exc:
-        print(f"error: {exc}", file=sys.stderr)
-        return 2
-
-    c1_rows = c1.get("rows")
-    if not isinstance(c1_rows, list):
-        print("error: c1-summary malformed: rows must be an array", file=sys.stderr)
-        return 2
-
-    promoted = compute_promoted_l1_le_l0(c1_rows)
-    f9_in = f9_passed(f9)
-
-    pair_eligible = list(HIGH_VALUE)  # frozen high-value list, ordered
-    for fx in promoted:
-        if fx not in pair_eligible and fx not in REPORTING_ONLY:
-            pair_eligible.append(fx)
-    if f9_in and "F9" not in pair_eligible:
-        pair_eligible.append("F9")
-    pair_eligible = [fx for fx in pair_eligible if fx not in REPORTING_ONLY]
-    rejected_excluded = sorted(
-        {fx for fx in pair_eligible if fx in rejected_short_ids},
-        key=lambda s: (s[0], int(s[1:])),
-    )
-    pair_eligible = [fx for fx in pair_eligible if fx not in rejected_short_ids]
-
-    conditional_promoted = [fx for fx in CONDITIONAL if fx in promoted]
-    conditional_excluded = [fx for fx in CONDITIONAL if fx not in promoted]
-    pair_eligible_sorted = sorted(pair_eligible, key=lambda s: (s[0], int(s[1:])))
-    if not pair_eligible_sorted:
-        rejected_text = ", ".join(rejected_excluded) if rejected_excluded else "none"
-        print(
-            "error: no pair-eligible fixtures remain after rejected-registry filtering "
-            f"(rejected_excluded={rejected_text})",
-            file=sys.stderr,
-        )
-        return 1
-
-    gate3_total = len(pair_eligible_sorted)
-    gate3_threshold = (gate3_total + 1) // 2  # ≥50% — ceil(gate3_total / 2)
-
-    manifest = {
-        "schema_version": "1.0",
-        "iter": "0033c",
-        "head": head_sha(),
-        "sources": {
-            "c1_summary": {"path": str(c1_path), "sha256": file_sha256(c1_path)},
-            "f9_judge": {"path": str(f9_path), "sha256": file_sha256(f9_path)},
-            "l1_rerun_summary": {"path": str(l1_path), "sha256": file_sha256(l1_path)},
-        },
-        "selection_rule": {
-            "high_value": HIGH_VALUE,
-            "promoted_by_l1_le_l0": sorted(set(promoted)),
-            "f9_included": f9_in,
-            "f9_passed_iter_0033a": f9_in,
-            "reporting_only": REPORTING_ONLY,
-            "conditional_excluded": conditional_excluded,
-            "conditional_promoted": conditional_promoted,
-            "rejected_registry": str(REJECTED_REGISTRY),
-            "rejected_excluded": rejected_excluded,
-            "rejected_excluded_reasons": {
-                fixture: rejected_reasons[fixture] for fixture in rejected_excluded
-            },
-        },
-        "fixtures_pair_eligible": pair_eligible_sorted,
-        "gate3_threshold_count": gate3_threshold,
-        "gate3_total": gate3_total,
-        "manifest_sha256": "",
-    }
-    manifest["manifest_sha256"] = canonical_manifest_sha256(manifest)
-
-    out_path.parent.mkdir(parents=True, exist_ok=True)
-    out_path.write_text(json.dumps(manifest, indent=2) + "\n")
-
-    print(f"[manifest] wrote {out_path}")
-    print(f"[manifest] pair-eligible: {pair_eligible_sorted} "
-          f"(gate3 ≥ {gate3_threshold} / {gate3_total})")
-    print(f"[manifest] sha256: {manifest['manifest_sha256']}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/benchmark/auto-resolve/scripts/check-f9-artifacts.py

@@ -1,268 +0,0 @@
-#!/usr/bin/env python3
-"""F9 skill-driven arm artifact + transcript fingerprint check.
-
-Out-of-band per Codex R0.5 §B (iter-0033a): expected.json.verification_commands
-apply to ALL arms (run-fixture.sh:472), so a `docs/specs/**` check there would
-punish bare. This script runs AFTER run-fixture.sh and asserts skill-driven
-arms produced the artifacts the 2-skill ideate→resolve chain should emit.
-
-Bare arm is exempt by construction.
-
-Usage:
-  check-f9-artifacts.py --result-dir <results/<run_id>/F9-e2e-ideate-to-resolve/<arm>>
-
-Exits:
-  0 — all checks pass (or bare arm — exempt).
-  1 — skill-driven arm but artifact contract violated.
-  2 — invalid invocation (missing args, missing dir).
-
-Emits a small JSON report at <result-dir>/check-f9-artifacts.json.
-"""
-import argparse
-import json
-import os
-import re
-import sys
-from pathlib import Path
-
-from pair_evidence_contract import loads_strict_json_object
-
-
-SKILL_DRIVEN_ARMS = {"variant", "solo_claude", "l2_gated", "l2_risk_probes", "l2_forced"}
-EXEMPT_ARMS = {"bare"}
-
-SPEC_DIR_GLOB = "docs/specs/*/spec.md"
-SPEC_EXPECTED_GLOB = "docs/specs/*/spec.expected.json"
-
-# Transcript fingerprint regexes (negative checks only — `claude -p`
-# transcript captures only the agent's final reply, not intermediate
-# tool calls; positive resolve invocation evidence lives in state).
-RE_AUTO_RESOLVE = re.compile(r"/devlyn:auto-resolve\b")
-RE_PREFLIGHT = re.compile(r"/devlyn:preflight\b")
-
-
-def _load_json_object(path: Path) -> tuple[dict | None, str | None]:
-    try:
-        data = loads_strict_json_object(path.read_text())
-    except json.JSONDecodeError as exc:
-        return None, f"{exc.__class__.__name__}: {exc}"
-    except ValueError as exc:
-        if str(exc) == "top-level JSON value must be an object":
-            return None, "expected JSON object"
-        return None, f"{exc.__class__.__name__}: {exc}"
-    return data, None
-
-
-def main() -> int:
-    p = argparse.ArgumentParser(description=__doc__.split("\n", 1)[0])
-    p.add_argument("--result-dir", required=True,
-                   help="Path to results/<run_id>/<fixture>/<arm>/")
-    args = p.parse_args()
-
-    result_dir = Path(args.result_dir)
-    if not result_dir.is_dir():
-        print(f"error: result dir not found: {result_dir}", file=sys.stderr)
-        return 2
-
-    arm = result_dir.name
-    fixture = result_dir.parent.name
-
-    if fixture != "F9-e2e-ideate-to-resolve":
-        print(f"error: this script is F9-only (got fixture={fixture})", file=sys.stderr)
-        return 2
-
-    report = {
-        "fixture": fixture,
-        "arm": arm,
-        "checks": [],
-        "exempt": False,
-        "pass": True,
-    }
-
-    if arm in EXEMPT_ARMS:
-        report["exempt"] = True
-        report["checks"].append({"name": "arm-is-bare-exempt", "pass": True})
-        _write_report(result_dir, report)
-        return 0
-
-    if arm not in SKILL_DRIVEN_ARMS:
-        print(f"error: unknown arm '{arm}' (expected one of {SKILL_DRIVEN_ARMS | EXEMPT_ARMS})",
-              file=sys.stderr)
-        return 2
-
-    # The fixture's work-dir is referenced from result_dir/timing.json. The
-    # arm produced files inside that work-dir; we glob from there.
-    timing_path = result_dir / "timing.json"
-    work_dir: Path
-    if timing_path.is_file():
-        timing, _timing_error = _load_json_object(timing_path)
-        if timing is not None:
-            work_dir = Path(timing.get("work_dir", ""))
-        else:
-            work_dir = Path("__invalid_timing_work_dir__")
-    else:
-        work_dir = Path("__missing_timing_work_dir__")
-
-    if not work_dir.is_dir():
-        report["checks"].append({
-            "name": "work-dir-resolvable",
-            "pass": False,
-            "reason": f"work_dir from timing.json not usable: {work_dir!r}",
-        })
-        report["pass"] = False
-        _write_report(result_dir, report)
-        return 1
-
-    # Check 1: docs/specs/<id>-<slug>/spec.md exists.
-    specs_root = work_dir / "docs" / "specs"
-    spec_md_files = list(specs_root.glob("*/spec.md")) if specs_root.is_dir() else []
-    spec_md_present = bool(spec_md_files)
-    report["checks"].append({
-        "name": "spec.md-exists-under-docs/specs",
-        "pass": spec_md_present,
-        "matched": [str(p.relative_to(work_dir)) for p in spec_md_files],
-    })
-    if not spec_md_present:
-        report["pass"] = False
-
-    # Check 2: spec.expected.json exists at the same dir.
-    spec_exp_files = list(specs_root.glob("*/spec.expected.json")) if specs_root.is_dir() else []
-    spec_exp_present = bool(spec_exp_files)
-    report["checks"].append({
-        "name": "spec.expected.json-exists-under-docs/specs",
-        "pass": spec_exp_present,
-        "matched": [str(p.relative_to(work_dir)) for p in spec_exp_files],
-    })
-    if not spec_exp_present:
-        report["pass"] = False
-
-    # Path-shape regression: the parent dir name should be `<id>-<slug>` shape.
-    # Both id and slug are kebab-case, so the dir must contain at least one
-    # hyphen. Bare `<id>/spec.md` (no hyphen) is the legacy shape we reject.
-    if spec_md_files:
-        bad_shapes = [p for p in spec_md_files if "-" not in p.parent.name]
-        report["checks"].append({
-            "name": "path-shape-id-slug",
-            "pass": not bad_shapes,
-            "non_conforming": [str(p.relative_to(work_dir)) for p in bad_shapes],
-        })
-        if bad_shapes:
-            report["pass"] = False
-
-    # Resolve invocation evidence — primary source is pipeline.state.json,
-    # NOT transcript.txt. `claude -p` only emits the agent's final reply to
-    # stdout; intermediate Skill / Agent / Bash tool calls do not appear in
-    # transcript.txt. Therefore "regex /devlyn:resolve --spec in transcript"
-    # is the wrong source. The authoritative evidence resolve actually ran
-    # in --spec mode is `state.mode == "spec"` plus `state.source.type ==
-    # "spec"` plus a populated `state.source.spec_path` pointing under
-    # `docs/specs/`. Per state-schema.md this is single-source-of-truth.
-    # Look for the archive first (preferred), then fall back to the live
-    # in-flight location. NEW resolve currently lands artifacts directly in
-    # `.devlyn/` and may skip the move-to-runs/ archive step (TODO: separate
-    # iter to fix archive); both locations carry the same authoritative
-    # state shape.
-    archived_paths = list(work_dir.glob(".devlyn/runs/*/pipeline.state.json"))
-    live_path = work_dir / ".devlyn" / "pipeline.state.json"
-    state_paths = archived_paths if archived_paths else (
-        [live_path] if live_path.is_file() else []
-    )
-    if not state_paths:
-        report["checks"].append({
-            "name": "pipeline.state.json-present",
-            "pass": False,
-            "reason": "neither .devlyn/runs/*/pipeline.state.json nor .devlyn/pipeline.state.json found in work_dir",
-        })
-        report["pass"] = False
-    else:
-        # Read the most recent run.
-        state_path = sorted(state_paths)[-1]
-        state, state_error = _load_json_object(state_path)
-        if state is None:
-            report["checks"].append({
-                "name": "pipeline.state.json-parses",
-                "pass": False,
-                "reason": state_error,
-            })
-            report["pass"] = False
-
-        if state is not None:
-            archived = "/runs/" in str(state_path)
-            report["checks"].append({
-                "name": "pipeline.state.json-present",
-                "pass": True,
-                "path": str(state_path.relative_to(work_dir)),
-                "archived_to_runs_dir": archived,
-            })
-            if not archived:
-                # Not a fail — note for harness developer that NEW resolve
-                # is skipping the archive step in this run.
-                report["checks"].append({
-                    "name": "archive-step-completed",
-                    "pass": True,
-                    "warning": "NEW resolve left artifacts in .devlyn/ instead of .devlyn/runs/<id>/ — archive step skipped (separate iter for harness fix)",
-                })
-            mode = state.get("mode")
-            src_type = (state.get("source") or {}).get("type")
-            spec_path = (state.get("source") or {}).get("spec_path") or ""
-            spec_under_specs = spec_path.startswith("docs/specs/") and spec_path.endswith("spec.md")
-            mode_ok = mode == "spec"
-            src_ok = src_type == "spec"
-            report["checks"].append({
-                "name": "state.mode-and-source-spec",
-                "pass": mode_ok and src_ok and spec_under_specs,
-                "mode": mode,
-                "source.type": src_type,
-                "source.spec_path": spec_path,
-            })
-            if not (mode_ok and src_ok and spec_under_specs):
-                report["pass"] = False
-
-    # Transcript fingerprint — negative checks only. transcript.txt records
-    # the agent's final reply; if the agent (or any subagent) had invoked
-    # /devlyn:auto-resolve or /devlyn:preflight, the prompt-following gate
-    # should still surface the name in the summary. Positive resolve
-    # evidence lives in state above; here we just rule out the deprecated
-    # 3-skill chain names.
-    transcript_path = result_dir / "transcript.txt"
-    if not transcript_path.is_file():
-        report["checks"].append({
-            "name": "transcript-readable",
-            "pass": False,
-            "reason": f"transcript.txt missing at {transcript_path}",
-        })
-        report["pass"] = False
-        _write_report(result_dir, report)
-        return 1
-
-    transcript = transcript_path.read_text(errors="replace")
-
-    auto_resolve_hits = RE_AUTO_RESOLVE.findall(transcript)
-    report["checks"].append({
-        "name": "transcript-no-auto-resolve",
-        "pass": len(auto_resolve_hits) == 0,
-        "count": len(auto_resolve_hits),
-    })
-    if auto_resolve_hits:
-        report["pass"] = False
-
-    preflight_hits = RE_PREFLIGHT.findall(transcript)
-    report["checks"].append({
-        "name": "transcript-no-preflight",
-        "pass": len(preflight_hits) == 0,
-        "count": len(preflight_hits),
-    })
-    if preflight_hits:
-        report["pass"] = False
-
-    _write_report(result_dir, report)
-    return 0 if report["pass"] else 1
-
-
-def _write_report(result_dir: Path, report: dict) -> None:
-    out_path = result_dir / "check-f9-artifacts.json"
-    out_path.write_text(json.dumps(report, indent=2) + "\n")
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/benchmark/auto-resolve/scripts/collect-swebench-predictions.py

@@ -1,108 +0,0 @@
-#!/usr/bin/env python3
-"""Collect patch.diff files into SWE-bench prediction JSONL."""
-
-from __future__ import annotations
-
-import argparse
-import json
-from pathlib import Path
-from typing import Any
-
-from pair_evidence_contract import reject_json_constant
-
-
-def read_jsonl(path: Path) -> list[dict[str, Any]]:
-    rows: list[dict[str, Any]] = []
-    with path.open(encoding="utf8") as f:
-        for line_no, line in enumerate(f, start=1):
-            if not line.strip():
-                continue
-            value = json.loads(line, parse_constant=reject_json_constant)
-            if not isinstance(value, dict):
-                raise ValueError(f"{path}:{line_no}: expected JSON object")
-            rows.append(value)
-    return rows
-
-
-def instance_ids_from_jsonl(path: Path | None) -> set[str] | None:
-    if path is None:
-        return None
-    ids: set[str] = set()
-    for row in read_jsonl(path):
-        instance_id = row.get("instance_id")
-        if not isinstance(instance_id, str) or not instance_id:
-            raise ValueError(f"{path}: row missing non-empty instance_id")
-        ids.add(instance_id)
-    return ids
-
-
-def collect_from_root(root: Path, patch_name: str, keep: set[str] | None) -> list[tuple[str, Path]]:
-    patches: list[tuple[str, Path]] = []
-    seen: set[str] = set()
-    for patch_path in sorted(root.glob(f"*/{patch_name}")):
-        instance_id = patch_path.parent.name
-        if keep is not None and instance_id not in keep:
-            continue
-        seen.add(instance_id)
-        patches.append((instance_id, patch_path))
-    if keep is not None:
-        missing = sorted(keep - seen)
-        if missing:
-            raise ValueError(f"missing {patch_name} for instance ids: {', '.join(missing)}")
-    return patches
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--patch-root", required=True, type=Path)
-    parser.add_argument("--patch-name", default="patch.diff")
-    parser.add_argument("--instances-jsonl", type=Path, help="Optional filter/validation set.")
-    parser.add_argument("--model-name", required=True)
-    parser.add_argument("--out", required=True, type=Path)
-    parser.add_argument("--allow-empty", action="store_true")
-    args = parser.parse_args()
-
-    keep = instance_ids_from_jsonl(args.instances_jsonl)
-    patches = collect_from_root(args.patch_root, args.patch_name, keep)
-    if not patches:
-        raise ValueError(f"no {args.patch_name} files found under {args.patch_root}")
-
-    args.out.parent.mkdir(parents=True, exist_ok=True)
-    written = 0
-    skipped_empty: list[str] = []
-    with args.out.open("w", encoding="utf8") as f:
-        for instance_id, patch_path in patches:
-            patch = patch_path.read_text(encoding="utf8")
-            if not patch.strip():
-                if args.allow_empty:
-                    skipped_empty.append(instance_id)
-                    continue
-                raise ValueError(f"empty patch for {instance_id}: {patch_path}")
-            f.write(
-                json.dumps(
-                    {
-                        "instance_id": instance_id,
-                        "model_name_or_path": args.model_name,
-                        "model_patch": patch,
-                    }
-                )
-                + "\n"
-            )
-            written += 1
-    if written == 0:
-        raise ValueError("no non-empty patches collected")
-
-    report = {
-        "patch_root": str(args.patch_root),
-        "patch_name": args.patch_name,
-        "model_name_or_path": args.model_name,
-        "out": str(args.out),
-        "predictions_written": written,
-        "empty_skipped": skipped_empty,
-    }
-    print(json.dumps(report, indent=2))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())