scripts/expert_calibrate.py

#!/usr/bin/env python3
"""Pilot subset, keep/drop decisions and the public 12 for the expert tier (SPEC 9.2).

  --pilot     pick the pilot subset from the candidate manifest: 3 tasks per family, chosen greedily to cover the
              family's ticket cards, then the drawn routine kinds, never two tasks with the same item multiset
  --jobs DIR  read Harbor job directories (any depth), join every trial with the manifest and apply the rules:

  family   in band when the better of the two pilot models solves 2-6 of its 9 trials of the family. Above 6/9 for
           both models: the family generator takes the next knob (SPEC 9.2 ladder, `alertforge expert --knobs`);
           seeds are not dropped one at a time
  task     6/6 solved: drop (or knob and re-pilot). 0/6: fairness audit first, never dropped on that alone (a 0/6
           with one requirement behind 4+ of the failures is listed for the audit). 1-5/6: candidate
  length   SPEC 9.2: share of non-solves whose failing requirements are all routine (> 50%: shorten the queue)
  shortcut E4/E5 solves that never replayed a packet (no `range2test`, no `promtool test rules`): > 50% of a
           family's solves means the evidence is not doing its job
  public   E1 x3, E2 x3, E3 x2, E4 x2, E5 x2 from the kept tasks, closest to a 0.5 pooled solve rate first,
           never two tasks with the same item multiset, and never two whose instruction and incident prose share
           more than 10% of their word 6-grams (SPEC 7.6 item 3; names, keys, numbers masked)

    scripts/expert_calibrate.py --manifest dist/v02-candidates/manifest.jsonl --pilot
    scripts/expert_calibrate.py --manifest dist/v02-candidates/manifest.jsonl --jobs jobs/pilot \
        --tasks dist/v02-candidates/tasks --regrade --models harness/model-a harness/model-b --json out.json

Incomplete or invalid pilot cells produce collect; historical scores alone never
trigger hardening. Replay-command counts are approximate diagnostics, not a score.
"""

from __future__ import annotations

import argparse
import collections
import glob
import json
import math
import os
import re
import sys

from run_meta import harbor_flags, input_mismatch, load_invalid

QUOTA = {"E1": 3, "E2": 3, "E3": 2, "E4": 2, "E5": 2}
TICKETS = {"H01", "H03", "H04", "H05", "H06", "H07", "H08", "H09", "H10", "H11", "H12", "H13", "H15", "H19", "H20",
           "H21", "H22", "H23", "H25"}
REPLAY = re.compile(r"range2test|promtool\s+test\s+rules")
EDIT = re.compile(r"apply_patch|\"(?:Write|Edit|MultiEdit|str_replace_editor)\"|sed\s+-i|cat\s*>|tee\s|>\s*rules/|"
                  r">\s*alertmanager/")


def load_manifest(path: str) -> dict[str, dict]:
    with open(path) as fh:
        return {r["task_id"]: r for r in map(json.loads, fh) if r.get("tier") == "expert"}


def cards(row: dict) -> list[str]:
    return [x.split(":")[1] for x in row["items"]]


def pilot(man: dict[str, dict], per_family: int = 3) -> dict[str, list[str]]:
    out = {}
    for fam in sorted({r["family"] for r in man.values()}):
        rows = sorted((r for r in man.values() if r["family"] == fam), key=lambda r: r["seed"])
        chosen, seen_t, seen_r, multisets = [], set(), collections.Counter(), set()
        for _ in range(per_family):
            best = None
            for r in rows:
                ms = tuple(sorted(cards(r)))
                if r["task_id"] in chosen or ms in multisets:
                    continue
                t = {c for c in cards(r) if c in TICKETS}
                rk = collections.Counter(c for c in cards(r) if c not in TICKETS)
                score = (len(t - seen_t), sum((rk - seen_r).values()), -r["seed"])
                if best is None or score > best[0]:
                    best = (score, r, ms, t, rk)
            if best is None:
                break
            _, r, ms, t, rk = best
            chosen.append(r["task_id"])
            multisets.add(ms)
            seen_t |= t
            seen_r |= rk
        out[fam] = chosen
    return out


