@event4u/agent-config 6.0.0 → 7.0.0

package/src/scripts/backfill_model_tier.py

@@ -1,184 +0,0 @@
-#!/usr/bin/env python3
-"""Backfill / migrate `model_tier` on every skill and command (ADR-035).
-
-Vendor-neutral capability band `lite | medium | high | inherit` (replaces the
-concrete-model `recommended_model` from ADR-034). Behaviour per artefact:
-
-- **Has `recommended_model`** (ADR-034 legacy) → migrate via the value map
-  (`opus→high`, `sonnet→medium`, `gpt→high`, `inherit→inherit`) and rename the
-  key to `model_tier`. Same line count — no body shift.
-- **Already `model_tier`** → leave (idempotent).
-- **Untagged** → classify fresh from the task→tier heuristic
-  (`contexts/model-recommendations.md`): deep reasoning → high; mechanical /
-  impl / docs / tests / quality → medium; clearly-trivial → lite; meta /
-  ambiguous → inherit.
-
-A small explicit `_LITE` set demotes obviously-trivial mechanical skills to the
-cheapest band; `_CONTEXT_LARGE` adds the orthogonal `context: large` modifier to
-genuinely long-context skills. Writes BOTH the source and its `dist/agent-src` copy
-(frontmatter stays byte-identical); refresh condensation hashes afterwards.
-
-CLI: python3 scripts/backfill_model_tier.py [--dry-run]
-"""
-from __future__ import annotations
-
-import argparse
-import re
-import sys
-from collections import Counter
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-from validate_frontmatter import parse_frontmatter  # noqa: E402
-from _lib.agent_src import artefact_roots, iter_commands, strip_source_prefix  # noqa: E402
-
-ROOT = Path(__file__).resolve().parents[2]
-CONDENSED = ROOT / "dist/agent-src"
-
-# ADR-034 → ADR-035 value map.
-_MIGRATE = {"opus": "high", "sonnet": "medium", "gpt": "high", "inherit": "inherit"}
-
-# Fresh-classification slug signals (deep reasoning / large-analysis → high).
-_HIGH = (
-    "architect", "refactor", "debug", "threat", "authz", "adversarial",
-    "blast-radius", "defense-in-depth", "data-flow", "decision-record",
-    "adr-create", "security-audit", "privacy-review", "review", "judge-",
-    "bug-analyzer", "systematic-debugging", "incident", "risk-officer",
-    "migration-architect", "moat", "analysis", "analyze", "analyzer",
-    "research", "deep-reading", "repomix", "sequential-thinking",
-    "project-analysis", "universal-project", "market-entry",
-    "scenario-modeling", "forecast", "dcf-modeling", "unit-economics",
-    "funnel-analysis",
-)
-_MEDIUM = (
-    "test", "pest", "playwright", "lint", "quality-tools", "format", "docs",
-    "readme-writing", "commit", "conventional", "css", "tailwind", "blade",
-    "flux", "livewire", "form-handler", "api-endpoint", "api-testing",
-    "eloquent", "laravel", "dto", "mail", "notification", "migration",
-    "middleware", "scheduling", "websocket", "reverb", "horizon", "pulse",
-    "pennant", "validation", "docker", "terraform", "terragrunt", "github-ci",
-    "traefik", "grafana", "dashboard", "openapi", "sql", "artisan", "composer",
-    "jobs-events", "multi-tenancy", "secrets", "logging", "database",
-    "php-coder", "php-service", "nextjs", "react", "symfony", "mcp",
-    "devcontainer", "copilot", "module",
-)
-_DOMAIN_DEFAULT = {
-    "engineering": "medium", "quality": "medium", "devops": "medium",
-    "discovery": "high", "product": "inherit", "process": "inherit",
-}
-
-# Clearly-trivial, no-reasoning mechanical skills → cheapest band.
-_LITE = {"file-editor", "md-language-check"}
-# Genuinely long-context skills → orthogonal context modifier (ADR-035).
-_CONTEXT_LARGE = {
-    "project-analysis-core", "project-analysis-hypothesis-driven",
-    "project-analyzer", "universal-project-analysis", "repomix-packer",
-    "deep-reading-analyst",
-}
-
-_RM_RE = re.compile(r'^recommended_model:[ \t]*"?[a-z0-9-]+"?[ \t]*$', re.MULTILINE)
-_MT_RE = re.compile(r'^model_tier:', re.MULTILINE)
-_CTX_RE = re.compile(r'^context:', re.MULTILINE)
-
-
-def _classify(slug: str, domain: str | None) -> str:
-    s = slug.lower()
-    if s in _LITE:
-        return "lite"
-    if any(k in s for k in _HIGH):
-        return "high"
-    if any(k in s for k in _MEDIUM):
-        return "medium"
-    return _DOMAIN_DEFAULT.get(domain or "", "inherit")
-
-
-def _resolve_tier(slug: str, fm: dict | None) -> str:
-    existing_mt = fm.get("model_tier") if isinstance(fm, dict) else None
-    if existing_mt:
-        tier = existing_mt
-    else:
-        existing_rm = fm.get("recommended_model") if isinstance(fm, dict) else None
-        if existing_rm:
-            tier = _MIGRATE.get(existing_rm, "inherit")
-        else:
-            tier = _classify(slug, fm.get("domain") if isinstance(fm, dict) else None)
-    return "lite" if slug in _LITE else tier
-
-
-def _apply(path: Path, tier: str, want_context: bool) -> bool:
-    text = path.read_text(encoding="utf-8")
-    if not text.startswith("---\n"):
-        return False
-    end = text.find("\n---\n", 4)
-    if end == -1:
-        return False
-    fm, body = text[4:end], text[end:]
-    changed = False
-    if _MT_RE.search(fm):
-        pass  # already migrated — idempotent
-    elif _RM_RE.search(fm):
-        fm = _RM_RE.sub(f"model_tier: {tier}", fm, count=1)
-        changed = True
-    else:
-        fm = f"model_tier: {tier}\n" + fm
-        changed = True
-    if want_context and not _CTX_RE.search(fm):
-        fm = re.sub(r'(^model_tier:.*$)', r'\1\ncontext: large', fm, count=1, flags=re.MULTILINE)
-        changed = True
-    if changed:
-        path.write_text("---\n" + fm + body, encoding="utf-8")
-    return changed
-
-
-def _iter():
-    for root in artefact_roots():
-        sdir = root / "skills"
-        if sdir.exists():
-            for p in sorted(sdir.rglob("SKILL.md")):
-                slug = p.parent.name
-                yield p, CONDENSED / "skills" / slug / "SKILL.md", slug
-    # Commands live under packages/*/commands/ AND the 6.0.0-D
-    # src/domains/<pack>/<subpath>/command.md homes; iter_commands() covers
-    # both. The condensed path + slug derive from the logical command path.
-    for p in iter_commands():
-        if p.name == "AGENTS.md":
-            continue
-        logical = strip_source_prefix(p.relative_to(ROOT).as_posix()) or ""
-        sub = logical[len("commands/"):] if logical.startswith("commands/") else p.name
-        slug = "-".join(Path(sub).with_suffix("").parts)
-        yield p, CONDENSED / "commands" / sub, slug
-
-
-def run(apply: bool) -> int:
-    dist: Counter = Counter()
-    ctx = 0
-    touched = 0
-    for src, cond, slug in _iter():
-        fm, _ = parse_frontmatter(src.read_text(encoding="utf-8"))
-        tier = _resolve_tier(slug, fm)
-        want_ctx = slug in _CONTEXT_LARGE
-        dist[tier] += 1
-        if want_ctx:
-            ctx += 1
-        if apply:
-            if _apply(src, tier, want_ctx):
-                touched += 1
-            if cond.exists():
-                _apply(cond, tier, want_ctx)
-    verb = "would set" if not apply else "set"
-    print(f"model_tier backfill ({'dry-run' if not apply else 'apply'}):")
-    for t in ("lite", "medium", "high", "inherit"):
-        print(f"  {t:8s}: {dist[t]}")
-    print(f"  context:large on {ctx} skills · {verb} {touched} newly · total {sum(dist.values())}")
-    return 0
-
-
-def main(argv=None) -> int:
-    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    ap.add_argument("--dry-run", action="store_true")
-    args = ap.parse_args(argv)
-    return run(apply=not args.dry_run)
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/src/scripts/bench_ab_cache_dispatch.py

