devlyn-cli 3.2.0 → 3.3.0

package/benchmark/auto-resolve/scripts/pair_evidence_contract.py

@@ -1,270 +0,0 @@
-"""Shared pair-evidence contract for benchmark audits."""
-from __future__ import annotations
-
-import json
-import math
-import re
-from pathlib import Path
-from typing import Any
-
-
-ALLOWED_PAIR_ARMS = {"l2_risk_probes", "l2_gated"}
-CANONICAL_PAIR_TRIGGER_REASONS = {
-    "pair.default",
-    "mode.verify-only",
-    "mode.pair-verify",
-    "complexity.high",
-    "complexity.large",
-    "spec.complexity.high",
-    "spec.complexity.large",
-    "spec.solo_headroom_hypothesis",
-    "risk.high",
-    "risk_probes.enabled",
-    "risk_probes.present",
-    "coverage.failed",
-    "mechanical.warning",
-    "judge.warning",
-}
-HISTORICAL_PAIR_TRIGGER_REASON_ALIASES = {
-    "risk_profile.high_risk",
-    "risk_probes_enabled",
-}
-HISTORICAL_NORMALIZED_PAIR_TRIGGER_REASON_ALIASES = {
-    "complexity.high.spec.frontmatter",
-    "frontmatter.complexity.high",
-    "high.complexity.spec",
-    "high.risk.profile",
-    "spec.frontmatter.complexity.high",
-    "state.complexity.high",
-}
-# Benchmark readers accept historical aliases only for archived artifacts.
-# Runtime /devlyn:resolve state must continue to emit canonical reasons.
-KNOWN_PAIR_TRIGGER_REASONS = (
-    CANONICAL_PAIR_TRIGGER_REASONS | HISTORICAL_PAIR_TRIGGER_REASON_ALIASES
-)
-OBSERVABLE_COMMAND_MARKERS = ("command", "observable", "expose")
-BACKTICKED_TEXT_RE = re.compile(r"`[^`\n]+`")
-RESERVED_BACKTICK_TERMS = {"solo-headroom hypothesis", "solo_claude", "miss"}
-COMMAND_PREFIXES = {
-    "bash",
-    "bun",
-    "cargo",
-    "git",
-    "go",
-    "jest",
-    "make",
-    "node",
-    "npm",
-    "pnpm",
-    "printf",
-    "pytest",
-    "python",
-    "python3",
-    "ruff",
-    "sh",
-    "uv",
-    "vitest",
-    "yarn",
-}
-
-
-def reject_json_constant(token: str) -> None:
-    raise ValueError(f"invalid JSON numeric constant: {token}")
-
-
-def loads_strict_json_object(text: str) -> dict[str, Any]:
-    data = json.loads(text, parse_constant=reject_json_constant)
-    if not isinstance(data, dict):
-        raise ValueError("top-level JSON value must be an object")
-    return data
-
-
-def normalized_pair_trigger_reason(reason: str) -> str:
-    return re.sub(r"[^a-z0-9]+", ".", reason.lower()).strip(".")
-
-
-def is_known_pair_trigger_reason(reason: str) -> bool:
-    normalized = normalized_pair_trigger_reason(reason)
-    return (
-        reason in CANONICAL_PAIR_TRIGGER_REASONS
-        or reason in HISTORICAL_PAIR_TRIGGER_REASON_ALIASES
-        or normalized in HISTORICAL_NORMALIZED_PAIR_TRIGGER_REASON_ALIASES
-    )
-
-
-def is_canonical_pair_trigger_reason(reason: str) -> bool:
-    return reason in CANONICAL_PAIR_TRIGGER_REASONS
-
-
-def is_historical_pair_trigger_reason(reason: str) -> bool:
-    normalized = normalized_pair_trigger_reason(reason)
-    return (
-        reason in HISTORICAL_PAIR_TRIGGER_REASON_ALIASES
-        or normalized in HISTORICAL_NORMALIZED_PAIR_TRIGGER_REASON_ALIASES
-    )
-
-
-def has_known_pair_trigger_reason(reasons: list[str]) -> bool:
-    return any(is_known_pair_trigger_reason(reason) for reason in reasons)
-
-
-def all_known_pair_trigger_reasons(reasons: list[str]) -> bool:
-    return all(is_known_pair_trigger_reason(reason) for reason in reasons)
-
-
-def has_canonical_pair_trigger_reason(reasons: list[str]) -> bool:
-    return any(is_canonical_pair_trigger_reason(reason) for reason in reasons)
-
-
-def has_historical_pair_trigger_reason(reasons: list[str]) -> bool:
-    return any(is_historical_pair_trigger_reason(reason) for reason in reasons)
-
-
-def is_command_like_backtick(value: str) -> bool:
-    stripped = value.strip()
-    lower = stripped.lower()
-    if not stripped or lower in RESERVED_BACKTICK_TERMS:
-        return False
-    first = lower.split(maxsplit=1)[0]
-    return (
-        first in COMMAND_PREFIXES
-        or any(marker in stripped for marker in ("/", "$", "=", "|", "&&", ";"))
-        or stripped.endswith((".js", ".py", ".sh"))
-    )
-
-
-def actionable_observable_commands(text: str) -> list[str]:
-    commands: list[str] = []
-    for line in text.splitlines():
-        lower = line.lower()
-        if "miss" not in lower or not any(marker in lower for marker in OBSERVABLE_COMMAND_MARKERS):
-            continue
-        for match in BACKTICKED_TEXT_RE.finditer(line):
-            value = match.group(0).strip("`")
-            if is_command_like_backtick(value):
-                commands.append(value)
-    return commands
-
-
-def has_actionable_solo_headroom_hypothesis_text(text: str) -> bool:
-    lower = text.lower()
-    return (
-        "solo-headroom hypothesis" in lower
-        and "solo_claude" in lower
-        and "miss" in lower
-        and bool(actionable_observable_commands(text))
-    )
-
-
-def path_has_actionable_solo_headroom_hypothesis(path: Path) -> bool:
-    try:
-        text = path.read_text(encoding="utf-8")
-    except OSError:
-        return False
-    return has_actionable_solo_headroom_hypothesis_text(text)
-
-
-def normalize_pair_evidence_row(
-    *,
-    fixture: str,
-    run_id: str,
-    pair_arm: object,
-    row: dict[str, Any],
-) -> dict[str, Any] | None:
-    bare_score = row.get("bare_score")
-    solo_score = row.get("solo_score")
-    pair_score = row.get("pair_score")
-    pair_margin = row.get("pair_margin")
-    pair_mode = row.get("pair_mode")
-    pair_trigger_eligible = row.get("pair_trigger_eligible")
-    pair_trigger_reasons = row.get("pair_trigger_reasons")
-    wall_ratio = row.get("pair_solo_wall_ratio")
-    if not fixture or not run_id:
-        return None
-    if not isinstance(pair_arm, str) or pair_arm not in ALLOWED_PAIR_ARMS:
-        return None
-    if not all(is_score(value) for value in [bare_score, solo_score, pair_score]):
-        return None
-    if not is_strict_int(pair_margin):
-        return None
-    if pair_margin != pair_score - solo_score:
-        return None
-    if pair_mode is not True:
-        return None
-    if pair_trigger_eligible is not True:
-        return None
-    if not (
-        isinstance(pair_trigger_reasons, list)
-        and pair_trigger_reasons
-        and all(isinstance(reason, str) for reason in pair_trigger_reasons)
-        and all_known_pair_trigger_reasons(pair_trigger_reasons)
-        and has_canonical_pair_trigger_reason(pair_trigger_reasons)
-    ):
-        return None
-    if not is_strict_number(wall_ratio):
-        return None
-    normalized = {
-        "run_id": run_id,
-        "pair_arm": pair_arm,
-        "bare_score": bare_score,
-        "solo_score": solo_score,
-        "pair_score": pair_score,
-        "pair_margin": pair_margin,
-        "pair_mode": pair_mode,
-        "pair_trigger_eligible": pair_trigger_eligible,
-        "pair_trigger_reasons": pair_trigger_reasons,
-        "pair_trigger_has_canonical_reason": True,
-        "pair_trigger_has_hypothesis_reason": (
-            "spec.solo_headroom_hypothesis" in pair_trigger_reasons
-        ),
-        "pair_solo_wall_ratio": wall_ratio,
-    }
-    return normalized
-
-
-def best_pair_evidence(evidence: list[object]) -> dict[str, Any] | None:
-    candidates = [
-        normalized
-        for item in evidence
-        if isinstance(item, dict)
-        if isinstance(item.get("run_id"), str)
-        for normalized in [
-            normalize_pair_evidence_row(
-                fixture="_",
-                run_id=item["run_id"],
-                pair_arm=item.get("pair_arm"),
-                row=item,
-            )
-        ]
-        if normalized is not None
-    ]
-    if not candidates:
-        return None
-
-    def key(item: dict[str, Any]) -> tuple[int, int, str]:
-        margin = item.get("pair_margin")
-        pair_score = item.get("pair_score")
-        return (
-            margin if isinstance(margin, int) else -10_000,
-            pair_score if isinstance(pair_score, int) else -10_000,
-            str(item.get("run_id") or ""),
-        )
-
-    return max(candidates, key=key)
-
-
-def is_strict_int(value: object) -> bool:
-    return isinstance(value, int) and not isinstance(value, bool)
-
-
-def is_score(value: object) -> bool:
-    return is_strict_int(value) and 0 <= value <= 100
-
-
-def is_strict_number(value: object) -> bool:
-    return (
-        isinstance(value, (int, float))
-        and not isinstance(value, bool)
-        and math.isfinite(value)
-        and value > 0
-    )