def _trial_dirs(roots: list[str]) -> list[str]:
    out = []
    for root in roots:
        out += [os.path.dirname(p) for p in glob.glob(os.path.join(root, "**", "result.json"), recursive=True)
                if os.path.isdir(os.path.join(os.path.dirname(p), "verifier"))]
    return sorted({os.path.realpath(p) for p in out})


def _commands(tdir: str) -> list[str]:
    """Every tool call's arguments in the trial's ATIF trajectory (Harbor writes it one directory down)."""
    paths = sorted(glob.glob(os.path.join(tdir, "*", "trajectory.json")))
    if not paths:
        return []
    with open(paths[0]) as fh:
        steps = json.load(fh).get("steps") or []
    return [json.dumps(tc.get("arguments", {})) for s in steps for tc in (s.get("tool_calls") or [])]


def trials(roots: list[str], man: dict[str, dict], tasks_dir: str | None, invalid=(), regrade=False) -> list[dict]:
    out, seen = [], set()
    for tdir in _trial_dirs(roots):
        with open(os.path.join(tdir, "result.json")) as fh:
            res = json.load(fh)
        tid = str(res.get("task_name", "")).split("/")[-1]
        if tid not in man:
            continue
        identity = res.get("id") or res.get("trial_name") or os.path.realpath(tdir)
        if identity in seen:
            continue
        seen.add(identity)
        info = res.get("agent_info") or {}
        who = f"{info.get('name', '?')}/{(info.get('model_info') or {}).get('name', '?')}"
        rewards = (res.get("verifier_result") or {}).get("rewards") or {}
        failing, ticket = [], {}
        det = os.path.join(tdir, "verifier", "details.json")
        spec = os.path.join(tasks_dir, tid, "tests", "spec.json") if tasks_dir else None
        if spec and os.path.exists(spec):
            with open(spec) as fh:
                ticket = {r["id"]: bool(r.get("ticket")) for r in json.load(fh)["requirements"]}
        if os.path.exists(det):
            with open(det) as fh:
                reqs = json.load(fh).get("requirements", {})
            failing = [(rid, ticket.get(rid, False)) for rid, v in reqs.items() if v.get("s", 0) < 1]
        cmds = _commands(tdir)
        first_edit = next((i for i, c in enumerate(cmds) if EDIT.search(c)), len(cmds))
        flags = harbor_flags(tdir, res, invalid)
        grade_source = "historical"
        if regrade and not flags.get("invalid"):
            from replay_expert import grade_with
            art = os.path.join(tdir, "artifacts", "workspace", "monitoring")
            try:
                if not tasks_dir or not os.path.isdir(art):
                    raise ValueError("the current task and saved workspace are required")
                task = os.path.join(tasks_dir, tid)
                mismatch = input_mismatch(task, art, os.path.join(tdir, "agent", "trajectory.json"))
                if mismatch:
                    flags["invalid"] = mismatch
                rewards, details = grade_with(task, art)
                failing = [(rid, ticket.get(rid, False)) for rid, v in details.get("requirements", {}).items()
                           if v.get("s", 0) < 1]
                grade_source = "current task regrade"
            except Exception as e:
                flags["invalid"] = f"requested regrade failed: {type(e).__name__}: {e}"
        if not all(isinstance(rewards.get(k), (int, float)) and math.isfinite(rewards[k])
                   and 0 <= rewards[k] <= 1 for k in ("reward", "solved")):
            flags["invalid"] = "missing or invalid verifier reward"
        elif not regrade and not flags.get("invalid"):
            flags["invalid"] = "historical grade is unverified; use --regrade with the current tasks"
        out.append({"task_id": tid, "family": man[tid]["family"], "who": who, "solved": rewards.get("solved", 0.0) == 1,
                    "reward": rewards.get("reward", 0.0), "diagnosis": rewards.get("diagnosis"),
                    "failing": failing, "replayed": any(REPLAY.search(c) for c in cmds), "calls": len(cmds),
                    "calls_before_edit": first_edit, "cost": (res.get("agent_result") or {}).get("cost_usd"),
                    "trial": tdir, "grade_source": grade_source, **flags})
    return out


def wilson(k: int, n: int) -> list[float] | None:
    """95% binomial interval; descriptive only (attempts on a task are correlated)."""
    if not n:
        return None
    z, p = 1.959963984540054, k / n
    denom = 1 + z * z / n
    mid = (p + z * z / (2 * n)) / denom
    half = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / denom
    return [round(max(0, mid - half), 4), round(min(1, mid + half), 4)]