@@ -1,68 +0,0 @@
-#!/usr/bin/env python3
-"""Cache-aware dispatch for `task bench:ab` arms.
-
-Phase 5 supporting helper. Wraps the Phase 2 cache lookup so the Taskfile
-entries can stay readable. Given a corpus name (`tracka` / `trackb`),
-checks whether the cached `without` report is fresh; if so, runs only the
-`with` arm of the corresponding runner. Otherwise runs both.
-
-Cost-saving math: a daily `task bench:ab` re-runs only the `with` arm
-when the corpus, claude CLI version, and target shape haven't changed.
-That halves the wall-time + cost of the daily run.
-"""
-from __future__ import annotations
-
-import argparse
-import subprocess
-import sys
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent.parent.parent
-sys.path.insert(0, str(REPO_ROOT / "src" / "scripts"))
-
-from _lib import bench_ab_cache  # type: ignore[import-not-found]  # noqa: E402
-
-RUNNER_FOR = {
-    "tracka": (REPO_ROOT / "src" / "scripts" / "bench_ab_tracka_run.py", "ab-tracka.yaml"),
-    "trackb": (REPO_ROOT / "src" / "scripts" / "bench_ab_task_runner.py", "ab-trackb.yaml"),
-}
-
-
-def parse_args(argv: list[str]) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Cache-aware dispatch.")
-    parser.add_argument("corpus", choices=tuple(RUNNER_FOR))
-    parser.add_argument(
-        "extra",
-        nargs=argparse.REMAINDER,
-        help="Extra args forwarded to the underlying runner.",
-    )
-    return parser.parse_args(argv)
-
-
-def main(argv: list[str] | None = None) -> int:
-    args = parse_args(argv if argv is not None else sys.argv[1:])
-    runner, corpus_name = RUNNER_FOR[args.corpus]
-    corpus_path = REPO_ROOT / "internal" / "bench" / "corpora" / corpus_name
-    if not corpus_path.exists():
-        sys.stderr.write(f"bench_ab_cache_dispatch: corpus missing at {corpus_path}\n")
-        return 1
-    lookup = bench_ab_cache.lookup(corpus_path)
-    if lookup.fresh and lookup.report_path is not None:
-        sys.stdout.write(
-            f"bench_ab_cache_dispatch ({args.corpus}): reusing fresh without baseline "
-            f"({lookup.report_path.name}) — running with-arm only\n"
-        )
-        variants = ("with",)
-    else:
-        sys.stdout.write(
-            f"bench_ab_cache_dispatch ({args.corpus}): cache {lookup.reason} — running both arms\n"
-        )
-        variants = ("with", "without")
-    cmd = [sys.executable, str(runner), "--variant", variants[0]] + list(args.extra)
-    if len(variants) == 2:
-        cmd = [sys.executable, str(runner), "--variant", "both"] + list(args.extra)
-    return subprocess.run(cmd, check=False).returncode
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/scripts/bench_ab_clone.py

