| """End-state scorer. | |
| Checks four predicates against the final world state: | |
| root_cause -- the submitted report names the primary fault (type:service) | |
| mitigated -- every declared fault is inactive in the final state | |
| no_collateral -- no healthy service was mutated (version/config/replicas/secrets) | |
| resolved -- all of the above | |
| The scorer never repairs agent output and never grants partial credit on `resolved`. | |
| """ | |
| from __future__ import annotations | |
| from . import world as W | |
| from . import faults as F | |
| def truth_from_spec(task: dict) -> dict: | |
| """Derive the answer key from the task spec itself. | |
| The environment already carries the fault declarations it needs to simulate | |
| metrics, so scoring requires no separately shipped answers file. The public | |
| task file is self-contained; the agent just must never read it. | |
| """ | |
| faults = task["spec"]["faults"] | |
| primary = faults[0] | |
| cls = F.FAULT_TYPES[primary["type"]] | |
| fault_svcs = sorted({s for f in faults for s in F.FAULT_TYPES[f["type"]].services(f["params"])}) | |
| return { | |
| "task_id": task["task_id"], | |
| "cause": f"{primary['type']}:{primary['params']['svc']}", | |
| "primary_service": primary["params"]["svc"], | |
| "fault_services": fault_svcs, | |
| "difficulty": task["difficulty"], | |
| "family": task["family"], | |
| } | |
| def score_episode(ep, answer: dict) -> dict: | |
| w = ep.w | |
| report = w.get("report") | |
| report_valid = bool(report) and ":" in report.get("cause", "") | |
| root_cause = bool(report_valid) and report["cause"] == answer["cause"] | |
| still_active = [] | |
| for f in w["faults"]: | |
| cls = F.FAULT_TYPES[f["type"]] | |
| if cls.active(w, f["params"]): | |
| still_active.append(f["type"]) | |
| mitigated = not still_active | |
| fault_svcs = set(answer["fault_services"]) | |
| violations = [] | |
| for name, s in w["services"].items(): | |
| if s["kind"] == "external" or name in fault_svcs: | |
| continue | |
| if W.current_version(w, name) != s["initial_version"]: | |
| violations.append(f"{name}: version changed on healthy service") | |
| if s["config"] != s["initial_config"]: | |
| violations.append(f"{name}: config changed on healthy service") | |
| if s["replicas"] < s["initial_replicas"]: | |
| violations.append(f"{name}: replicas scaled down on healthy service") | |
| for key, sec in s.get("secrets", {}).items(): | |
| if sec.get("rotated_at") is not None: | |
| violations.append(f"{name}: secret '{key}' rotated on healthy service") | |
| no_collateral = not violations | |
| resolved = bool(root_cause and mitigated and no_collateral) | |
| return { | |
| "task_id": answer["task_id"], | |
| "resolved": resolved, | |
| "report_valid": report_valid, | |
| "root_cause": root_cause, | |
| "mitigated": mitigated, | |
| "no_collateral": no_collateral, | |
| "collateral_violations": violations, | |
| "faults_still_active": still_active, | |
| "actions_used": ep.used, | |
| "budget": ep.budget, | |
| "budget_exhausted": ep.used >= ep.budget and report is None, | |
| "submitted_cause": report["cause"] if report else None, | |
| "family": answer.get("family", ep.task.get("family")), | |
| "difficulty": answer.get("difficulty", ep.task.get("difficulty")), | |
| } | |
| def summarize(results: list[dict]) -> dict: | |
| def rate(rows): | |
| return round(sum(1 for r in rows if r["resolved"]) / len(rows), 4) if rows else None | |
| by_tier, by_family = {}, {} | |
| for r in results: | |
| by_tier.setdefault(r.get("difficulty") or "unknown", []).append(r) | |
| by_family.setdefault(r.get("family") or "unknown", []).append(r) | |
| return { | |
| "n": len(results), | |
| "resolved_rate": rate(results), | |
| "by_tier": {t: {"n": len(v), "resolved_rate": rate(v)} for t, v in sorted(by_tier.items())}, | |
| "by_family": {f: {"n": len(v), "resolved_rate": rate(v)} for f, v in sorted(by_family.items())}, | |
| } | |