def decide(rows: list[dict], man: dict[str, dict], tasks_dir: str | None = None,
           models: list[str] | None = None, attempts: int = 3, per_family: int = 3) -> dict:
    """Only a complete, balanced pilot can trigger a difficulty change or task selection.

    Counts are per task *and* model: nine runs of one task cannot stand in for three tasks.
    Invalid trials remain in the report, but never become model failures. Explicit model IDs
    are recommended; inference is allowed only when exactly two participants are present.
    """
    if attempts < 1 or per_family < 1:
        raise ValueError("attempts and per_family must be positive")
    models = sorted(set(models if models is not None else [r["who"] for r in rows]))
    selected = [r for r in rows if r["who"] in models]
    excluded = [{"trial": r.get("trial"), "task_id": r["task_id"], "reason": r["invalid"]}
                for r in selected if r.get("invalid")]
    valid = [r for r in selected if not r.get("invalid")]
    schedule = pilot(man, per_family)
    expected = {tid for tids in schedule.values() for tid in tids}
    by_task, by_fam = collections.defaultdict(list), collections.defaultdict(lambda: collections.defaultdict(list))
    for r in valid:
        by_task[r["task_id"]].append(r)
        if r["task_id"] in expected:
            by_fam[r["family"]][r["who"]].append(r)
    coverage = {}
    for tid in sorted(expected | set(by_task)):
        counts = collections.Counter(r["who"] for r in by_task[tid])
        coverage[tid] = {m: counts[m] for m in models}
    complete = lambda tid: len(models) == 2 and all(n == attempts for n in coverage[tid].values())
    fams = {}
    for fam, tids in schedule.items():
        per = by_fam[fam]
        rates = {who: (sum(x["solved"] for x in per[who]), len(per[who])) for who in models}
        ready = len(tids) == per_family and len(models) == 2 and all(complete(t) for t in tids)
        best = max((s / n for s, n in rates.values() if n), default=0)
        solves = [x for xs in per.values() for x in xs if x["solved"]]
        non = [x for xs in per.values() for x in xs if not x["solved"] and x["failing"]]
        easy = all(s / n > 6 / 9 for s, n in rates.values()) if ready else None
        band = 2 / 9 <= best <= 6 / 9 if ready else None
        fams[fam] = {"solves": rates, "complete": ready, "in_band": band, "too_easy": easy,
                     "decision": "collect" if not ready else "harden" if easy else "in_band" if band else "audit",
                     "solve_rate_ci95": {m: wilson(s, n) for m, (s, n) in rates.items()},
                     "missing": {t: {m: max(0, attempts - n) for m, n in coverage[t].items()}
                                 for t in tids if not complete(t)},
                     "length_share": round(sum(all(not t for _, t in x["failing"]) for x in non) / len(non), 3) if non else None,
                     "solves_without_replay": round(sum(not x["replayed"] for x in solves) / len(solves), 3) if solves else None}
    tasks = {}
    for tid in sorted(expected | set(by_task)):
        xs = by_task[tid]
        k, n = sum(x["solved"] for x in xs), len(xs)
        fails = collections.Counter(rid for x in xs for rid, _ in x["failing"])
        verdict = "incomplete" if not complete(tid) else "drop" if k == n else "audit" if k == 0 else "keep"
        tasks[tid] = {"solved": k, "trials": n, "rate": round(k / n, 3) if n else None, "verdict": verdict,
                      "by_model": coverage[tid], "solve_rate_ci95": wilson(k, n),
                      "top_failure": fails.most_common(1)[0] if fails else None,
                      "audit_reason": "one requirement behind 4+ failures" if fails and fails.most_common(1)[0][1] >= 4 else None}
    eligible = {t: v for t, v in tasks.items()
                if fams.get(man[t]["family"], {}).get("decision") == "in_band"}
    return {"families": fams, "tasks": tasks, "public": public(eligible, man, tasks_dir), "excluded": excluded,
            "protocol": {"models": models, "attempts_per_task_model": attempts, "tasks_per_family": per_family,
                         "pilot": schedule, "purpose": "development calibration; not held-out measurement",
                         "model_count_ok": len(models) == 2,
                         "replay_diagnostic": "approximate tool-name match; not a difficulty decision"},
            "valid_trials": len(valid)}