@@ -1,170 +0,0 @@
-#!/usr/bin/env python3
-"""Materialise the `with` and `without` clones for the package-impact A/B bench.
-
-Phase 1 Step 2 of `agents/roadmaps/road-to-package-impact-benchmark.md`.
-
-The fixture lives at `internal/bench/ab/fixture/`. Both clones are byte-identical
-copies of the fixture; the `with` clone additionally receives the agent-config
-surface (`.claude/`, `.augment/`, `AGENTS.md`, `CLAUDE.md`) so a Claude Code
-session run inside it sees the same files a consumer project would after
-running the installer.
-
-Idempotent: re-running without `--refresh` leaves an existing clone alone. With
-`--refresh`, the target clone is removed and rebuilt from scratch.
-
-The clones tree (`internal/bench/ab/clones/`) is gitignored — only this script's
-output schema is committed.
-"""
-from __future__ import annotations
-
-import argparse
-import hashlib
-import json
-import os
-import shutil
-import sys
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parents[2]
-AB_ROOT = REPO_ROOT / "internal" / "bench" / "ab"
-FIXTURE = AB_ROOT / "fixture"
-CLONES = AB_ROOT / "clones"
-
-# Surfaces the `with` clone inherits from the package root.
-WITH_SURFACES = (
-    ".claude",
-    ".augment",
-    "AGENTS.md",
-    "CLAUDE.md",
-)
-
-
-def die(msg: str) -> None:
-    sys.stderr.write(f"bench_ab_clone: {msg}\n")
-    raise SystemExit(1)
-
-
-def copytree_preserve(src: Path, dst: Path) -> None:
-    """Copy tree, dereferencing symlinks.
-
-    The package installs the `.claude/` surface as a tree of symlinks into
-    `dist/agent-src/`. Cloning the surface as symlinks would carry pointers that
-    resolve against the package root, not the clone — meaning a Claude Code
-    session inside the clone could not actually read the rule bodies. Deref
-    at copy time produces standalone files inside the clone.
-    """
-    if dst.exists():
-        shutil.rmtree(dst)
-    shutil.copytree(src, dst, symlinks=False)
-
-
-def materialise_clone(variant: str, target: Path) -> None:
-    """Copy the fixture into the target, then layer the variant-specific surface."""
-    target.mkdir(parents=True, exist_ok=True)
-    # Mirror the fixture
-    for entry in FIXTURE.iterdir():
-        dest = target / entry.name
-        if entry.is_dir():
-            copytree_preserve(entry, dest)
-        else:
-            shutil.copy2(entry, dest)
-    # Layer the agent-config surface onto the `with` variant
-    if variant == "with":
-        for surface in WITH_SURFACES:
-            src = REPO_ROOT / surface
-            if not src.exists():
-                # Best-effort: a missing surface is reported but does not fail
-                sys.stderr.write(
-                    f"bench_ab_clone: surface '{surface}' missing in package root; "
-                    "with-clone may not be representative\n"
-                )
-                continue
-            dest = target / surface
-            if src.is_dir():
-                copytree_preserve(src, dest)
-            else:
-                shutil.copy2(src, dest)
-
-
-def target_shape_hash() -> str:
-    """Stable hash of the fixture tree + the with-surface list.
-
-    Used by Phase 2's cache key. Recomputing this here keeps the cache code
-    and the clone code reading the same surface definition.
-    """
-    h = hashlib.sha256()
-    h.update(b"with-surfaces:" + json.dumps(WITH_SURFACES).encode() + b"\n")
-    for path in sorted(FIXTURE.rglob("*")):
-        if not path.is_file():
-            continue
-        rel = path.relative_to(FIXTURE).as_posix()
-        h.update(f"{rel}\n".encode())
-        h.update(path.read_bytes())
-        h.update(b"\n")
-    return h.hexdigest()[:16]
-
-
-def write_manifest(variant: str, target: Path) -> None:
-    """Drop a small manifest so other scripts can verify the clone shape."""
-    manifest = {
-        "variant": variant,
-        "target_shape_hash": target_shape_hash(),
-        "with_surfaces": list(WITH_SURFACES),
-        "fixture_relpath": FIXTURE.relative_to(REPO_ROOT).as_posix(),
-    }
-    (target / ".bench-ab-manifest.json").write_text(
-        json.dumps(manifest, indent=2) + "\n"
-    )
-
-
-def clone(variant: str, *, refresh: bool) -> Path:
-    target = CLONES / variant
-    if target.exists() and not refresh:
-        sys.stdout.write(f"bench_ab_clone: {variant} clone already present at {target} (use --refresh to rebuild)\n")
-        return target
-    if target.exists():
-        shutil.rmtree(target)
-    materialise_clone(variant, target)
-    write_manifest(variant, target)
-    sys.stdout.write(f"bench_ab_clone: built {variant} clone at {target}\n")
-    return target
-
-
-def parse_args(argv: list[str]) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Materialise `with` and `without` clones for the A/B bench."
-    )
-    parser.add_argument(
-        "--refresh",
-        action="store_true",
-        help="Force-rebuild even if the clone already exists.",
-    )
-    parser.add_argument(
-        "--variant",
-        choices=("with", "without", "both"),
-        default="both",
-        help="Which clone to materialise (default: both).",
-    )
-    parser.add_argument(
-        "--print-shape-hash",
-        action="store_true",
-        help="Print the target-shape hash and exit without cloning.",
-    )
-    return parser.parse_args(argv)
-
-
-def main(argv: list[str] | None = None) -> int:
-    args = parse_args(argv if argv is not None else sys.argv[1:])
-    if not FIXTURE.exists():
-        die(f"fixture missing at {FIXTURE}")
-    if args.print_shape_hash:
-        sys.stdout.write(target_shape_hash() + "\n")
-        return 0
-    variants = ("with", "without") if args.variant == "both" else (args.variant,)
-    for v in variants:
-        clone(v, refresh=args.refresh)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/scripts/bench_ab_diff.py

