| |
| """Record scripted, LLM-free reference episodes through the OpenEnv episode layer, for the replay Space. |
| |
| Each episode drives `alertforge.episode.Episode` (the class the OpenEnv server wraps) in parity reward mode, |
| so the per-step rewards sum to the Harbor reward. After every step the workspace is graded with the same |
| grader, and the trimmed grader details (per-check pass/fail) are stored with the step. |
| |
| Policies (all read the conventions and the files they will change first): |
| oracle writes the oracle solution file by file, runs `run_checks` in between, then submits |
| partial writes the partial reference solution (half the requests, one plausible mistake) |
| careless oracle, with two slips that are caught and fixed: a hand edit that mis-indents one key of a |
| rule file (caught by `run_checks`), and a page route sent to Slack (caught by `route_test`) |
| |
| export AF_PROMTOOL=/path/to/promtool AF_AMTOOL=/path/to/amtool |
| python scripts/record_reference_runs.py --out dist/replay/traces [--tasks af-001,af-009] [-j 4] |
| python scripts/export_runs.py --traces dist/replay/traces --out space/data/runs.json |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| import sys |
| from concurrent.futures import ProcessPoolExecutor |
|
|
| ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) |
| sys.path.insert(0, os.path.join(ROOT, "src")) |
|
|
| from alertforge.episode import Episode |
| from alertforge.solutions import break_indent |
|
|
| |
| DEFAULT_TASKS = ["af-001", "af-009", "af-013", "af-017", "af-021", "af-029"] |
| POLICIES = ["oracle", "partial", "careless"] |
| TIERS = ("easy", "medium", "hard") |
|
|
|
|
| def heredoc_writes(script: str) -> list[tuple[str, str]]: |
| """Parse `cat > 'path' <<'AF_EOF'` blocks of a reference solve.sh into (path, content) writes.""" |
| out, cur, buf = [], None, [] |
| for line in open(script).read().splitlines(): |
| if cur is None and line.startswith("cat > '") and line.endswith("<<'AF_EOF'"): |
| cur, buf = line.split("'")[1], [] |
| elif cur is not None and line == "AF_EOF": |
| out.append((cur, "\n".join(buf) + "\n")) |
| cur = None |
| elif cur is not None: |
| buf.append(line) |
| return out |
|
|
|
|
| def trim_details(details: dict) -> dict: |
| """Keep what the checks panel needs from a grader details dict.""" |
| reqs = {} |
| for rid, rd in (details.get("requirements") or {}).items(): |
| fams = rd.get("families") or {} |
| reqs[rid] = {"s": rd.get("s"), "families": {"pos": fams["pos"]} if "pos" in fams else {}} |
| return {"checks": details.get("checks") or {}, "requirements": reqs, |
| "preservation_items": details.get("preservation_items") or [], "tamper": details.get("tamper") or [], |
| "syntax_errors": details.get("syntax_errors") or {}} |
|
|
|
|
| def indent_slip(rules: list[tuple[str, str]], ws0: str) -> list[dict]: |
| """A hand edit of an already-fixed, pre-existing rule file that breaks its YAML, then the fix.""" |
| pre = [(p, c) for p, c in rules if os.path.exists(os.path.join(ws0, p))] or rules |
| if not pre: |
| return [] |
| p, c = pre[0] |
| bad = break_indent(c) |
| bad_line = next((b for b, g in zip(bad.splitlines(), c.splitlines()) if b != g), None) |
| acts = [{"think": f"Tidy up {p} by hand before moving on."}, |
| {"tool": "write_file", "path": p, "content": bad}, {"tool": "run_checks"}, |
| {"think": f"`run_checks` says {p} no longer loads: an `expr:` key is indented one space too far, " |
| "so every rule in the file is gone. Fix the indentation."}] |
| if bad_line is not None and bad.count("\n" + bad_line + "\n") == 1: |
| acts.append({"tool": "replace_in_file", "path": p, "old": "\n" + bad_line + "\n", |
| "new": "\n" + bad_line[1:] + "\n"}) |
| else: |
| acts.append({"tool": "write_file", "path": p, "content": c}) |
| acts.append({"tool": "run_checks"}) |
| return acts |
|
|
|
|
| def bad_route(am_text: str, route_req: dict | None) -> str | None: |
| """A plausible routing slip: the new team's page route sends to its Slack receiver instead of the pager.""" |
| if not route_req or not route_req["route"]["pos"]: |
| return None |
| expect = route_req["route"]["pos"][0]["expect"] |
| pager = next((e for e in expect if e.startswith("pagerduty-")), None) |
| chat = next((e for e in expect if e.startswith("slack-")), None) |
| if not pager or not chat or f"receiver: {pager}" not in am_text: |
| return None |
| return am_text.replace(f"receiver: {pager}", f"receiver: {chat}", 1) |
|
|
|
|
| def plan(task_dir: str, policy: str) -> list[dict]: |
| """The scripted action list (with `think` notes interleaved) for one policy.""" |
| tid = os.path.basename(task_dir) |
| oracle = heredoc_writes(os.path.join(task_dir, "solution", "solve.sh")) |
| writes = heredoc_writes(os.path.join(ROOT, "partial", tid, "solve.sh")) if policy == "partial" else oracle |
| with open(os.path.join(task_dir, "tests", "spec.json")) as fh: |
| spec = json.load(fh) |
| route_req = next((r for r in spec["requirements"] if r["kind"] == "route"), None) |
| probe_labels = route_req["route"]["pos"][0]["labels"] if route_req else None |
| ws0 = os.path.join(task_dir, "environment", "workspace", "monitoring") |
|
|
| acts: list[dict] = [{"think": "Start by listing the repo and reading the conventions in README.md."}, |
| {"tool": "list_files"}, {"tool": "read_file", "path": "README.md"}] |
| targets = [p for p, _ in writes if os.path.exists(os.path.join(ws0, p))] |
| if targets: |
| acts.append({"think": "Read every file the change requests touch before editing: " + ", ".join(targets) + "."}) |
| acts += [{"tool": "read_file", "path": p} for p in targets] |
|
|
| rules = [(p, c) for p, c in writes if p.startswith("rules/")] |
| am = [(p, c) for p, c in writes if p.startswith("alertmanager/")] |
| for n, (p, c) in enumerate(rules): |
| acts.append({"think": f"Update {p}."}) |
| acts.append({"tool": "write_file", "path": p, "content": c}) |
| if n % 2 == 1 or n == len(rules) - 1: |
| acts.append({"tool": "run_checks"}) |
| if policy == "careless": |
| acts += indent_slip(rules, ws0) |
| for p, c in am: |
| slip = bad_route(c, route_req) if policy == "careless" else None |
| if slip: |
| acts.append({"think": "Route the new team and add the inhibition in the Alertmanager config."}) |
| acts.append({"tool": "write_file", "path": p, "content": slip}) |
| acts.append({"tool": "route_test", "labels": probe_labels}) |
| acts.append({"think": "`route_test` shows the page alert only reaching Slack: the page route points at " |
| "the wrong receiver. Rewrite the config."}) |
| else: |
| acts.append({"think": "Route the new team and add the inhibition in the Alertmanager config."}) |
| acts.append({"tool": "write_file", "path": p, "content": c}) |
| if probe_labels: |
| acts.append({"tool": "route_test", "labels": probe_labels}) |
| acts.append({"tool": "run_checks"}) |
| acts.append({"think": "Checks pass locally; submit."}) |
| acts.append({"tool": "submit"}) |
| return acts |
|
|
|
|
| def record(task_dir: str, policy: str) -> dict: |
| tid = os.path.basename(task_dir) |
| tier = next(t for t in TIERS if f"-{t}-" in tid) |
| ep = Episode(task_dir, split="train", mode="parity", tier=tier) |
| steps = [] |
| try: |
| for a in plan(task_dir, policy): |
| if "think" in a: |
| steps.append({"think": a["think"]}) |
| continue |
| res = ep.step(a) |
| keys, details = ep.grader.grade(ep.ws) |
| steps.append({"action": a, "output": res["output"], "ok": res["ok"], "reward": res["reward"], |
| "done": res["done"], "metadata": res["metadata"], "keys": keys, |
| "details": trim_details(details)}) |
| if res["done"]: |
| break |
| finally: |
| ep.close() |
| total = sum(s.get("reward", 0.0) for s in steps) |
| last = steps[-1] |
| return {"format": "3ambench-trace/1", "source": "openenv", "task_id": tid, "tier": tier, |
| "agent": f"reference: {policy}", "model": "scripted (no LLM)", "reward_mode": "parity", |
| "total_reward": round(total, 6), "harbor_reward": last["metadata"].get("harbor_reward"), |
| "final_keys": last["keys"], "steps": steps} |
|
|
|
|
| def _job(args: tuple[str, str, str]) -> str: |
| task_dir, policy, out = args |
| tr = record(task_dir, policy) |
| path = os.path.join(out, f"{tr['task_id']}__{policy}.json") |
| with open(path, "w") as fh: |
| json.dump(tr, fh) |
| n = sum(1 for s in tr["steps"] if "action" in s) |
| return f"{tr['task_id']:44s} {policy:9s} steps={n:3d} sum_r={tr['total_reward']:.4f} harbor={tr['harbor_reward']}" |
|
|
|
|
| def main() -> int: |
| ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| ap.add_argument("--out", default=os.path.join(ROOT, "dist", "replay", "traces")) |
| ap.add_argument("--tasks", default=",".join(DEFAULT_TASKS), help="comma-separated task ids or prefixes") |
| ap.add_argument("--policies", default=",".join(POLICIES)) |
| ap.add_argument("-j", "--jobs", type=int, default=4) |
| a = ap.parse_args() |
| os.makedirs(a.out, exist_ok=True) |
| all_tasks = sorted(os.listdir(os.path.join(ROOT, "tasks"))) |
| chosen = [t for pre in a.tasks.split(",") for t in all_tasks if t.startswith(pre.strip())] |
| jobs = [(os.path.join(ROOT, "tasks", t), p, a.out) for t in chosen for p in a.policies.split(",")] |
| with ProcessPoolExecutor(max_workers=a.jobs) as pool: |
| for line in pool.map(_job, jobs): |
| print(line, flush=True) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