MAX_JACCARD = 0.10


def prose_grams(tasks_dir: str | None, tid: str) -> set:
    """Word 6-grams of a task's instruction and incident prose (survey included), names, keys and numbers masked."""
    if not tasks_dir or not os.path.isdir(os.path.join(tasks_dir, tid)):
        return set()
    root = os.path.join(tasks_dir, tid)
    ws = os.path.join(root, "environment", "workspace", "monitoring")
    files = [os.path.join(root, "instruction.md")] + glob.glob(os.path.join(ws, "incidents", "*", "*.md")) \
        + glob.glob(os.path.join(ws, "docs", "oncall-survey*.md"))
    text = "\n".join(open(f).read() for f in files if os.path.exists(f))
    names = set()
    own = os.path.join(ws, "teams", "ownership.yaml")
    if os.path.exists(own):
        names = {x for pair in re.findall(r"^  ([\w-]+):$|^    - ([\w-]+)", open(own).read(), re.M) for x in pair if x}
    for n in sorted(names, key=len, reverse=True):
        text = text.replace(n, "X")
    text = re.sub(r"[A-Z][a-z]+[A-Z][A-Za-z]+", "A", text)
    text = re.sub(r"\b[A-Z]+-\d+\b", "K", text)
    words = re.sub(r"\d+(\.\d+)?", "N", text).split()
    return {tuple(words[i:i + 6]) for i in range(len(words) - 5)}


def _jaccard(a: set, b: set) -> float:
    return len(a & b) / len(a | b) if a and b else 0.0


def public(tasks: dict, man: dict[str, dict], tasks_dir: str | None = None) -> dict[str, list[str]]:
    out, grams, all_picked = {}, {}, []
    for fam, k in QUOTA.items():
        cands = sorted((t for t, v in tasks.items() if man[t]["family"] == fam and v["verdict"] == "keep"),
                       key=lambda t: (abs(tasks[t]["rate"] - 0.5), man[t]["seed"]))
        picked, seen = [], set()
        for t in cands:
            ms = tuple(sorted(cards(man[t])))
            g = grams.setdefault(t, prose_grams(tasks_dir, t))
            close = any(_jaccard(g, grams[o]) > MAX_JACCARD for o in all_picked)
            if ms not in seen and not close and len(picked) < k:
                picked.append(t)
                all_picked.append(t)
                seen.add(ms)
        out[fam] = picked
    return out


def main(argv=None) -> int:
    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
    ap.add_argument("--manifest", required=True)
    ap.add_argument("--tasks", help="candidate tasks dir (default: tasks/ next to the manifest)")
    ap.add_argument("--pilot", action="store_true")
    ap.add_argument("--jobs", nargs="*", default=[])
    ap.add_argument("--json")
    ap.add_argument("--invalid", help="same invalid-trial list as export_runs.py")
    ap.add_argument("--regrade", action="store_true", help="grade saved workspaces with current tasks before decisions")
    ap.add_argument("--models", nargs=2, help="the two pilot participants, as agent/model IDs")
    ap.add_argument("--attempts", type=int, default=3, help="required valid runs per task and model (default: 3)")
    a = ap.parse_args(argv)
    man = load_manifest(a.manifest)
    if a.pilot:
        out = {"pilot": pilot(man)}
    else:
        tdir = a.tasks or os.path.join(os.path.dirname(os.path.abspath(a.manifest)), "tasks")
        rows = trials(a.jobs, man, tdir, load_invalid(a.invalid), regrade=a.regrade)
        out = decide(rows, man, tdir, models=a.models, attempts=a.attempts)
        cost = collections.defaultdict(float)
        for r in rows:
            cost[r["who"]] += r["cost"] or 0.0
        out["cost_usd"] = {k: round(v, 3) for k, v in sorted(cost.items())}
        out["trials"] = len(rows)
    text = json.dumps(out, indent=1, default=str)
    if a.json:
        with open(a.json, "w") as fh:
            fh.write(text + "\n")
    print(text)
    return 0


if __name__ == "__main__":
    sys.exit(main())