@@ -1,220 +0,0 @@
-#!/usr/bin/env python3
-"""Diff two A/B reports (one per variant) into a comparison artefact.
-
-Phase 2 Step 4 of `agents/roadmaps/road-to-package-impact-benchmark.md`.
-
-Inputs: two report JSON paths. Output: a JSON artefact under
-`internal/bench/reports/ab/diff/{stamp}-{corpus}-diff.json` plus a matching
-`.md`. Phase 5's renderer consumes this artefact to populate `docs/benchmark.md`.
-
-The diff content depends on the corpus:
-
-- `ab-tracka` — trigger-accuracy %, false-positive count, per-rule lift.
-- `ab-trackb` — completion-rate per category, wall-time, tokens,
-  ask-vs-act ratio, tool-call count.
-
-Phase 2 only writes the structural skeleton (delta object with `with`,
-`without`, `delta` keys); Phases 3 and 4 plug their real metrics into
-the `results` blocks the runners emit, and the diff is computed in
-`compute_track_a_diff` / `compute_track_b_diff` here.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent.parent.parent
-REPORTS_DIR = REPO_ROOT / "internal" / "bench" / "reports" / "ab"
-DIFF_DIR = REPORTS_DIR / "diff"
-
-
-def utc_stamp() -> str:
-    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H-%M-%SZ")
-
-
-def load_report(path: Path) -> dict:
-    return json.loads(path.read_text())
-
-
-def compute_track_a_diff(with_results: dict, without_results: dict) -> dict:
-    """Track A: trigger accuracy + per-rule lift.
-
-    Phase 3 populates `triggers`, `per_rule_accuracy`, `false_positives` in the
-    `results` block. This helper computes the delta. While Phase 3 is not yet
-    landed, we surface what we have and zero what we don't — never invent
-    numbers.
-    """
-    def take(d: dict, key: str, default: float = 0.0) -> float:
-        value = d.get(key, default)
-        try:
-            return float(value)
-        except (TypeError, ValueError):
-            return default
-
-    with_acc = take(with_results, "trigger_accuracy")
-    without_acc = take(without_results, "trigger_accuracy")
-    return {
-        "trigger_accuracy": {
-            "with": with_acc,
-            "without": without_acc,
-            "delta_pct_points": round(with_acc - without_acc, 3),
-        },
-        "false_positives": {
-            "with": with_results.get("false_positives", 0),
-            "without": without_results.get("false_positives", 0),
-        },
-        "per_rule": {
-            "with": with_results.get("per_rule_accuracy", {}),
-            "without": without_results.get("per_rule_accuracy", {}),
-        },
-    }
-
-
-def compute_track_b_diff(with_results: dict, without_results: dict) -> dict:
-    """Track B: completion rate per category + wall-time + tokens + ask-vs-act."""
-    def mean(d: dict, key: str) -> float:
-        try:
-            return float(d.get(key, 0.0))
-        except (TypeError, ValueError):
-            return 0.0
-
-    with_cats = with_results.get("per_category", {})
-    without_cats = without_results.get("per_category", {})
-    categories = sorted(set(with_cats) | set(without_cats))
-    per_category = {}
-    for cat in categories:
-        per_category[cat] = {
-            "with": with_cats.get(cat, {}),
-            "without": without_cats.get(cat, {}),
-        }
-
-    return {
-        "per_category": per_category,
-        "wall_time_seconds": {
-            "with": mean(with_results, "mean_wall_time"),
-            "without": mean(without_results, "mean_wall_time"),
-            "delta": round(
-                mean(with_results, "mean_wall_time")
-                - mean(without_results, "mean_wall_time"),
-                3,
-            ),
-        },
-        "tokens": {
-            "with": mean(with_results, "mean_tokens"),
-            "without": mean(without_results, "mean_tokens"),
-            "delta": round(
-                mean(with_results, "mean_tokens")
-                - mean(without_results, "mean_tokens"),
-                3,
-            ),
-        },
-        # cost_usd comparison intentionally omitted — API pricing misleads
-        # subscription users; tokens are the currency-neutral metric.
-        "ask_vs_act_ratio": {
-            "with": mean(with_results, "ask_vs_act_ratio"),
-            "without": mean(without_results, "ask_vs_act_ratio"),
-        },
-        "tool_calls_per_task": {
-            "with": mean(with_results, "mean_tool_calls"),
-            "without": mean(without_results, "mean_tool_calls"),
-        },
-    }
-
-
-def render_markdown(diff: dict) -> str:
-    lines = [
-        f"# A/B Bench Diff — {diff['corpus']}",
-        "",
-        f"- Stamp: `{diff['stamp']}`",
-        f"- With:    `{diff['with_report']}`",
-        f"- Without: `{diff['without_report']}`",
-        "",
-        "## Delta",
-        "",
-        "```json",
-        json.dumps(diff.get("delta", {}), indent=2),
-        "```",
-        "",
-    ]
-    return "\n".join(lines)
-
-
-def parse_args(argv: list[str]) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Diff two A/B bench reports (one per variant)."
-    )
-    parser.add_argument("with_report", type=Path, help="Report JSON for variant=with")
-    parser.add_argument("without_report", type=Path, help="Report JSON for variant=without")
-    parser.add_argument(
-        "--out-dir",
-        type=Path,
-        default=DIFF_DIR,
-        help="Where to write the diff artefact (default: internal/bench/reports/ab/diff/)",
-    )
-    return parser.parse_args(argv)
-
-
-def main(argv: list[str] | None = None) -> int:
-    args = parse_args(argv if argv is not None else sys.argv[1:])
-    if not args.with_report.exists():
-        sys.stderr.write(f"bench_ab_diff: missing {args.with_report}\n")
-        return 1
-    if not args.without_report.exists():
-        sys.stderr.write(f"bench_ab_diff: missing {args.without_report}\n")
-        return 1
-    with_rep = load_report(args.with_report)
-    without_rep = load_report(args.without_report)
-    if with_rep.get("variant") != "with":
-        sys.stderr.write(
-            f"bench_ab_diff: {args.with_report} variant is "
-            f"{with_rep.get('variant')!r}, expected 'with'\n"
-        )
-        return 1
-    if without_rep.get("variant") != "without":
-        sys.stderr.write(
-            f"bench_ab_diff: {args.without_report} variant is "
-            f"{without_rep.get('variant')!r}, expected 'without'\n"
-        )
-        return 1
-    if with_rep.get("corpus") != without_rep.get("corpus"):
-        sys.stderr.write(
-            f"bench_ab_diff: corpus mismatch — with={with_rep.get('corpus')} "
-            f"without={without_rep.get('corpus')}\n"
-        )
-        return 1
-    corpus = with_rep.get("corpus") or "unknown"
-    with_results = with_rep.get("results", {})
-    without_results = without_rep.get("results", {})
-    if corpus == "ab-tracka":
-        delta = compute_track_a_diff(with_results, without_results)
-    elif corpus == "ab-trackb":
-        delta = compute_track_b_diff(with_results, without_results)
-    else:
-        delta = {
-            "note": f"no diff strategy registered for corpus {corpus!r}",
-            "with_results": with_results,
-            "without_results": without_results,
-        }
-    stamp = utc_stamp()
-    diff = {
-        "schema": "ab-bench-diff/0.1",
-        "stamp": stamp,
-        "corpus": corpus,
-        "with_report": str(args.with_report.resolve().relative_to(REPO_ROOT)),
-        "without_report": str(args.without_report.resolve().relative_to(REPO_ROOT)),
-        "delta": delta,
-    }
-    args.out_dir.mkdir(parents=True, exist_ok=True)
-    json_path = args.out_dir / f"{stamp}-{corpus}-diff.json"
-    md_path = json_path.with_suffix(".md")
-    json_path.write_text(json.dumps(diff, indent=2) + "\n")
-    md_path.write_text(render_markdown(diff))
-    sys.stdout.write(f"bench_ab_diff: wrote {json_path.relative_to(REPO_ROOT)}\n")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())