@event4u/agent-config 5.7.0 → 5.9.0

package/scripts/prediction-pool/score_ev.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""Exact-score EV optimiser for prediction-pool-optimizer.
+
+Honest replacement for eyeballing the favourite — given each side's expected
+goals (lambda) and the pool's scoring rule, this builds the full Poisson
+score grid and computes the expected points of EVERY candidate tip, then
+prints the EV-maximizing scoreline. It exists to kill two recurring failure
+modes:
+
+  1. Hallucinated high scorelines (4:2, 1:4, 3:2 ...). Under any partial-points
+     rule these are almost never EV-max for a moderate favourite — the points
+     live in the tendency and goal-difference tiers, not the exact high score.
+  2. Under-tipped draws. A correctly-tipped draw banks the goal-difference
+     tier on every draw scoreline, so a 1:1 can beat a 1:0 in a close game.
+     The grid surfaces this; intuition does not.
+
+The scoring model (configurable points per tier):
+
+    exact result  → --exact     (default 4)
+    goal diff      → --diff      (default 3)   # same difference, not exact; draw-on-draw lands here
+    tendency       → --tendency  (default 2)   # same W/D/L sign only
+    else           → 0
+
+For kicktipp's common "2 / 3 / 5" config run with --tendency 2 --diff 3 --exact 5.
+
+It is an APPROXIMATION only in its goal model: a Poisson per side with the
+provided lambdas, sides independent. That is the standard football scoreline
+model and is robust to small lambda changes — but the lambdas themselves must
+come from de-vigged consensus odds (see reference/odds-and-bonus.md), not a
+guess. Feed it real numbers and the EV-max is exact for that model.
+
+Input — either two lambdas on the CLI:
+
+  python3 scripts/prediction-pool/score_ev.py --lh 2.0 --la 0.7
+  python3 scripts/prediction-pool/score_ev.py --lh 0.6 --la 2.1 --tendency 2 --diff 3 --exact 5
+
+or a JSON file of named matches (batch):
+
+  python3 scripts/prediction-pool/score_ev.py matches.json --tendency 2 --diff 3 --exact 5
+
+  matches.json:
+  [
+    {"match": "Senegal-Iraq",  "lh": 2.0, "la": 0.7},
+    {"match": "Qatar-Switzerland", "lh": 0.6, "la": 2.1}
+  ]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import sys
+from pathlib import Path
+
+MAX_GOALS = 12  # truncation of the Poisson grid; tail beyond this is negligible
+
+
+def _pois_pmf(k: int, rate: float) -> float:
+    if rate <= 0:
+        return 1.0 if k == 0 else 0.0
+    return math.exp(-rate) * rate ** k / math.factorial(k)
+
+
+def _sign(x: int) -> int:
+    return (x > 0) - (x < 0)
+
+
+def _score(th: int, ta: int, ah: int, aa: int,
+           pts_exact: float, pts_diff: float, pts_tend: float) -> float:
+    """Points a tip (th:ta) earns against an actual result (ah:aa)."""
+    if th == ah and ta == aa:
+        return pts_exact
+    if (th - ta) == (ah - aa):
+        return pts_diff
+    if _sign(th - ta) == _sign(ah - aa):
+        return pts_tend
+    return 0.0
+
+
+def grid(lh: float, la: float, max_goals: int = MAX_GOALS):
+    """Joint probability of every actual scoreline up to max_goals."""
+    ph = [_pois_pmf(k, lh) for k in range(max_goals + 1)]
+    pa = [_pois_pmf(k, la) for k in range(max_goals + 1)]
+    return [[ph[h] * pa[a] for a in range(max_goals + 1)] for h in range(max_goals + 1)]
+
+
+def ev_table(lh: float, la: float, pts_exact: float, pts_diff: float, pts_tend: float,
+             max_tip: int = 6, max_goals: int = MAX_GOALS):
+    """EV (expected points) of every candidate tip up to max_tip goals/side."""
+    g = grid(lh, la, max_goals)
+    rows = []
+    for th in range(max_tip + 1):
+        for ta in range(max_tip + 1):
+            ev = 0.0
+            for ah in range(max_goals + 1):
+                for aa in range(max_goals + 1):
+                    p = g[ah][aa]
+                    if p <= 0:
+                        continue
+                    s = _score(th, ta, ah, aa, pts_exact, pts_diff, pts_tend)
+                    if s:
+                        ev += p * s
+            rows.append((th, ta, ev))
+    rows.sort(key=lambda r: r[2], reverse=True)
+    return rows, g
+
+
+def _modal(g) -> tuple[int, int, float]:
+    best = (0, 0, 0.0)
+    for h in range(len(g)):
+        for a in range(len(g[h])):
+            if g[h][a] > best[2]:
+                best = (h, a, g[h][a])
+    return best
+
+
+def _p_draw(g) -> float:
+    return sum(g[i][i] for i in range(len(g)))
+
+
+def analyse(lh: float, la: float, pts_exact: float, pts_diff: float, pts_tend: float,
+            max_tip: int = 6, top: int = 6):
+    rows, g = ev_table(lh, la, pts_exact, pts_diff, pts_tend, max_tip)
+    mh, ma, mp = _modal(g)
+    return {
+        "lambda": [lh, la],
+        "rule": {"exact": pts_exact, "diff": pts_diff, "tendency": pts_tend},
+        "ev_max": {"tip": f"{rows[0][0]}:{rows[0][1]}", "ev": round(rows[0][2], 3)},
+        "modal_result": {"score": f"{mh}:{ma}", "prob": round(mp, 3)},
+        "p_draw": round(_p_draw(g), 3),
+        "ranked": [{"tip": f"{h}:{a}", "ev": round(ev, 3)} for h, a, ev in rows[:top]],
+    }
+
+
+def _print_one(name: str | None, res: dict) -> None:
+    if name:
+        print(f"\n## {name}")
+    lh, la = res["lambda"]
+    r = res["rule"]
+    print(f"lambda {lh}:{la}  rule exact={r['exact']} diff={r['diff']} tendency={r['tendency']}")
+    print(f"EV-max tip : {res['ev_max']['tip']}  (EV {res['ev_max']['ev']})")
+    print(f"modal score: {res['modal_result']['score']}  (P {res['modal_result']['prob']})  "
+          f"P(draw) {res['p_draw']}")
+    print("ranked by EV:")
+    for row in res["ranked"]:
+        flag = "  <- EV-max" if row["tip"] == res["ev_max"]["tip"] else ""
+        print(f"  {row['tip']:>5}  EV {row['ev']:.3f}{flag}")
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description="Exact-score EV optimiser (Poisson grid).")
+    ap.add_argument("matches", nargs="?", help="JSON file of matches [{match,lh,la}]")
+    ap.add_argument("--lh", type=float, help="home expected goals (lambda)")
+    ap.add_argument("--la", type=float, help="away expected goals (lambda)")
+    ap.add_argument("--exact", type=float, default=4.0, help="points for exact result (default 4)")
+    ap.add_argument("--diff", type=float, default=3.0, help="points for correct goal difference (default 3)")
+    ap.add_argument("--tendency", type=float, default=2.0, help="points for correct tendency (default 2)")
+    ap.add_argument("--max-tip", type=int, default=6, help="max goals/side to consider as a tip")
+    ap.add_argument("--top", type=int, default=6, help="rows to print per match")
+    ap.add_argument("--json", action="store_true", help="emit JSON instead of text")
+    args = ap.parse_args(argv)
+
+    jobs: list[tuple[str | None, float, float]] = []
+    if args.matches:
+        data = json.loads(Path(args.matches).read_text())
+        for m in data:
+            jobs.append((m.get("match"), float(m["lh"]), float(m["la"])))
+    elif args.lh is not None and args.la is not None:
+        jobs.append((None, args.lh, args.la))
+    else:
+        ap.error("provide either a matches JSON file or --lh and --la")
+
+    out = []
+    for name, lh, la in jobs:
+        res = analyse(lh, la, args.exact, args.diff, args.tendency, args.max_tip, args.top)
+        if name:
+            res["match"] = name
+        out.append(res)
+        if not args.json:
+            _print_one(name, res)
+
+    if args.json:
+        print(json.dumps(out, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/profile_staleness_hook.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Session-profile staleness notice — `session_start` hook.
+
+Phase 1 companion to the locked Phase-0.1 decision (option a, explicit
+`/profile deactivate`). The `runtime.active_packs` overlay survives an IDE
+restart, so this hook does **not** reset it — it only surfaces a one-line
+**staleness notice** when a new session starts with an overlay carried over
+from a previous session. Silently resetting on `session_start` is the
+registry-refresh Catch-22 the council ruled out (see
+`agents/settings/contexts/session-host-capability-audit.md`).
+
+Contract: never blocks. Reads the JSON envelope on stdin (ignored — the
+notice is derived from the overlay file), emits at most one stderr line,
+returns 0 on every path.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+# Make `scripts` importable when invoked as a bare script path.
+_REPO = Path(__file__).resolve().parent.parent
+if str(_REPO) not in sys.path:
+    sys.path.insert(0, str(_REPO))
+
+try:
+    from scripts.config import session_profiles
+except Exception:  # pragma: no cover - defensive; never block the loop
+    session_profiles = None  # type: ignore
+
+
+def _project_root() -> Path:
+    env = os.environ.get("CLAUDE_PROJECT_DIR") or os.environ.get("AGENT_CONFIG_PROJECT_DIR")
+    if env:
+        return Path(env)
+    return Path.cwd()
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description="Session-profile staleness notice (session_start).")
+    ap.add_argument("--root", default=None)
+    args, _ = ap.parse_known_args(argv)
+
+    # Drain stdin (the dispatcher passes a JSON envelope); we do not need it.
+    try:
+        if not sys.stdin.isatty():
+            sys.stdin.read()
+    except Exception:
+        pass
+
+    if session_profiles is None:
+        return 0
+
+    root = Path(args.root) if args.root else _project_root()
+    try:
+        notice = session_profiles.stale_notice(root)
+    except Exception:
+        return 0  # fail-open — never block the session
+
+    if notice:
+        print(f"[profile] {notice}", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/release.py

@@ -665,7 +665,7 @@ def execute(
     resume: bool = False,
 ) -> None:
     branch = f"release/{plan.target}"
-    total = 9
+    total = 10
 
     if dry_run:
         print("(dry-run) no git/gh mutations will be performed.")
@@ -842,6 +842,25 @@ def execute(
             "--notes", notes,
         )
 
+    # ─── 10. delete the merged release branch (local + remote) ───────────────
+    # Branch hygiene: a merged-but-undeleted release/X.Y.Z is what made
+    # `--resume` mis-detect an old version. Delete it now so it can never
+    # accumulate. Idempotent — skips whatever is already gone. Never touches
+    # `main` or any tag.
+    if dry_run:
+        _step(10, total, f"Would delete merged branch {branch} (local + remote)")
+    else:
+        deleted = []
+        if _branch_exists_local(branch) and \
+                git("rev-parse", "--abbrev-ref", "HEAD", capture=True) != branch:
+            run("git", "branch", "-D", branch, check=False)
+            deleted.append("local")
+        if _branch_exists_remote(branch):
+            run("git", "push", REMOTE, "--delete", branch, check=False)
+            deleted.append("remote")
+        where = " + ".join(deleted) if deleted else "already gone"
+        _step(10, total, f"Delete merged branch {branch} ({where})")
+
     print()
     print(f"✅  Released {plan.target}")
     print(f"   https://github.com/{REPO_SLUG}/releases/tag/{plan.target}")
@@ -904,43 +923,47 @@ _RELEASE_BRANCH_RE = re.compile(r"^release/(\d+\.\d+\.\d+)$")
 
 
 def _detect_in_flight_target() -> str | None:
-    """Find the in-flight release target from existing release branches.
-
-    Resume mode needs to know which `release/X.Y.Z` is being recovered,
-    not what the next bump would be. The release branch name is the
-    canonical anchor: it was committed by step 1 of an earlier run and
-    is the only state guaranteed to survive a partial pipeline.
-
-    Local branches win over remote, current-branch wins over both — if
-    you ran `git checkout release/1.15.0`, that's the target. Returns
-    None if no release branch exists; caller falls back to the regular
-    bump-inference path.
+    """Find the in-flight release target — the SOURCE OF TRUTH is package.json.
+
+    An "in-flight" release is one whose version was already bumped into
+    ``main``'s ``package.json`` (and possibly merged) but whose tag has not
+    yet been pushed — i.e. the publish step never completed. The canonical
+    anchor is therefore ``package.json`` version `V` **with no matching tag
+    `V`**, NOT the set of ``release/X.Y.Z`` branches.
+
+    Why not the branch set: merged release branches are frequently left
+    undeleted on the remote, so "highest existing release/* branch" can
+    resolve to an OLD, already-published version (e.g. picking 5.4.0 while
+    5.8.0 is the real in-flight target) and tag a downgrade. The package.json
+    version cannot lie that way — it is the version main currently claims to
+    be, and an untagged claim is exactly an incomplete release.
+
+    Resolution order:
+      1. If HEAD is on a ``release/X.Y.Z`` branch, that explicit checkout wins.
+      2. Else: read ``package.json`` version `V`. If tag `V` does not exist
+         (local or remote), `V` is the in-flight target. If it is already
+         tagged, the release is complete → return None (regular bump path).
+
+    Stale ``release/*`` branches are never used for version detection.
     """
     head = git("rev-parse", "--abbrev-ref", "HEAD", capture=True)
     m = _RELEASE_BRANCH_RE.match(head)
     if m:
         return m.group(1)
 
-    local_raw = git("for-each-ref", "--format=%(refname:short)", "refs/heads/release/", capture=True)
-    candidates = [
-        m.group(1)
-        for line in local_raw.splitlines()
-        if (m := _RELEASE_BRANCH_RE.match(line.strip()))
-    ]
-    remote_raw = git(
-        "for-each-ref", "--format=%(refname:short)",
-        f"refs/remotes/{REMOTE}/release/", capture=True,
-    )
-    for line in remote_raw.splitlines():
-        bare = line.strip().removeprefix(f"{REMOTE}/")
-        if (m := _RELEASE_BRANCH_RE.match(bare)):
-            candidates.append(m.group(1))
+    try:
+        version = json.loads(PACKAGE_JSON.read_text(encoding="utf-8"))["version"]
+    except (OSError, KeyError, json.JSONDecodeError):
+        return None
+    try:
+        parse_version(version)
+    except Exception:
+        return None
 
-    if not candidates:
+    # An already-tagged version is a completed release, not in-flight.
+    if _tag_exists_local(version) or _tag_exists_remote(version):
         return None
-    # Sort semver-aware so 1.10.0 > 1.9.0 (lexicographic would lose).
-    candidates.sort(key=parse_version)
-    return candidates[-1]
+    return version
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -961,7 +984,7 @@ def main(argv: list[str] | None = None) -> int:
         target = args.explicit
     elif in_flight:
         target = in_flight
-        print(f"(resume) detected in-flight release branch release/{in_flight}")
+        print(f"(resume) in-flight target {in_flight} (package.json version with no tag yet)")
     else:
         target = bump_version(current, bump)
     parse_version(target)

package/scripts/roadmap_progress_hook.py

@@ -55,6 +55,21 @@ ROADMAP_PREFIX = "agents/roadmaps/"
 ROADMAP_EXCLUDED_PARTS = frozenset({"archive", "skipped"})
 DASHBOARD_PATH = "agents/roadmaps-progress.md"
 
+REGEN_NAME = "update_roadmap_progress.py"
+# Distributed-content script subtrees that may ship the regenerator,
+# in priority order. Project-scoped installs land it under .augment/ or
+# .agent-src/; the package itself carries the same projection.
+DIST_SCRIPT_SUBDIRS = (
+    Path(".augment") / "scripts",
+    Path(".agent-src") / "scripts",
+    Path(".agent-src.uncondensed") / "scripts",
+)
+# Set by the dispatcher (scripts/hooks/dispatch_hook.py) to its own
+# resolved package root, so a globally-installed binary (ADR-020
+# global-only) can locate the shipped regenerator even when the consumer
+# repo carries no project-local distributed content.
+PACKAGE_ROOT_ENV_VAR = "AGENT_CONFIG_PACKAGE_ROOT"
+
 
 def _candidate_paths(payload: dict) -> list[str]:
     """Pull every plausible file path out of a PostToolUse payload."""
@@ -115,15 +130,50 @@ def _is_roadmap_touch(path: str) -> bool:
     return True
 
 
+def _package_roots() -> list[Path]:
+    """Package roots to search for the shipped regenerator, in priority
+    order, when the consumer carries no project-local copy.
+
+    A global-only consumer (ADR-020) never has `.augment/` / `.agent-src/`
+    in its repo — those trees are *distributed content*, which global-only
+    installs keep in the globally-installed package, not the project. The
+    regenerator therefore lives next to the running code, not next to the
+    edited roadmap.
+
+    1. ``AGENT_CONFIG_PACKAGE_ROOT`` — the dispatcher passes its own
+       resolved package root (``dispatch_hook.REPO_ROOT``). This is the
+       same root the dispatcher already trusts to locate this concern, so
+       it survives editable installs, plugin-cache moves, and symlinks
+       that a naive ``__file__`` walk would mis-resolve.
+    2. This hook's own location (``<pkg>/scripts/roadmap_progress_hook.py``
+       → ``<pkg>``) — last-resort fallback for standalone invocation
+       outside the dispatcher.
+    """
+    roots: list[Path] = []
+    env_root = os.environ.get(PACKAGE_ROOT_ENV_VAR, "").strip()
+    if env_root:
+        roots.append(Path(env_root).expanduser())
+    roots.append(Path(__file__).resolve().parent.parent)
+    return roots
+
+
 def _resolve_regenerator(consumer_root: Path) -> Path | None:
-    """Find the regenerator script — package-shipped or installed copy."""
-    for candidate in (
-        consumer_root / ".augment" / "scripts" / "update_roadmap_progress.py",
-        consumer_root / ".agent-src" / "scripts" / "update_roadmap_progress.py",
-        consumer_root / ".agent-src.uncondensed" / "scripts" / "update_roadmap_progress.py",
-    ):
+    """Find the regenerator script.
+
+    Project-local copy first (project-scoped installs), then the package
+    the hook itself ships in (global-only consumers, per ADR-020 — the
+    repo has no project-local distributed content). Returns ``None`` only
+    when no copy exists in either place.
+    """
+    for subdir in DIST_SCRIPT_SUBDIRS:
+        candidate = consumer_root / subdir / REGEN_NAME
         if candidate.is_file():
             return candidate
+    for root in _package_roots():
+        for subdir in DIST_SCRIPT_SUBDIRS:
+            candidate = root / subdir / REGEN_NAME
+            if candidate.is_file():
+                return candidate
     return None
 
 

package/scripts/smoke_quickstart.py

@@ -61,9 +61,10 @@ def _check_installer_runs(tmpdir: Path) -> tuple[int, Path | None]:
             _fail(f"installer exited {result.returncode}\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}"),
             None,
         )
-    settings = tmpdir / ".agent-settings.yml"
+    # ADR-038: installer writes the canonical settings file under agents/settings/.
+    settings = tmpdir / "agents" / "settings" / ".agent-settings.yml"
     if not settings.exists():
-        return _fail(".agent-settings.yml not written by installer"), None
+        return _fail("agents/settings/.agent-settings.yml not written by installer"), None
     return 0, settings
 
 

package/scripts/sync_agent_settings.py

@@ -85,8 +85,10 @@ def render_diff(old_text: str, new_text: str, path: str) -> str:
 
 def main(argv: list[str] | None = None) -> int:
     ap = argparse.ArgumentParser(description=__doc__)
-    ap.add_argument("--path", default=DEFAULT_SETTINGS,
-                    help=f"target settings file (default: ./{DEFAULT_SETTINGS})")
+    ap.add_argument("--path", default=None,
+                    help="target settings file (default: canonical "
+                         "agents/settings/.agent-settings.yml, falling back to "
+                         "a legacy repo-root .agent-settings.yml — ADR-038)")
     ap.add_argument("--template", default=str(DEFAULT_TEMPLATE),
                     help="path to the settings template")
     ap.add_argument("--profile", default=None,
@@ -102,7 +104,10 @@ def main(argv: list[str] | None = None) -> int:
                     help="suppress summary on success")
     args = ap.parse_args(argv)
 
-    target = Path(args.path)
+    target = (
+        Path(args.path) if args.path is not None
+        else _install._resolve_settings_read(Path.cwd())
+    )
     template_path = Path(args.template)
     profile_dir = Path(args.profile_dir)
 

package/scripts/validate_agent_settings.py

@@ -29,6 +29,10 @@ from __future__ import annotations
 import json
 import sys
 from pathlib import Path
+try:  # invocation-agnostic import (repo-root-on-path vs scripts-on-path)
+    from scripts._lib.agent_settings import project_settings_path
+except ModuleNotFoundError:  # pragma: no cover
+    from _lib.agent_settings import project_settings_path
 
 try:
     import yaml
@@ -45,7 +49,7 @@ except ImportError:  # pragma: no cover — bootstrap guard
 REPO_ROOT = Path(__file__).resolve().parent.parent
 SCHEMA_PATH = REPO_ROOT / "scripts" / "schemas" / "agent-settings.schema.json"
 TEMPLATE_PATH = REPO_ROOT / "config" / "agent-settings.template.yml"
-LOCAL_PATHS = [REPO_ROOT / ".agent-settings.yml"]
+LOCAL_PATHS = [project_settings_path(REPO_ROOT)]
 
 # Installer-default substitutions, mirroring scripts/install.py so the
 # template validates as it would after a fresh `balanced` install.

package/scripts/validate_decision_engine.py

@@ -19,6 +19,10 @@ from __future__ import annotations
 
 import sys
 from pathlib import Path
+try:  # invocation-agnostic import (repo-root-on-path vs scripts-on-path)
+    from scripts._lib.agent_settings import project_settings_path
+except ModuleNotFoundError:  # pragma: no cover
+    from _lib.agent_settings import project_settings_path
 
 try:
     import yaml
@@ -48,7 +52,7 @@ from work_engine.scoring.decision_engine import (  # noqa: E402
 # canonical — its absence is itself a regression).
 TEMPLATE_PATH = REPO_ROOT / "config" / "agent-settings.template.yml"
 # Project-level overrides developers may have on disk locally.
-LOCAL_PATHS = [REPO_ROOT / ".agent-settings.yml"]
+LOCAL_PATHS = [project_settings_path(REPO_ROOT)]
 
 
 def _load_yaml(path: Path) -> dict | None:

package/scripts/measure_roadmap_trajectory.py

@@ -1,112 +0,0 @@
-#!/usr/bin/env python3
-"""Phase 5.1 — Roadmap commitment-history measurement.
-
-Walks `agents/roadmaps/archive/` and computes per-roadmap checkbox
-completion ratio at archival time. Output: one-line trajectory metric
-per roadmap, plus an aggregate `agents/runtime/reports/roadmap-trajectory.json`.
-
-Checkbox grammar (mirrors `scripts/roadmap_progress_check.py`):
-- `[ ]` — open
-- `[x]` — done
-- `[~]` — in-progress
-- `[-]` — cancelled / dropped (counts neither toward open nor closed)
-
-Trajectory metric = closed / (open + closed + in-progress); cancelled
-items are excluded from the denominator so a cleanly archived "we
-decided not to do this" doesn't dilute the score.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import sys
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parent.parent
-ARCHIVE = ROOT / "agents" / "roadmaps" / "archive"
-REPORT = ROOT / "agents" / "reports" / "roadmap-trajectory.json"
-
-CHECKBOX = re.compile(r"^\s*[-*]\s*\[(?P<state>[ x~\-])\]", re.MULTILINE)
-
-
-def measure(path: Path) -> dict:
-    text = path.read_text(encoding="utf-8", errors="replace")
-    counts = {"open": 0, "done": 0, "wip": 0, "cancelled": 0}
-    for m in CHECKBOX.finditer(text):
-        state = m.group("state")
-        if state == " ":
-            counts["open"] += 1
-        elif state == "x":
-            counts["done"] += 1
-        elif state == "~":
-            counts["wip"] += 1
-        elif state == "-":
-            counts["cancelled"] += 1
-    denom = counts["open"] + counts["done"] + counts["wip"]
-    ratio = (counts["done"] / denom) if denom else None
-    return {
-        "file": str(path.relative_to(ROOT)),
-        "counts": counts,
-        "completion_ratio": ratio,
-        "total_actionable": denom,
-    }
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--archive", default=str(ARCHIVE))
-    ap.add_argument("--report", default=str(REPORT))
-    ap.add_argument("--print-table", action="store_true")
-    args = ap.parse_args()
-
-    archive = Path(args.archive)
-    if not archive.exists():
-        print(f"❌  archive not found: {archive}", file=sys.stderr)
-        return 2
-
-    rows = [measure(p) for p in sorted(archive.glob("*.md"))]
-
-    # Aggregate: mean, median, count above 80%, count zero-completion
-    ratios = [r["completion_ratio"] for r in rows if r["completion_ratio"] is not None]
-    aggregate = {
-        "roadmaps": len(rows),
-        "scored": len(ratios),
-        "mean": (sum(ratios) / len(ratios)) if ratios else None,
-        "median": sorted(ratios)[len(ratios) // 2] if ratios else None,
-        "above_80pct": sum(1 for r in ratios if r >= 0.80),
-        "below_50pct": sum(1 for r in ratios if r < 0.50),
-        "zero_completion": sum(1 for r in ratios if r == 0.0),
-    }
-
-    out = Path(args.report)
-    out.parent.mkdir(parents=True, exist_ok=True)
-    out.write_text(
-        json.dumps({"aggregate": aggregate, "rows": rows}, indent=2) + "\n",
-        encoding="utf-8",
-    )
-
-    print(f"✅  Wrote {out.relative_to(ROOT)}")
-    print(f"   roadmaps={aggregate['roadmaps']} scored={aggregate['scored']}")
-    if aggregate["mean"] is not None:
-        print(
-            f"   mean={aggregate['mean']:.1%}  median={aggregate['median']:.1%}  "
-            f"above_80%={aggregate['above_80pct']}  below_50%={aggregate['below_50pct']}  "
-            f"zero={aggregate['zero_completion']}"
-        )
-    if args.print_table:
-        print()
-        print(f"   {'file':70s} {'ratio':>7s} {'done':>5s} {'open':>5s} {'wip':>5s} {'cx':>5s}")
-        for r in sorted(rows, key=lambda x: (x["completion_ratio"] is None, -(x["completion_ratio"] or 0))):
-            ratio = "—" if r["completion_ratio"] is None else f"{r['completion_ratio']:.1%}"
-            print(
-                f"   {Path(r['file']).name:70s} {ratio:>7s} "
-                f"{r['counts']['done']:>5d} {r['counts']['open']:>5d} "
-                f"{r['counts']['wip']:>5d} {r['counts']['cancelled']:>5d}"
-            )
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())