@event4u/agent-config 6.1.0 → 7.0.0

package/src/scripts/bench_ab_v2_stats.py

@@ -1,347 +0,0 @@
-#!/usr/bin/env python3
-"""bench:ab v2 — paired statistics (Phase 3).
-
-Reads a v2 paired report (bench_ab_v2_run.py output) and computes, for each
-arm comparison, paired significance + effect size on:
-
-- capability axis (binary)  -> McNemar exact test + Cohen's h
-- discipline axis ([0,1])    -> Wilcoxon signed-rank + rank-biserial
-- status buckets             -> error/undisciplined-rate per arm
-
-Pairing: each (task, seed) is one pair, seen under every arm. Pooled across all
-task×seed pairs. Dependency-free (stdlib math only) so the benchmark stays
-portable. Errored runs are EXCLUDED from a pair (per-axis) so a quota trip is
-never read as a content/discipline fail.
-
-Comparisons reported:
-  package   vs vanilla   -> the package lift (adoption question)
-  package-rdp vs package -> the RDP reasoning lift
-  package   vs placebo   -> attribution: content vs mere prompt-length priming
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import math
-import sys
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent.parent.parent
-REPORTS_DIR = REPO_ROOT / "internal" / "bench" / "reports" / "ab-v2"
-
-COMPARISONS = [
-    ("package", "vanilla", "package lift"),
-    ("package-rdp", "package", "RDP lift"),
-    ("package", "placebo", "attribution (content vs length)"),
-]
-
-
-def _phi(z: float) -> float:
-    """Standard-normal CDF via erf."""
-    return 0.5 * (1.0 + math.erf(z / math.sqrt(2.0)))
-
-
-def _comb(n: int, k: int) -> int:
-    return math.comb(n, k)
-
-
-def mcnemar_exact(b: int, c: int) -> float:
-    """Two-sided exact McNemar p-value (binomial on discordant pairs)."""
-    n = b + c
-    if n == 0:
-        return 1.0
-    k = min(b, c)
-    tail = sum(_comb(n, i) for i in range(0, k + 1)) * (0.5 ** n)
-    return min(1.0, 2.0 * tail)
-
-
-def cohens_h(p1: float, p2: float) -> float:
-    return 2 * math.asin(math.sqrt(max(0, min(1, p1)))) - \
-           2 * math.asin(math.sqrt(max(0, min(1, p2))))
-
-
-def wilcoxon(diffs: list[float]) -> dict:
-    """Wilcoxon signed-rank on paired differences (treatment - baseline).
-
-    Returns W+, W-, normal-approx two-sided p (continuity-corrected), and
-    rank-biserial effect size. Zeros are dropped."""
-    nz = [d for d in diffs if abs(d) > 1e-9]
-    n = len(nz)
-    if n == 0:
-        return {"n": 0, "W_plus": 0, "W_minus": 0, "p": 1.0, "rank_biserial": 0.0}
-    order = sorted(range(n), key=lambda i: abs(nz[i]))
-    ranks = [0.0] * n
-    i = 0
-    while i < n:
-        j = i
-        while j + 1 < n and abs(nz[order[j + 1]]) == abs(nz[order[i]]):
-            j += 1
-        avg = (i + 1 + j + 1) / 2.0  # average rank for ties (1-based)
-        for k in range(i, j + 1):
-            ranks[order[k]] = avg
-        i = j + 1
-    w_plus = sum(ranks[i] for i in range(n) if nz[i] > 0)
-    w_minus = sum(ranks[i] for i in range(n) if nz[i] < 0)
-    total = w_plus + w_minus
-    rb = (w_plus - w_minus) / total if total else 0.0
-    # Normal approximation (ok-ish for n>=10; for small n it's conservative —
-    # we surface n so the reader can weight it).
-    mean = n * (n + 1) / 4.0
-    sd = math.sqrt(n * (n + 1) * (2 * n + 1) / 24.0)
-    w = min(w_plus, w_minus)
-    if sd == 0:
-        p = 1.0
-    else:
-        z = (w - mean + 0.5) / sd
-        p = min(1.0, 2.0 * _phi(z))
-    return {"n": n, "W_plus": round(w_plus, 1), "W_minus": round(w_minus, 1),
-            "p": round(p, 4), "rank_biserial": round(rb, 4)}
-
-
-def _pairs(records: list[dict], arm_t: str, arm_b: str):
-    """Yield (task, seed, run_t, run_b) for each paired (task,seed)."""
-    for rec in records:
-        arms = rec.get("arms", {})
-        runs_t = arms.get(arm_t) or []
-        runs_b = arms.get(arm_b) or []
-        by_seed_b = {r.get("seed"): r for r in runs_b}
-        for r_t in runs_t:
-            r_b = by_seed_b.get(r_t.get("seed"))
-            if r_b is not None:
-                yield rec["id"], r_t.get("seed"), r_t, r_b
-
-
-def compare(records: list[dict], arm_t: str, arm_b: str) -> dict:
-    # Capability (binary, McNemar) — exclude pairs where either side errored.
-    b = c = both1 = both0 = 0
-    cap_t = cap_b = capn = 0
-    # Discipline (continuous, Wilcoxon)
-    diffs: list[float] = []
-    dis_t_sum = dis_b_sum = disn = 0.0
-    for _id, _seed, rt, rb in _pairs(records, arm_t, arm_b):
-        if not rt.get("errored") and not rb.get("errored"):
-            t = bool(rt.get("capability_pass"))
-            bb = bool(rb.get("capability_pass"))
-            capn += 1
-            cap_t += int(t)
-            cap_b += int(bb)
-            if t and not bb:
-                b += 1
-            elif bb and not t:
-                c += 1
-            elif t and bb:
-                both1 += 1
-            else:
-                both0 += 1
-            dt = float(rt.get("discipline_score", 0))
-            db = float(rb.get("discipline_score", 0))
-            diffs.append(dt - db)
-            dis_t_sum += dt
-            dis_b_sum += db
-            disn += 1
-    p1 = cap_t / capn if capn else 0
-    p2 = cap_b / capn if capn else 0
-    wil = wilcoxon(diffs)
-    return {
-        "arm_treatment": arm_t,
-        "arm_baseline": arm_b,
-        "n_pairs": capn,
-        "capability": {
-            "rate_treatment": round(p1, 4),
-            "rate_baseline": round(p2, 4),
-            "discordant_b_only_treatment": b,
-            "discordant_c_only_baseline": c,
-            "mcnemar_p": round(mcnemar_exact(b, c), 4),
-            "cohens_h": round(cohens_h(p1, p2), 4),
-        },
-        "discipline": {
-            "mean_treatment": round(dis_t_sum / disn, 4) if disn else 0,
-            "mean_baseline": round(dis_b_sum / disn, 4) if disn else 0,
-            "mean_delta": round((dis_t_sum - dis_b_sum) / disn, 4) if disn else 0,
-            "wilcoxon_p": wil["p"],
-            "rank_biserial": wil["rank_biserial"],
-            "n_nonzero": wil["n"],
-        },
-    }
-
-
-def bucket_rates(records: list[dict], arms: list[str]) -> dict:
-    out: dict[str, dict] = {}
-    for arm in arms:
-        buckets: dict[str, int] = {}
-        total = 0
-        for rec in records:
-            for r in rec.get("arms", {}).get(arm, []) or []:
-                total += 1
-                bk = r.get("metrics", {}).get("status_bucket", "completed")
-                buckets[bk] = buckets.get(bk, 0) + 1
-        out[arm] = {"total": total, "buckets": buckets,
-                    "error_rate": round(1 - buckets.get("completed", 0) / total, 4)
-                    if total else 0}
-    return out
-
-
-def analyse(payload: dict) -> dict:
-    records = payload.get("records", [])
-    arms = payload.get("arms", [])
-    comps = [compare(records, t, b) | {"label": lbl}
-             for (t, b, lbl) in COMPARISONS if t in arms and b in arms]
-    return {
-        "stamp": payload.get("stamp"),
-        "model": payload.get("model"),
-        "seeds": payload.get("seeds"),
-        "n_tasks": len(records),
-        "comparisons": comps,
-        "status_buckets": bucket_rates(records, arms),
-    }
-
-
-def gate_verdict(analysis: dict) -> dict:
-    """L4 gate: PASS if ANY axis shows significant paired lift for package vs
-    vanilla (McNemar p<0.05 OR Wilcoxon p<0.05 OR a status-bucket reduction)."""
-    pkg = next((c for c in analysis["comparisons"]
-                if c["arm_treatment"] == "package" and c["arm_baseline"] == "vanilla"), None)
-    if not pkg:
-        return {"verdict": "INCONCLUSIVE", "reason": "no package-vs-vanilla comparison"}
-    cap_sig = pkg["capability"]["mcnemar_p"] < 0.05 and pkg["capability"]["rate_treatment"] > pkg["capability"]["rate_baseline"]
-    dis_sig = pkg["discipline"]["wilcoxon_p"] < 0.05 and pkg["discipline"]["mean_delta"] > 0
-    sb = analysis["status_buckets"]
-    bucket_better = (sb.get("package", {}).get("error_rate", 1) <
-                     sb.get("vanilla", {}).get("error_rate", 1))
-    passed = cap_sig or dis_sig
-    return {
-        "verdict": "PASS" if passed else "FALSIFIED-OR-INCONCLUSIVE",
-        "capability_significant": cap_sig,
-        "discipline_significant": dis_sig,
-        "status_bucket_better": bucket_better,
-        "note": "PASS = significant paired discipline/capability lift; "
-                "FALSIFIED only if also trivial across seeds (inspect n_pairs).",
-    }
-
-
-def to_markdown(analysis: dict, payload: dict) -> str:
-    a = analysis
-    g = a["gate"]
-    L = []
-    L.append("# Discipline-Axis Wrapper-Lift Benchmark (v2)")
-    L.append("")
-    L.append("> Generated by `scripts/bench_ab_v2_stats.py --markdown`. Source: "
-             "`internal/bench/reports/ab-v2/`. Re-render with `task bench:ab:v2:diff`.")
-    L.append("")
-    L.append("## Honesty labels (read first)")
-    L.append("")
-    L.append(f"> 1. **Wrapper-lift on a fixed host (`{a['model']}`), NOT model-vs-model.** "
-             "Measures what the agent-config package does to ONE host model on a neutral "
-             "fixture — not a capability ranking.")
-    L.append("> 2. **Discipline axis, not capability.** The headline is the *discipline* "
-             "delta (did it stay minimal / verify / ask / not destroy / update downstream), "
-             "not whether the goal was achievable.")
-    L.append(f"> 3. **PILOT — low statistical power (N={a['n_tasks']} tasks × "
-             f"{a['seeds']} seed(s)).** Directional only.")
-    L.append("> 4. **Paired design**, errored runs excluded; McNemar (capability) + "
-             "Wilcoxon signed-rank (discipline) + effect sizes.")
-    L.append("> 5. **Not comparable to SWE-bench / GAIA / Fable scores** — a different "
-             "question entirely.")
-    L.append("")
-    L.append(f"## Gate verdict: **{g['verdict']}**")
-    L.append("")
-    L.append(f"- capability lift significant: `{g['capability_significant']}`")
-    L.append(f"- discipline lift significant: `{g['discipline_significant']}`")
-    L.append(f"- status-bucket better (package vs vanilla): `{g.get('status_bucket_better')}`")
-    L.append("")
-    if g["verdict"] != "PASS":
-        L.append("> **Honest null at this scale.** On this micro-fixture pilot the bare "
-                 "host is *already* disciplined (vanilla discipline ≈ 1.0), so there is no "
-                 "headroom for the package to lift. Per the 2026-06-14 council this is NOT a "
-                 "full falsification — a complete gate requires a **complexity-stratified** "
-                 "run (micro / meso / multi-file fixtures) to see whether headroom appears at "
-                 "realistic scale. That run (meso/multi fixtures + ~17M-token budget) is the "
-                 "deferred follow-up. No lift is claimed.")
-        L.append("")
-    for c in a["comparisons"]:
-        cap, dis = c["capability"], c["discipline"]
-        L.append(f"## {c['label']} — `{c['arm_treatment']}` vs `{c['arm_baseline']}` "
-                 f"(n={c['n_pairs']} pairs)")
-        L.append("")
-        L.append("### Table 1 — capability axis (expected near-flat by design)")
-        L.append("")
-        L.append("| metric | baseline | treatment | test |")
-        L.append("|---|---|---|---|")
-        L.append(f"| pass-rate | {cap['rate_baseline']:.0%} | {cap['rate_treatment']:.0%} "
-                 f"| McNemar p={cap['mcnemar_p']}, h={cap['cohens_h']} |")
-        L.append("")
-        L.append("### Table 2 — discipline axis (the lift)")
-        L.append("")
-        L.append("| metric | baseline | treatment | Δ | test |")
-        L.append("|---|---|---|---|---|")
-        L.append(f"| mean discipline | {dis['mean_baseline']:.3f} | {dis['mean_treatment']:.3f} "
-                 f"| {dis['mean_delta']:+.3f} | Wilcoxon p={dis['wilcoxon_p']}, "
-                 f"rb={dis['rank_biserial']} (n≠0={dis['n_nonzero']}) |")
-        L.append("")
-    L.append("## Status buckets (trajectory)")
-    L.append("")
-    L.append("| arm | runs | error-rate | buckets |")
-    L.append("|---|---|---|---|")
-    for arm, info in a["status_buckets"].items():
-        bk = ", ".join(f"{k}:{v}" for k, v in info["buckets"].items())
-        L.append(f"| {arm} | {info['total']} | {info['error_rate']:.0%} | {bk} |")
-    L.append("")
-    L.append("## Methodology")
-    L.append("")
-    L.append(f"- Host model: `{a['model']}` (pinned across all arms — a validity "
-             "requirement, not a model comparison).")
-    L.append(f"- Per-run budget cap: ${payload.get('budget_usd_per_run')}; "
-             f"placebo injected ~{payload.get('placebo_chars')} chars of inert prose.")
-    L.append("- Arms: vanilla (plugin off) · package (real plugin) · package-rdp "
-             "(plugin + RDP rules) · placebo (plugin off + equal-length inert prose).")
-    L.append("- Corpus: `internal/bench/corpora/ab-trackb-v2.yaml` (5 trap archetypes). "
-             "Scoring: `bench_ab_scoring_v2.py` (deterministic, no LLM judge).")
-    L.append("- Roadmap: `agents/roadmaps/road-to-discipline-axis-benchmark.md`.")
-    L.append("")
-    return "\n".join(L)
-
-
-def main(argv: "list[str] | None" = None) -> int:
-    ap = argparse.ArgumentParser(description="bench:ab v2 paired statistics.")
-    ap.add_argument("report", nargs="?", help="paired report JSON (default: latest).")
-    ap.add_argument("--json", action="store_true", help="emit analysis JSON to stdout.")
-    ap.add_argument("--markdown", metavar="PATH", default="",
-                    help="write the honest v2 report markdown to PATH (e.g. docs/benchmark.md).")
-    args = ap.parse_args(argv if argv is not None else sys.argv[1:])
-
-    if args.report:
-        path = Path(args.report)
-    else:
-        cands = sorted(REPORTS_DIR.glob("*-ab-v2-paired.json"))
-        if not cands:
-            sys.stderr.write("no v2 paired report found\n")
-            return 1
-        path = cands[-1]
-    payload = json.loads(path.read_text())
-    analysis = analyse(payload)
-    analysis["gate"] = gate_verdict(analysis)
-    if args.markdown:
-        out = Path(args.markdown)
-        out.parent.mkdir(parents=True, exist_ok=True)
-        out.write_text(to_markdown(analysis, payload))
-        sys.stdout.write(f"wrote {out}\n")
-        return 0
-    if args.json:
-        sys.stdout.write(json.dumps(analysis, indent=2) + "\n")
-        return 0
-    a = analysis
-    print(f"bench:ab v2 — {a['n_tasks']} tasks × {a['seeds']} seeds · model={a['model']}")
-    for c in a["comparisons"]:
-        print(f"\n[{c['label']}] {c['arm_treatment']} vs {c['arm_baseline']} (n={c['n_pairs']} pairs)")
-        cap, dis = c["capability"], c["discipline"]
-        print(f"  capability: {cap['rate_baseline']:.0%} -> {cap['rate_treatment']:.0%} "
-              f"(McNemar p={cap['mcnemar_p']}, h={cap['cohens_h']})")
-        print(f"  discipline: {dis['mean_baseline']:.3f} -> {dis['mean_treatment']:.3f} "
-              f"(Δ={dis['mean_delta']:+.3f}, Wilcoxon p={dis['wilcoxon_p']}, rb={dis['rank_biserial']}, n≠0={dis['n_nonzero']})")
-    print(f"\nGATE: {a['gate']['verdict']} "
-          f"(cap_sig={a['gate']['capability_significant']}, dis_sig={a['gate']['discipline_significant']})")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/scripts/bench_baseline_ready.py

@@ -1,108 +0,0 @@
-#!/usr/bin/env python3
-"""Baseline-closure check — step-4 Phase 3 Step 4.
-
-Returns exit 0 iff the 60-day clock has elapsed since
-`internal/bench/baseline-start.txt` AND `internal/bench/reports/` contains at least
-`--min-reports` complete runs for the named corpus (default 30).
-
-Read by P2 enforcement roadmaps as their precondition (G1 gate in
-step-99). This is the single arbiter of "are we allowed to flip
-defaults yet" — no other timer is authoritative.
-
-Exit codes:
-    0 — baseline ready (clock elapsed AND report count met)
-    1 — argument / file error
-    2 — baseline not ready (clock OR reports insufficient)
-
-CLI:
-    python3 scripts/bench_baseline_ready.py
-    python3 scripts/bench_baseline_ready.py --corpus dev --min-days 60 --min-reports 30
-    python3 scripts/bench_baseline_ready.py --json
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from datetime import date, datetime, timezone
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent.parent.parent
-
-
-def _read_baseline_start(path: Path) -> date | None:
-    if not path.exists():
-        return None
-    for line in path.read_text(encoding="utf-8").splitlines():
-        stripped = line.strip()
-        if not stripped or stripped.startswith("#"):
-            continue
-        try:
-            return datetime.strptime(stripped, "%Y-%m-%d").date()
-        except ValueError:
-            continue
-    return None
-
-
-def main(argv: list[str] | None = None) -> int:
-    ap = argparse.ArgumentParser(
-        description=__doc__,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    ap.add_argument("--corpus", default="dev")
-    ap.add_argument("--reports-dir", default="internal/bench/reports")
-    ap.add_argument("--baseline-file", default="internal/bench/baseline-start.txt")
-    ap.add_argument("--min-days", type=int, default=60)
-    ap.add_argument("--min-reports", type=int, default=30)
-    ap.add_argument("--json", action="store_true")
-    args = ap.parse_args(argv)
-
-    baseline_path = REPO_ROOT / args.baseline_file
-    start = _read_baseline_start(baseline_path)
-    if start is None:
-        msg = f"baseline-start file missing or unreadable: {baseline_path}"
-        if args.json:
-            print(json.dumps({"status": "error", "reason": msg}))
-        else:
-            print(f"  ❌  {msg}", file=sys.stderr)
-        return 1
-
-    today = datetime.now(timezone.utc).date()
-    days_elapsed = (today - start).days
-    days_ok = days_elapsed >= args.min_days
-
-    reports_dir = REPO_ROOT / args.reports_dir
-    report_count = (
-        len(list(reports_dir.glob(f"*-{args.corpus}.json")))
-        if reports_dir.exists() else 0
-    )
-    reports_ok = report_count >= args.min_reports
-
-    ready = days_ok and reports_ok
-    payload = {
-        "status": "ready" if ready else "warmup",
-        "corpus": args.corpus,
-        "baseline_start": start.isoformat(),
-        "today": today.isoformat(),
-        "days_elapsed": days_elapsed,
-        "min_days": args.min_days,
-        "days_ok": days_ok,
-        "report_count": report_count,
-        "min_reports": args.min_reports,
-        "reports_ok": reports_ok,
-    }
-    if args.json:
-        print(json.dumps(payload, indent=2))
-    else:
-        emoji = "✅" if ready else "⏳"
-        verdict = "READY" if ready else "WARMUP"
-        print(
-            f"  {emoji}  bench-baseline · corpus={args.corpus} · "
-            f"{verdict} · days={days_elapsed}/{args.min_days} · "
-            f"reports={report_count}/{args.min_reports}"
-        )
-    return 0 if ready else 2
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/src/scripts/bench_condense_memory.py

@@ -1,168 +0,0 @@
-#!/usr/bin/env python3
-"""Offline bench for input-side memory condensation (Phase 2 / Step 11).
-
-Runs `condense_memory.py` over a fixed corpus of memory-target files, records
-pre/post char counts, approximates input-token savings (chars / 4 — the
-GPT-4 / Claude rule of thumb), and emits `internal/bench/reports/telegraph-v2.{json,md}`.
-
-Offline (no API calls). Cadence-aligned with `docs/benchmarks.md`. Citation
-in `internal/bench/reports/telegraph-v2.md` notes the chars→tokens approximation and
-points at upstream tiktoken / claude-tokenizer if a calibrated number is
-later needed.
-"""
-from __future__ import annotations
-
-import json
-import shutil
-import statistics
-import subprocess
-import sys
-import tempfile
-from datetime import datetime, timezone
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent.parent.parent
-CONDENSE_SCRIPT = REPO_ROOT / "src" / "scripts" / "condense_memory.py"
-REPORT_JSON = REPO_ROOT / "internal" / "bench" / "reports" / "telegraph-v2.json"
-REPORT_MD = REPO_ROOT / "internal" / "bench" / "reports" / "telegraph-v2.md"
-
-CORPUS: list[tuple[str, str]] = [
-    ("AGENTS.md", "thin-root-package"),
-    (".agent-src.uncondensed/templates/AGENTS.md", "thin-root-consumer-template"),
-    ("dist/agent-src/templates/AGENTS.md", "thin-root-consumer-generated"),
-    ("docs/contracts/ai-council-config.md", "prose-heavy-contract"),
-    ("docs/contracts/implement-ticket-flow.md", "prose-heavy-contract"),
-    ("docs/contracts/command-clusters.md", "prose-heavy-contract"),
-    ("docs/contracts/mental-models.md", "prose-heavy-contract"),
-    ("docs/contracts/kernel-membership.md", "prose-heavy-contract"),
-    ("docs/contracts/load-context-budget-model.md", "prose-heavy-contract"),
-    ("docs/contracts/mcp-cloud-scope.md", "prose-heavy-contract"),
-    ("docs/contracts/context-spine.md", "prose-heavy-contract"),
-    ("docs/contracts/rule-classification.md", "rule-classification"),
-]
-
-
-def chars_to_tokens(n: int) -> int:
-    """Approximate token count via chars / 4 (GPT-4/Claude English heuristic)."""
-    return round(n / 4)
-
-
-def bench_one(rel_path: str, category: str) -> dict:
-    src = REPO_ROOT / rel_path
-    if not src.is_file():
-        return {"path": rel_path, "category": category, "error": "not-found"}
-    with tempfile.TemporaryDirectory() as tmp:
-        target = Path(tmp) / src.name
-        shutil.copy(src, target)
-        before_chars = target.stat().st_size
-        result = subprocess.run(
-            [sys.executable, str(CONDENSE_SCRIPT), str(target)],
-            capture_output=True, text=True, cwd=REPO_ROOT,
-        )
-        if result.returncode != 0:
-            return {"path": rel_path, "category": category,
-                    "error": f"exit-{result.returncode}", "stderr": result.stderr[:200]}
-        after_chars = target.stat().st_size
-        before_tok = chars_to_tokens(before_chars)
-        after_tok = chars_to_tokens(after_chars)
-        return {
-            "path": rel_path,
-            "category": category,
-            "before_chars": before_chars,
-            "after_chars": after_chars,
-            "delta_chars": after_chars - before_chars,
-            "saving_pct_chars": (before_chars - after_chars) * 100 / before_chars,
-            "before_tokens_est": before_tok,
-            "after_tokens_est": after_tok,
-            "delta_tokens_est": after_tok - before_tok,
-            "saving_pct_tokens_est": (before_tok - after_tok) * 100 / before_tok if before_tok else 0.0,
-        }
-
-
-def aggregate(rows: list[dict]) -> dict:
-    rows_ok = [r for r in rows if "error" not in r]
-    savings = [r["saving_pct_chars"] for r in rows_ok]
-    by_cat: dict[str, list[float]] = {}
-    for r in rows_ok:
-        by_cat.setdefault(r["category"], []).append(r["saving_pct_chars"])
-    return {
-        "calls": len(rows),
-        "errors": len(rows) - len(rows_ok),
-        "median_saving_pct": statistics.median(savings) if savings else 0.0,
-        "p10_saving_pct": statistics.quantiles(savings, n=10)[0] if len(savings) >= 10 else min(savings, default=0.0),
-        "p90_saving_pct": statistics.quantiles(savings, n=10)[8] if len(savings) >= 10 else max(savings, default=0.0),
-        "stdev_saving_pct": statistics.pstdev(savings) if len(savings) > 1 else 0.0,
-        "total_chars_saved": sum(r["before_chars"] - r["after_chars"] for r in rows_ok),
-        "total_tokens_est_saved": sum(r["before_tokens_est"] - r["after_tokens_est"] for r in rows_ok),
-        "by_category_median_pct": {k: statistics.median(v) for k, v in by_cat.items()},
-    }
-
-
-def render_md(payload: dict) -> str:
-    agg = payload["aggregate"]
-    lines = [
-        "# telegraph-v2 — input-side memory condensation bench",
-        "",
-        f"**Generated:** {payload['generated_at']}",
-        f"**Schema:** `telegraph-v2` (input-side; offline; chars→tokens via /4 heuristic)",
-        f"**Script:** `scripts/bench_condense_memory.py`",
-        "",
-        "## Headline",
-        "",
-        f"- Median char saving: **{agg['median_saving_pct']:+.2f}%** (p10 {agg['p10_saving_pct']:+.2f}% · p90 {agg['p90_saving_pct']:+.2f}%)",
-        f"- Total chars saved across corpus: **{agg['total_chars_saved']:+,}**",
-        f"- Total tokens (estimate) saved across corpus: **{agg['total_tokens_est_saved']:+,}**",
-        f"- Files: {agg['calls']} · errors: {agg['errors']}",
-        "",
-        "## By category (median %)",
-        "",
-        "| Category | Median saving |",
-        "|---|---:|",
-    ]
-    for cat, med in sorted(agg["by_category_median_pct"].items()):
-        lines.append(f"| {cat} | {med:+.2f}% |")
-    lines += ["", "## Per file", "",
-              "| Path | Category | Before | After | Δ chars | Saving % |",
-              "|---|---|---:|---:|---:|---:|"]
-    for r in payload["rows"]:
-        if "error" in r:
-            lines.append(f"| `{r['path']}` | {r['category']} | — | — | — | {r['error']} |")
-        else:
-            lines.append(
-                f"| `{r['path']}` | {r['category']} | {r['before_chars']:,} | {r['after_chars']:,} | "
-                f"{r['delta_chars']:+,} | {r['saving_pct_chars']:+.2f}% |"
-            )
-    lines += ["", "## Methodology",
-              "",
-              "- Offline run: `condense_memory.py` writes `.original.md` backup + frontmatter (`original_sha256`, `condensed_at`). The frontmatter pair (≈ 120 chars) is the fixed condensation tax — files with little prose net negative.",
-              "- chars → tokens approximation: `tokens ≈ chars / 4` (GPT-4 / Claude English rule of thumb). Calibrated number requires `tiktoken` or `claude-tokenizer`; deferred until a consumer requests pinpoint numbers.",
-              "- The `telegraph-v1` output-side verdict (`vs_terse` median −9.27%) is orthogonal — input-side savings apply to the always-loaded memory budget, not the reply stream.",
-              "",
-              "## Interpretation",
-              "",
-              "- **Thin-Root files net negative.** `AGENTS.md` and `templates/AGENTS.md` already follow `agents-md-thin-root` (≥ 40 % pointer ratio). The condenseor's frontmatter pair adds more bytes than the sparse prose loses. **Do not condense Thin-Root files.**",
-              "- **Prose-heavy contract docs net 3–6 % saving.** Useful but modest. Pays off when the file is large and frequently loaded.",
-              "- **Rule of thumb:** target files with > 5 KB and visible paragraph prose; skip pointer-only files.",
-              ""]
-    return "\n".join(lines)
-
-
-def main() -> int:
-    rows = [bench_one(p, c) for p, c in CORPUS]
-    payload = {
-        "generated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
-        "schema": "telegraph-v2",
-        "rows": rows,
-        "aggregate": aggregate(rows),
-    }
-    REPORT_JSON.parent.mkdir(parents=True, exist_ok=True)
-    REPORT_JSON.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
-    REPORT_MD.write_text(render_md(payload), encoding="utf-8")
-    print(f"wrote: {REPORT_JSON}")
-    print(f"wrote: {REPORT_MD}")
-    print(f"median saving: {payload['aggregate']['median_saving_pct']:+.2f}%")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())