package/benchmark/auto-resolve/scripts/prepare-swebench-frozen-case.py

@@ -1,273 +0,0 @@
-#!/usr/bin/env python3
-"""Prepare a SWE-bench instance for frozen VERIFY solo-vs-pair review.
-
-The script does not run models and does not evaluate SWE-bench correctness.
-It converts one official SWE-bench-style instance plus one candidate patch into
-the case layout consumed by run-frozen-verify-pair.sh.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import shlex
-import shutil
-import subprocess
-from pathlib import Path
-from typing import Any
-
-from pair_evidence_contract import loads_strict_json_object
-
-
-SAFE_ID = re.compile(r"^[A-Za-z0-9_.-]+$")
-SAFE_REPO = re.compile(r"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$")
-SAFE_COMMIT = re.compile(r"^[0-9a-fA-F]{7,40}$")
-
-
-def run(cmd: list[str], cwd: Path | None = None) -> None:
-    subprocess.run(cmd, cwd=cwd, check=True)
-
-
-def read_json(path: Path) -> dict[str, Any]:
-    try:
-        return loads_strict_json_object(path.read_text(encoding="utf8"))
-    except ValueError as exc:
-        if str(exc) == "top-level JSON value must be an object":
-            raise ValueError(f"expected JSON object: {path}") from exc
-        raise
-
-
-def require_text(instance: dict[str, Any], key: str) -> str:
-    value = instance.get(key)
-    if not isinstance(value, str) or not value.strip():
-        raise ValueError(f"SWE-bench instance missing non-empty {key!r}")
-    return value.strip()
-
-
-def positive_int(value: str) -> int:
-    try:
-        parsed = int(value)
-    except ValueError as exc:
-        raise argparse.ArgumentTypeError("must be an integer") from exc
-    if parsed <= 0:
-        raise argparse.ArgumentTypeError("must be > 0")
-    return parsed
-
-
-def require_safe_repo(instance: dict[str, Any]) -> str:
-    repo = require_text(instance, "repo")
-    if not SAFE_REPO.match(repo):
-        raise ValueError(f"unsafe SWE-bench repo: {repo!r}")
-    return repo
-
-
-def require_safe_base_commit(instance: dict[str, Any]) -> str:
-    base_commit = require_text(instance, "base_commit")
-    if not SAFE_COMMIT.match(base_commit):
-        raise ValueError(f"unsafe SWE-bench base_commit: {base_commit!r}")
-    return base_commit
-
-
-def repo_cache_name(repo: str, base_commit: str) -> str:
-    safe_repo = repo.replace("/", "__")
-    return f"{safe_repo}-{base_commit[:12]}"
-
-
-def prepare_repo(instance: dict[str, Any], repo_dir: Path | None, repos_root: Path) -> Path:
-    repo = require_safe_repo(instance)
-    base_commit = require_safe_base_commit(instance)
-    repos_root.mkdir(parents=True, exist_ok=True)
-    dest = repos_root / repo_cache_name(repo, base_commit)
-
-    if repo_dir is not None:
-        if dest.exists():
-            shutil.rmtree(dest)
-        run(["git", "clone", "--quiet", "--no-hardlinks", str(repo_dir), str(dest)])
-    elif not dest.exists():
-        run(["git", "clone", "--quiet", f"https://github.com/{repo}.git", str(dest)])
-
-    run(["git", "fetch", "--quiet", "--all", "--tags"], cwd=dest)
-    run(["git", "checkout", "--quiet", base_commit], cwd=dest)
-    run(["git", "reset", "--hard", "--quiet"], cwd=dest)
-    run(["git", "clean", "-ffdqx"], cwd=dest)
-    return dest
-
-
-def write_case_files(
-    instance: dict[str, Any],
-    case_dir: Path,
-    patch_text: str,
-    timeout_seconds: int,
-) -> None:
-    instance_id = require_text(instance, "instance_id")
-    repo = require_safe_repo(instance)
-    base_commit = require_safe_base_commit(instance)
-    problem = require_text(instance, "problem_statement")
-    case_dir.mkdir(parents=True, exist_ok=True)
-
-    metadata = {
-        "id": instance_id,
-        "category": "high-risk",
-        "difficulty": instance.get("difficulty") or "swebench",
-        "timeout_seconds": timeout_seconds,
-        "required_tools": ["git", "python3"],
-        "browser": False,
-        "deps_change_expected": True,
-        "intent": f"SWE-bench issue for {repo} at {base_commit}: resolve the supplied problem statement without using the gold patch.",
-        "source": {
-            "benchmark": "SWE-bench",
-            "repo": repo,
-            "base_commit": base_commit,
-            "issue_url": instance.get("issue_url"),
-            "pr_url": instance.get("pr_url"),
-            "version": instance.get("version"),
-        },
-    }
-    (case_dir / "metadata.json").write_text(json.dumps(metadata, indent=2) + "\n", encoding="utf8")
-
-    spec = f"""---
-id: "{instance_id}"
-title: "SWE-bench {instance_id}"
-status: planned
-complexity: high
-depends-on: []
----
-
-# SWE-bench {instance_id}
-
-## Context
-
-Repository: `{repo}`
-Base commit: `{base_commit}`
-
-This case is imported from a SWE-bench-style instance. Treat the problem
-statement below as the visible user contract. Do not use the gold `patch` or
-`test_patch` fields as implementation guidance during model generation or
-review.
-
-## Requirements
-
-- [ ] Resolve the reported issue described in the problem statement.
-- [ ] Preserve existing behavior outside the issue's scope.
-- [ ] Keep the implementation consistent with the repository's local style and
-      dependency policy.
-- [ ] Surface failures explicitly; do not hide errors behind silent fallbacks.
-
-## Problem Statement
-
-{problem}
-
-## Constraints
-
-- Do not inspect or rely on the SWE-bench gold solution patch while producing
-  or judging a candidate patch.
-- Do not add broad rewrites, unrelated formatting churn, or new dependencies
-  unless the problem statement strictly requires them.
-- Frozen VERIFY compares reviewers on the same already-applied candidate patch;
-  it is review evidence, not a full SWE-bench solve-rate measurement.
-
-## Verification
-
-- Run the official SWE-bench evaluator separately for solve-rate evidence.
-- Use `/devlyn:resolve --verify-only` here only to compare solo vs gated pair
-  review of the frozen candidate patch against the visible problem statement.
-"""
-    (case_dir / "spec.md").write_text(spec, encoding="utf8")
-    (case_dir / "task.txt").write_text(problem + "\n", encoding="utf8")
-    (case_dir / "expected.json").write_text(
-        json.dumps(
-            {
-                "verification_commands": [],
-                "forbidden_patterns": [],
-                "required_files": [],
-                "forbidden_files": [],
-                "tier_a_waivers": [],
-                "spec_output_files": [],
-                "max_deps_added": 999,
-            },
-            indent=2,
-        )
-        + "\n",
-        encoding="utf8",
-    )
-    (case_dir / "setup.sh").write_text("#!/usr/bin/env bash\nset -euo pipefail\n", encoding="utf8")
-    (case_dir / "setup.sh").chmod(0o755)
-    notes = f"""# {instance_id} — SWE-bench Frozen VERIFY Case
-
-Source repo: `{repo}`
-Base commit: `{base_commit}`
-
-This case exists to measure whether gated pair VERIFY catches verdict-binding
-review issues that solo VERIFY misses on a fixed candidate patch. It does not
-replace official SWE-bench pass/fail evaluation.
-"""
-    (case_dir / "NOTES.md").write_text(notes, encoding="utf8")
-    (case_dir / "model.patch").write_text(patch_text, encoding="utf8")
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--instance-json", required=True, type=Path)
-    parser.add_argument("--model-patch", required=True, type=Path)
-    parser.add_argument(
-        "--cases-root",
-        default=Path("benchmark/auto-resolve/external/swebench/cases"),
-        type=Path,
-    )
-    parser.add_argument(
-        "--repos-root",
-        default=Path("benchmark/auto-resolve/external/swebench/repos"),
-        type=Path,
-    )
-    parser.add_argument(
-        "--repo-dir",
-        type=Path,
-        help="Local clone/source repo to copy instead of cloning GitHub; useful for tests and cached runs.",
-    )
-    parser.add_argument("--timeout-seconds", type=positive_int, default=2400)
-    args = parser.parse_args()
-
-    instance = read_json(args.instance_json)
-    instance_id = require_text(instance, "instance_id")
-    if not SAFE_ID.match(instance_id):
-        raise ValueError(f"unsafe instance_id for path/spec use: {instance_id!r}")
-    patch_text = args.model_patch.read_text(encoding="utf8")
-    if not patch_text.strip():
-        raise ValueError(f"model patch is empty: {args.model_patch}")
-
-    repo_path = prepare_repo(instance, args.repo_dir, args.repos_root)
-    case_dir = args.cases_root / instance_id
-    write_case_files(instance, case_dir, patch_text, args.timeout_seconds)
-
-    command = [
-        "bash",
-        "benchmark/auto-resolve/scripts/run-frozen-verify-pair.sh",
-        "--fixture",
-        instance_id,
-        "--fixtures-root",
-        str(args.cases_root),
-        "--base-repo",
-        str(repo_path),
-        "--diff",
-        str(case_dir / "model.patch"),
-        "--pair-mode",
-        "gated",
-    ]
-    (case_dir / "run-command.txt").write_text(shlex.join(command) + "\n", encoding="utf8")
-    print(
-        json.dumps(
-            {
-                "instance_id": instance_id,
-                "case_dir": str(case_dir),
-                "repo_dir": str(repo_path),
-                "run_command": command,
-            },
-            indent=2,
-        )
-    )
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/benchmark/auto-resolve/scripts/prepare-swebench-frozen-corpus.py

@@ -1,148 +0,0 @@
-#!/usr/bin/env python3
-"""Prepare a SWE-bench prediction JSONL as frozen VERIFY review cases."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import subprocess
-import tempfile
-from pathlib import Path
-from typing import Any
-
-from pair_evidence_contract import loads_strict_json_object, 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 require_text(row: dict[str, Any], key: str, source: str) -> str:
-    value = row.get(key)
-    if not isinstance(value, str) or not value.strip():
-        raise ValueError(f"{source} missing non-empty {key!r}")
-    return value.strip()
-
-
-def positive_int(value: str) -> int:
-    try:
-        parsed = int(value)
-    except ValueError as exc:
-        raise argparse.ArgumentTypeError("must be an integer") from exc
-    if parsed <= 0:
-        raise argparse.ArgumentTypeError("must be > 0")
-    return parsed
-
-
-def parse_prepared_case(stdout: str, source: str) -> dict[str, Any]:
-    try:
-        value = loads_strict_json_object(stdout)
-    except ValueError as exc:
-        if str(exc) == "top-level JSON value must be an object":
-            raise ValueError(f"{source}: expected JSON object") from exc
-        raise
-    for key in ("instance_id", "case_dir", "repo_dir", "run_command"):
-        if key == "run_command":
-            if not isinstance(value.get(key), list) or not value[key]:
-                raise ValueError(f"{source}: missing non-empty {key!r}")
-        elif not isinstance(value.get(key), str) or not value[key].strip():
-            raise ValueError(f"{source}: missing non-empty {key!r}")
-    return value
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--instances-jsonl", required=True, type=Path)
-    parser.add_argument("--predictions-jsonl", required=True, type=Path)
-    parser.add_argument(
-        "--cases-root",
-        default=Path("benchmark/auto-resolve/external/swebench/cases"),
-        type=Path,
-    )
-    parser.add_argument(
-        "--repos-root",
-        default=Path("benchmark/auto-resolve/external/swebench/repos"),
-        type=Path,
-    )
-    parser.add_argument("--repo-dir", type=Path, help="Use one local repo clone for every selected instance.")
-    parser.add_argument("--instance-id", action="append", help="Prepare only these instance ids.")
-    parser.add_argument("--limit", type=positive_int, help="Prepare at most N matched instances after filtering.")
-    parser.add_argument("--timeout-seconds", type=positive_int, default=2400)
-    parser.add_argument("--out-manifest", type=Path)
-    args = parser.parse_args()
-
-    instances = {require_text(row, "instance_id", f"{args.instances_jsonl}"): row for row in read_jsonl(args.instances_jsonl)}
-    predictions: dict[str, dict[str, Any]] = {}
-    for row in read_jsonl(args.predictions_jsonl):
-        instance_id = require_text(row, "instance_id", f"{args.predictions_jsonl}")
-        if instance_id in predictions:
-            raise ValueError(f"duplicate prediction for {instance_id}")
-        predictions[instance_id] = row
-
-    selected_ids = args.instance_id or list(predictions)
-    if not selected_ids:
-        raise ValueError("no prediction instances selected")
-    script = Path(__file__).with_name("prepare-swebench-frozen-case.py")
-    prepared: list[dict[str, Any]] = []
-    with tempfile.TemporaryDirectory() as tmp:
-        tmp_dir = Path(tmp)
-        for instance_id in selected_ids:
-            if args.limit is not None and len(prepared) >= args.limit:
-                break
-            if instance_id not in instances:
-                raise ValueError(f"prediction instance not found in instances JSONL: {instance_id}")
-            prediction = predictions.get(instance_id)
-            if prediction is None:
-                raise ValueError(f"selected instance missing prediction: {instance_id}")
-            patch_value = prediction.get("model_patch")
-            if not isinstance(patch_value, str) or not patch_value.strip():
-                raise ValueError(f"prediction {instance_id} missing non-empty 'model_patch'")
-            instance_path = tmp_dir / f"{instance_id}.instance.json"
-            patch_path = tmp_dir / f"{instance_id}.patch"
-            instance_path.write_text(json.dumps(instances[instance_id], indent=2) + "\n", encoding="utf8")
-            patch_path.write_text(patch_value, encoding="utf8")
-
-            cmd = [
-                "python3",
-                str(script),
-                "--instance-json",
-                str(instance_path),
-                "--model-patch",
-                str(patch_path),
-                "--cases-root",
-                str(args.cases_root),
-                "--repos-root",
-                str(args.repos_root),
-                "--timeout-seconds",
-                str(args.timeout_seconds),
-            ]
-            if args.repo_dir is not None:
-                cmd.extend(["--repo-dir", str(args.repo_dir)])
-            completed = subprocess.run(cmd, check=True, text=True, capture_output=True)
-            prepared.append(parse_prepared_case(completed.stdout, f"prepared case {instance_id}"))
-
-    manifest = {
-        "instances_jsonl": str(args.instances_jsonl),
-        "predictions_jsonl": str(args.predictions_jsonl),
-        "cases_root": str(args.cases_root),
-        "repos_root": str(args.repos_root),
-        "prepared_count": len(prepared),
-        "prepared": prepared,
-    }
-    if args.out_manifest:
-        args.out_manifest.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf8")
-    print(json.dumps(manifest, indent=2))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())