| """Expert-tier builder: `alertforge expert --out DIR [--families E1,E2] [--seeds 1-8] [--jobs 4]`. |
| |
| Builds candidate tasks into DIR/tasks, runs the acceptance gate on each, writes partial/ and null/ policies, |
| moves candidates that fail the gate to DIR/rejected/ and logs every result to DIR/gate.jsonl.""" |
|
|
| from __future__ import annotations |
|
|
| import json |
| import os |
| import shutil |
| import sys |
| import time |
| from concurrent.futures import ProcessPoolExecutor, as_completed |
|
|
|
|
| RESAMPLES = 3 |
|
|
|
|
| def _reject(out: str, tid: str) -> None: |
| """A failed rebuild cannot leave an old task in the accepted/publishable directories.""" |
| src, dst = os.path.join(out, "tasks", tid), os.path.join(out, "rejected", tid) |
| if os.path.exists(src): |
| if os.path.exists(dst): |
| shutil.rmtree(dst) |
| os.makedirs(os.path.dirname(dst), exist_ok=True) |
| shutil.move(src, dst) |
| for sub in ("partial", "null"): |
| shutil.rmtree(os.path.join(out, sub, tid), ignore_errors=True) |
|
|
|
|
| def _one(args) -> dict: |
| fam, seed, out, master, adversaries = args[:5] |
| from . import build, gate, knobs |
| if len(args) > 5 and args[5] is not None: |
| knobs.set_active(args[5]) |
| tid = f"afx-{fam.lower()}-s{seed:02d}" |
| t0 = time.time() |
| sweep: list[str] = [] |
| try: |
| for k in range(RESAMPLES): |
| m = build.build_task(fam, seed, os.path.join(out, "tasks"), tid, master, resample=k) |
| sweep = gate.variant_sweep(m) |
| if not sweep: |
| break |
| except Exception as e: |
| _reject(out, tid) |
| return {"task_id": tid, "family": fam, "seed": seed, "pass": False, "reasons": [f"build failed: {e!r}"]} |
| t1 = time.time() |
| try: |
| res = gate.gate_task(m, out, adversaries=adversaries, sweep=sweep) |
| except Exception as e: |
| _reject(out, tid) |
| return {"task_id": tid, "family": fam, "seed": seed, "pass": False, |
| "reasons": [f"gate failed: {e!r}"]} |
| res.update(seed=seed, build_seconds=round(t1 - t0, 1), gate_seconds=round(time.time() - t1, 1), resample=m["resample"], |
| knobs=sorted(knobs.ACTIVE), ticket_share=_ticket_share(m["spec"]), |
| n_checks=m["n_checks"], items=[f"{it.rid}:{it.code}" for it in m["items"]], |
| kept=[k.alert for k in m["kept"]], company=m["world"].company.name, |
| n_alert_rules=sum(1 for f in m["world"].files.values() for g in f.groups for r in g["rules"] if "alert" in r), |
| n_record_rules=sum(1 for f in m["world"].files.values() for g in f.groups for r in g["rules"] if "record" in r), |
| n_rule_files=len(m["world"].files)) |
| if not res["pass"]: |
| _reject(out, tid) |
| return res |
|
|
|
|
| def _ticket_share(spec: dict) -> float: |
| w = [(r["weight"], bool(r.get("ticket"))) for r in spec["requirements"]] |
| return round(sum(x for x, t in w if t) / (sum(x for x, _ in w) or 1), 3) |
|
|
|
|
| def _seeds(spec: str) -> list[int]: |
| if "-" in spec: |
| a, b = spec.split("-") |
| return list(range(int(a), int(b) + 1)) |
| return [int(x) for x in spec.split(",")] |
|
|
|
|
| def main(a) -> int: |
| fams = a.families.split(",") |
| kn = None if getattr(a, "knobs", None) is None else [k for k in a.knobs.split(",") if k] |
| if kn is not None: |
| from . import knobs |
| knobs.set_active(kn) |
| jobs = [(f, s, a.out, a.master_seed, not a.no_adversaries, kn) for s in _seeds(a.seeds) for f in fams] |
| os.makedirs(a.out, exist_ok=True) |
| log = open(os.path.join(a.out, "gate.jsonl"), "a") |
| rows, fails = [], 0 |
| with ProcessPoolExecutor(max_workers=a.jobs) as ex: |
| futs = [ex.submit(_one, j) for j in jobs] |
| for fu in as_completed(futs): |
| res = fu.result() |
| rows.append(res) |
| fails += 0 if res["pass"] else 1 |
| log.write(json.dumps({**res, "ts": time.strftime("%Y-%m-%dT%H:%M:%S")}, default=str) + "\n") |
| log.flush() |
| print(f"{res['task_id']:16s} {'PASS' if res['pass'] else 'FAIL'} oracle={res.get('oracle')} alt={res.get('alt')} " |
| f"null={res.get('null')} partial={res.get('partial')} grader={res.get('grader_seconds')} " |
| f"checks={res.get('n_checks')}" + ("" if res["pass"] else f"\n {str(res['reasons'])[:600]}"), flush=True) |
| mpath = os.path.join(a.out, "manifest.jsonl") |
| keep = {} |
| if os.path.exists(mpath): |
| for line in open(mpath): |
| r = json.loads(line) |
| keep[r["task_id"]] = r |
| for r in rows: |
| keep.pop(r["task_id"], None) |
| if r["pass"]: |
| keep[r["task_id"]] = {k: r.get(k) for k in ("task_id", "family", "seed", "company", "items", "kept", "n_checks", |
| "n_alert_rules", "n_record_rules", "n_rule_files", "grader_seconds", |
| "partial", "alert_rules_pristine", "ticket_share", "detect", |
| "overlap", "overlap_seed", "decoys", "resample", "knobs")} | {"tier": "expert"} |
| with open(mpath, "w") as fh: |
| for tid in sorted(keep): |
| fh.write(json.dumps(keep[tid]) + "\n") |
| print(f"{len(rows) - fails}/{len(rows)} candidates pass the gate") |
| |
| from . import xlint |
| built = [(f, s) for s in _seeds(a.seeds) for f in fams] |
| bad, stats = xlint.check([xlint.render(f, s, a.master_seed) for f, s in built]) |
| with open(os.path.join(a.out, "xlint.json"), "w") as fh: |
| json.dump({"tasks": [f"afx-{f.lower()}-s{s:02d}" for f, s in built], "over_cap": bad, **stats}, fh, indent=1, default=str) |
| print(f"cross-task lint: {len(bad)} sentences over the cap, max 6-gram Jaccard {stats['max_jaccard_6gram']}") |
| for b in bad[:20]: |
| print(" ", b) |
| return 0 if not bad and not fails else 1 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(0) |
|
|
