platformforge 0.1.0__py3-none-any.whl

platformforge/lab/fleetlab.py

@@ -0,0 +1,351 @@
+"""Cycle 5 Phase N — fleet lab scenarios (§273–285).
+
+A fleet scenario is a fixture (fleet + graphs + events + costs +
+capacity + requests + policies) evaluated by deterministic checks —
+the same analytics used by the real CLI. `kind: fleet` in the
+scenario YAML. Every verdict is evidence-cited; coverage is always
+part of the answer.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from platformforge.fleet.loader import fleet_from, graph_from_doc, load_fleet_dir
+from platformforge.fleet.query import fleet_query
+
+
+def _load_fixture(fx: Path) -> dict[str, Any]:
+    return load_fleet_dir(fx)
+
+
+def run_fleet_scenario(scenario_dir) -> dict[str, Any]:
+    """`scenario_dir` holds expected.yaml (checks) + fixture/ (data)."""
+    d = Path(scenario_dir)
+    doc = yaml.safe_load((d / "expected.yaml").read_text())
+    # shared fleet fixtures live in lab/fleets/<name>; per-scenario
+    # fixture/ overrides file-by-file (§274 — one fleet, many questions)
+    shared = doc.get("shared_fixture")
+    data: dict[str, Any] = {}
+    if shared:
+        from platformforge.resources import data_path
+        data = _load_fixture(data_path() / shared)
+    local = d / "fixture"
+    if local.is_dir():
+        for k, v in _load_fixture(local).items():
+            if v is not None:
+                data[k] = v
+    fx = d
+    checks: list[str] = []
+    failures: list[str] = []
+    results: dict[str, Any] = {}
+
+    fleet = fleet_from(data)
+    graph = graph_from_doc(data.get("graph"))
+    events = data.get("events") or {}
+    costs = data.get("costs") or {}
+    capacity = data.get("capacity") or {}
+    requests = data.get("requests") or {}
+    policies = data.get("policies") or {}
+
+    for chk in doc.get("checks", []):
+        kind, expect = next(iter(chk.items()))
+        checks.append(kind)
+        r = _run_check(kind, expect, fleet, graph, events, costs,
+                       capacity, requests, policies, data)
+        results[kind] = r
+        failures.extend(r.get("failures", []))
+    return {"scenario": fx.name, "checks": checks, "results": results,
+            "failures": failures,
+            "verdict": "pass" if not failures else "fail"}
+
+
+def _patterns_at(eng, window: str, now) -> list:
+    """patterns() against a fixed lab clock."""
+    from platformforge.analytics.history import WINDOWS
+    from platformforge.analytics.models import HistoricalPattern, confidence_for_support
+    since = now - WINDOWS.get(window, WINDOWS["90d"])
+    groups: dict[tuple, list] = {}
+    for e in eng._events:
+        if since <= e.ts <= now:
+            k = (e.subject, e.kind, e.outcome)
+            groups.setdefault(k, []).append(e)
+    return [HistoricalPattern(
+        pattern_id=f"{kind}:{subj}:{outcome}", window=window,
+        support=len(evs), sample_size=len(evs),
+        confidence=confidence_for_support(len(evs)),
+        scope={"subject": subj},
+        limitations=["correlation is not causality"])
+        for (subj, kind, outcome), evs in groups.items() if len(evs) >= 2]
+
+
+def _expect_eq(name: str, got, want, failures: list[str]) -> None:
+    if want is not None and got != want:
+        failures.append(f"{name}: expected {want!r}, got {got!r}")
+
+
+def _expect_min(name: str, got, want, failures: list[str]) -> None:
+    if want is not None and not (got or 0) >= want:
+        failures.append(f"{name}: expected >={want}, got {got}")
+
+
+def _run_check(kind: str, expect: dict[str, Any], fleet, graph, events,
+               costs, capacity, requests, policies,
+               data) -> dict[str, Any]:
+    f: list[str] = []
+    out: dict[str, Any] = {"failures": f}
+
+    if kind == "fleet_query":
+        r = fleet_query(graph, expect["question"])
+        _expect_min("count", r["count"], expect.get("min_count"), f)
+        if expect.get("node_ids"):
+            missing = set(expect["node_ids"]) - \
+                {i["node_id"] for i in r["items"]}
+            if missing:
+                f.append(f"missing nodes: {sorted(missing)}")
+        out["result"] = r
+
+    elif kind == "history_pattern":
+        from platformforge.analytics.history import HistoryEngine
+        from platformforge.live.models import parse_ts
+        eng = HistoryEngine()
+        for k, evs in events.items():
+            eng.ingest_events(k, evs, "lab")
+        # deterministic lab clock — newest event is "now" so fixtures
+        # never age out of their own windows
+        stamps = [parse_ts(str(e.get("ts", ""))) for evs in
+                  events.values() for e in evs]
+        now = max((s for s in stamps if s), default=None)
+        win = expect.get("window", "90d")
+        pats = eng.patterns(win) if now is None else \
+            _patterns_at(eng, win, now)
+        _expect_min("patterns", len(pats), expect.get("min_support"), f)
+        if expect.get("max_confidence"):
+            order = {"low": 0, "medium": 1, "high": 2}
+            for p in pats:
+                if order[p.confidence] > order[expect["max_confidence"]]:
+                    f.append(f"confidence {p.confidence} exceeds cap "
+                             f"{expect['max_confidence']}")
+        out["result"] = [p.to_dict() for p in pats]
+
+    elif kind == "policy_analytics":
+        from platformforge.analytics.policyintel import (
+            false_positive_candidates,
+            policy_metrics,
+            policy_recommendations,
+        )
+        m = policy_metrics(policies.get("decisions", []),
+                           exceptions=policies.get("exceptions", []),
+                           overrides=policies.get("overrides", []))
+        fps = false_positive_candidates(m, policies.get("outcomes", {}))
+        recs = policy_recommendations(m, fps)
+        if expect.get("policy"):
+            pm = m.get(expect["policy"], {})
+            for k, v in expect.get("metrics", {}).items():
+                _expect_eq(f"policy.{k}", pm.get(k), v, f)
+        _expect_min("fp_candidates", len(fps),
+                    expect.get("min_fp"), f)
+        _expect_min("recommendations", len(recs),
+                    expect.get("min_recs"), f)
+        if expect.get("no_auto_apply") and \
+                any(r.get("executes") for r in recs):
+            f.append("recommendation marked executes")
+        out["result"] = {"metrics": m, "fp": fps, "recs": recs}
+
+    elif kind == "golden_path":
+        from platformforge.analytics.goldenpath import golden_path_analytics, golden_path_recommendations
+        a = golden_path_analytics(requests.get("requests", []),
+                                  outcomes=requests.get("outcomes", []),
+                                  escapes=requests.get("escapes", []))
+        pa = a["paths"].get(expect.get("path", ""), {})
+        for k, v in expect.get("expect", {}).items():
+            _expect_eq(f"gp.{k}", pa.get(k), v, f)
+        if expect.get("escape_reason") and \
+                expect["escape_reason"] not in pa.get(
+                        "escape_reasons", {}):
+            f.append(f"escape reason {expect['escape_reason']} "
+                     "not observed")
+        recs = golden_path_recommendations(a)
+        _expect_min("recs", len(recs), expect.get("min_recs"), f)
+        out["result"] = a
+
+    elif kind == "cost":
+        from platformforge.analytics.finops_v4 import cost_hierarchy, cost_trend, idle_resources, rightsizing
+        if "hierarchy" in expect:
+            h = cost_hierarchy(costs.get("allocations", []))
+            _expect_min("unallocated", h["unallocated"],
+                        expect["hierarchy"].get("min_unallocated"), f)
+            out["result"] = h
+        if "rightsizing" in expect:
+            hits = [rightsizing(w) for w in costs.get("workloads", [])]
+            hits = [h for h in hits if h]
+            _expect_min("rightsizing", len(hits),
+                        expect["rightsizing"].get("min"), f)
+            out["result"] = hits
+        if "idle" in expect:
+            idle = idle_resources(costs.get("resources", []))
+            _expect_min("idle", len(idle), expect["idle"].get("min"), f)
+            if any(i["deletable"] for i in idle):
+                f.append("idle marked deletable")
+            out["result"] = idle
+        if "trend" in expect:
+            t = cost_trend(costs.get("points", []))
+            _expect_eq("trend", t["trend"],
+                       expect["trend"].get("direction"), f)
+            out["result"] = t
+
+    elif kind == "capacity":
+        from platformforge.analytics.capacity import CapacityDimension, CapacitySnapshot, capacity_risk
+        snaps = {}
+        for m in capacity.get("members", []):
+            snaps[m["member_id"]] = CapacitySnapshot(
+                member_id=m["member_id"],
+                dimensions=[CapacityDimension(
+                    d["name"], d.get("used"), d.get("capacity"),
+                    d.get("source", "observed"))
+                    for d in m.get("dimensions", [])])
+        member = expect.get("member")
+        if member and member in snaps:
+            risk = capacity_risk(
+                snaps[member],
+                criticality=expect.get("criticality"),
+                failure_domains=expect.get("failure_domains"))
+            _expect_eq("risk", risk["risk"], expect.get("expect_risk"), f)
+            out["result"] = risk
+        else:
+            sats = {mid: s.saturation() for mid, s in snaps.items()}
+            hot = [mid for mid, s in sats.items()
+                   if s["saturated_dimensions"]]
+            _expect_min("saturated", len(hot), expect.get("min_hot"), f)
+            out["result"] = sats
+
+    elif kind == "reliability":
+        from platformforge.analytics.reliability import blast_concentration, build_profile, fleet_hotspots
+        profiles = [build_profile(
+            s["service"], events.get("incident", []) if s.get("all") else
+            [i for i in events.get("incident", [])
+             if i.get("service") == s["service"]],
+            [c for c in events.get("deployment", [])
+             if c.get("service") == s["service"]],
+            [r for r in events.get("rollback", [])
+             if r.get("service") == s["service"]])
+            for s in expect.get("services",
+                                [{"service": s} for s in {
+                                    i.get("service") for i in
+                                    events.get("incident", [])
+                                    if i.get("service")}])]
+        hot = fleet_hotspots(profiles)
+        _expect_min("hotspots", len(hot), expect.get("min_hotspots"), f)
+        if expect.get("blast"):
+            conc = blast_concentration(graph)
+            out["blast"] = conc
+            _expect_min("centrality", len(conc),
+                        expect["blast"].get("min"), f)
+        out["result"] = hot
+
+    elif kind == "operations":
+        from platformforge.analytics.opsanalytics import (
+            operation_hotspots,
+            operation_metrics,
+            remediation_recurrence,
+        )
+        ops = events.get("operation", [])
+        m = operation_metrics(ops)
+        hot = operation_hotspots(ops, expect.get("min_count", 3))
+        rec = remediation_recurrence(events.get("remediation", []))
+        for k, v in expect.get("metrics", {}).items():
+            _expect_eq(f"ops.{k}", m.get(k), v, f)
+        _expect_min("hotspots", len(hot), expect.get("min_hotspots"), f)
+        _expect_min("recurrence", len(rec), expect.get("min_recurrence"),
+                    f)
+        if expect.get("no_auto_remediate") and \
+                any(r.get("auto_remediate") for r in rec):
+            f.append("auto_remediate true")
+        out["result"] = {"metrics": m, "hotspots": hot,
+                         "recurrence": rec}
+
+    elif kind == "coverage":
+        from platformforge.fleet.models import FleetSnapshot, MemberObservation
+        obs = [MemberObservation(**o)
+               for o in (data.get("capacity", {}) or {}).get(
+                   "observations",
+                   (data.get("fleet") or {}).get("observations", []))]
+        snap = FleetSnapshot(fleet_id=fleet.fleet_id,
+                             member_observations=obs)
+        _expect_eq("ratio", snap.coverage_ratio,
+                   expect.get("ratio"), f)
+        if expect.get("max_coverage") is not None and \
+           snap.coverage > expect["max_coverage"]:
+            f.append(f"coverage {snap.coverage} exceeds cap "
+                     f"{expect['max_coverage']}")
+        out["result"] = snap.to_dict()
+
+    elif kind == "federation":
+        from platformforge.federation.node import NodeManifest, export_summary
+        fed = data.get("fleet", {}).get("federation", {})
+        node = NodeManifest(node_id=fed.get("node_id", "n1"),
+                            capabilities=fed.get("capabilities", []))
+        for exp in fed.get("exports", []):
+            s = export_summary(node, exp.get("payload", {}),
+                               exp.get("classification", "internal"))
+            out.setdefault("exports", []).append(s)
+        for i, exp in enumerate(expect.get("exports", [])):
+            got = out["exports"][i] if i < len(out["exports"]) else {}
+            _expect_eq("fed.action", got.get("action"),
+                       exp.get("action"), f)
+
+    elif kind == "fleet_report":
+        # north-star receipt — drives the real cmd_fleet code path
+        import argparse
+        import tempfile
+
+        import yaml as _yaml
+
+        from platformforge.cli.fleetcmd import cmd_fleet
+        with tempfile.TemporaryDirectory() as td:
+            for name, blob in data.items():
+                (Path(td) / f"{name}.yaml").write_text(
+                    _yaml.safe_dump(blob))
+            ns = argparse.Namespace(
+                fleet_cmd="report", path=td, question="", window="",
+                limit=expect.get("limit", 5), id="", out="", format="json")
+            r = cmd_fleet(ns)
+        out["result"] = r
+        _expect_min("invest_next", len(r.get("invest_next", [])),
+                    expect.get("min_invest"), f)
+        _expect_min("suppressed", r.get("portfolio", {}).get("suppressed"),
+                    expect.get("min_suppressed"), f)
+        for dim in expect.get("dimensions", []):
+            if dim not in r.get("dimensions", {}):
+                f.append(f"dimension missing: {dim}")
+        if expect.get("invest_cited", True):
+            for item in r.get("invest_next", []):
+                if not item.get("evidence"):
+                    f.append(f"uncited invest item: "
+                             f"{item.get('recommendation_id')}")
+        if expect.get("coverage_below") is not None and \
+                r.get("coverage", {}).get("min_member", 1) >= \
+                expect["coverage_below"]:
+            f.append("coverage not bounded as expected: "
+                     f"{r.get('coverage')}")
+
+    elif kind == "ai":
+        from platformforge.aiplat.models import ai_unit_economics, detect_ai_workloads
+        w = detect_ai_workloads(capacity.get("k8s_resources", []))
+        _expect_min("ai_workloads", len(w), expect.get("min_detected"), f)
+        if "unit_economics" in expect:
+            ue = ai_unit_economics(
+                expect["unit_economics"].get("cost"),
+                tokens=expect["unit_economics"].get("tokens"))
+            _expect_eq("cost/token", ue.get("cost_per_1m_tokens",
+                                            ue.get("tokens_metric")),
+                       expect["unit_economics"].get("expect"), f)
+            out["ue"] = ue
+        out["result"] = w
+
+    else:
+        f.append(f"unknown check kind: {kind}")
+    return out

platformforge/lab/opslab.py

@@ -0,0 +1,271 @@
+"""Cycle 4 phase T — Forge Lab V4 operations scenarios.
+
+An ops scenario drives the governed pipeline end to end with scripted
+transports — no real mutation. `ops.yaml` in the fixture declares the
+intent, plan steps, policies, approvals, observation, transport stubs
+and the expected terminal state/refusal:
+
+    detect → intent → plan → simulate → risk → policy → approve →
+    envelope → execute(dry-or-scripted) → verify → converge/rollback
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import yaml
+
+from platformforge.ops.approval import Approval, BreakGlass
+from platformforge.ops.engine import assess_risk, decide, execute, finalize_verify, mint_envelope
+from platformforge.ops.engine import plan as mkplan
+from platformforge.ops.models import ChangeIntent, ExpectedDelta, PlanStep, Reason
+from platformforge.ops.operation import LockTable, Operation, OperationLedger
+from platformforge.ops.policy import Policy
+from platformforge.ops.rollback import derive_rollback
+from platformforge.ops.simulate import simulate
+
+
+def _stub_transport(rc: int = 0, stdout: str = "ok", stderr: str = ""):
+    calls: list[list[str]] = []
+
+    def t(argv, cwd=None, timeout_s=None):
+        calls.append(list(argv))
+        return rc, stdout, stderr
+    t.calls = calls
+    return t
+
+
+def run_ops_scenario(fixture_dir) -> dict[str, Any]:
+    from pathlib import Path
+    fx = Path(fixture_dir)
+    doc = yaml.safe_load((fx / "ops.yaml").read_text())
+    checks: list[str] = []
+    failures: list[str] = []
+
+    i = doc["intent"]
+    intent = ChangeIntent(
+        intent_id=i.get("intent_id", "lab-intent"),
+        owner=i.get("owner", "lab"), requested_by=i.get("requested_by", "lab"),
+        reason=Reason(**i.get("reason", {"type": "manual"})),
+        target_resources=list(i.get("target_resources", [])),
+        desired_change=dict(i.get("desired_change", {})))
+
+    for s in doc.get("steps", []):
+        prm = s.get("params") or {}
+        wd = prm.get("workdir")
+        if isinstance(wd, str) and wd and not Path(wd).is_absolute():
+            prm["workdir"] = str((fx / wd).resolve())
+
+    steps = [PlanStep(step_id=s["step_id"], action=s["action"],
+                      params=dict(s.get("params", {})))
+             for s in doc.get("steps", [])]
+    ed = doc.get("expected_delta") or {}
+    plan = mkplan(intent,
+                  steps=steps,
+                  expected_delta=ExpectedDelta(
+                      adds=ed.get("adds", {}),
+                      removes=ed.get("removes", {}),
+                      changes=ed.get("changes", {})))
+    checks.append("plan.built")
+
+    # simulate
+    sim = simulate(plan, level=doc.get("simulation_level", "S1"))
+    checks.append(f"simulate:{sim.outcome}")
+
+    # rollback — status feeds the risk ceiling (cycle 4.1 §F)
+    rb = derive_rollback([{"step_id": s.get("step_id"),
+                           "action": s["action"],
+                           "params": dict(s.get("params", {}))}
+                          for s in doc.get("steps", [])],
+                         {"environment": doc.get("environment", "lab"),
+                          "automatic_allowed": doc.get(
+                              "auto_rollback", False)})
+    risk = assess_risk(
+        plan, {"environment": doc.get("environment", "lab")},
+        rollback_status=rb.status)
+    checks.append(f"risk:{risk['risk_class']}")
+
+    # policy
+    policies = [Policy(**p) for p in doc.get("policies", [])]
+    decisions = [decide(plan, policies,
+                        {"environment": doc.get("environment", "lab"),
+                         "risk_class": risk["risk_class"]})] \
+        if policies else []
+    checks.append("policy:" + ",".join(d.decision for d in decisions)
+                  if decisions else "policy:none")
+    checks.append(f"rollback:{rb.strategy}/{rb.status}")
+
+    # envelope
+    env = mint_envelope(plan, execution_id="lab-ex",
+                        decisions=decisions or [_allow_all()],
+                        approvals=[], risk=risk, rollback=rb)
+    if isinstance(env, dict):
+        result = {"ok": False, "stage": "mint",
+                  "refusal": env}
+        return _check_expect(doc, result, checks, failures)
+
+    # approvals
+    env_hash = env.freeze()
+    approvals = []
+    for a in doc.get("approvals", []):
+        sh = {"envelope": env_hash, "plan": plan.hash()}.get(
+            a.get("binds", "envelope"), a.get("binds", ""))
+        approvals.append(Approval(
+            approval_id=a.get("approval_id", "ap"),
+            subject_hash=sh,
+            scope=list(a.get("scope", env.scope)),
+            actor=a.get("actor", "approver"),
+            role=a.get("role", "owner"),
+            expires_at=a.get("expires_at", ""),
+            type=a.get("type", ""),
+            actor_kind=a.get("actor_kind", "human")))
+    bg = None
+    if doc.get("break_glass"):
+        b = doc["break_glass"]
+        bg = BreakGlass(break_glass_id=b.get("ticket_id", "BG-1"),
+                        actor=b.get("actor", "oncall"),
+                        invocation_reason=b.get("reason", ""),
+                        scope=list(b.get("scope", env.scope)),
+                        expires_at=b.get("expires_at", ""))
+
+    # transports
+    transports = {}
+    for name, stub in (doc.get("transports") or {}).items():
+        transports[name] = _stub_transport(
+            rc=stub.get("rc", 0), stdout=stub.get("stdout", "ok"))
+
+    # conflicting op
+    locks = LockTable()
+    ledger = OperationLedger()
+    op = Operation(operation_id="lab-op", intent_id=intent.intent_id,
+                   resources=list(env.scope))
+    if doc.get("conflicting_operation"):
+        other = Operation(operation_id="other",
+                          resources=list(env.scope))
+        locks.acquire(other.resources, "other")
+
+    result = execute(op, env, approvals=approvals,
+                     transports=transports, ledger=ledger,
+                     locks=locks, dry_run=doc.get("dry_run", True),
+                     break_glass=bg,
+                     preconditions={
+                         "observation": doc.get("observation"),
+                         "pre_state": doc.get("pre_state"),
+                         "sot": doc.get("sot"),
+                         "current_plan_hash":
+                             doc.get("current_plan_hash",
+                                     env.change_plan_hash),
+                         "policy_decision": (decisions[0].decision
+                                             if decisions else "allow"),
+                         "environment": doc.get("environment", "lab"),
+                         "maintenance_window":
+                             doc.get("maintenance_window"),
+                         "freeze_active": doc.get("freeze_active",
+                                                  False),
+                         "automatic_rollback": doc.get(
+                             "auto_rollback", False)})
+
+    # verify stage if execution passed
+    if result.get("ok") and doc.get("verify"):
+        v = doc["verify"]
+        from platformforge.ops.verify import verify as do_verify
+        vr = do_verify(expected_delta=ed,
+                       observations=v.get("observations", {}),
+                       slo_contract=v.get("slo"),
+                       metrics=v.get("metrics"),
+                       mutating=any(s.get("mutating", True)
+                                    for s in doc.get("steps", [])))
+        result["verify"] = vr.to_dict()
+        result["final"] = finalize_verify(
+            op, ledger, {"convergence": vr.convergence})
+        result["state"] = op.state
+        # rollback execution from the material-built plan (§30 pipeline;
+        # lab/non-prod §123). Auto-rollback needs `automatic`; a manual
+        # trigger (trigger_rollback: true) exercises the human-decided
+        # path for executable plans — and the honest refusal for
+        # non-executable ones.
+        if op.state == "rollback-planned":
+            rbp = result.get("rollback_plan") or env.rollback
+            auto = (rbp or {}).get("status") == "executable" and \
+                (rbp or {}).get("automatic")
+            manual = doc.get("trigger_rollback", False)
+            if auto or manual:
+                from platformforge.ops.engine import execute_rollback
+                result["rollback"] = execute_rollback(
+                    op, env, transports=transports, ledger=ledger,
+                    locks=locks,
+                    completed_results=result.get("results"),
+                    materials=result.get("materials"),
+                    rollback_plan=rbp,
+                    trigger={"type": "verification-failed",
+                             "observed_delta": ed},
+                    post_rollback_state=doc.get("post_rollback") or {},
+                    dry_run=doc.get("dry_run", True))
+                result["state"] = op.state
+
+    result["checks"] = checks
+    result["ledger_valid"] = ledger.verify_chain()
+    result["ledger_events"] = [e.event for e in ledger.entries]
+    return _check_expect(doc, result, checks, failures)
+
+
+def _allow_all():
+    from platformforge.ops.policy import PolicyDecision
+    return PolicyDecision(policy_id="lab-default", decision="allow",
+                          reason="lab default allow")
+
+
+def _check_expect(doc, result, checks, failures):
+    exp = doc.get("expect", {})
+    if "ok" in exp and result.get("ok") != exp["ok"]:
+        failures.append(f"expected ok={exp['ok']} got {result.get('ok')}")
+    if exp.get("stage") and result.get("stage") != exp["stage"]:
+        failures.append(f"stage: expected {exp['stage']} "
+                        f"got {result.get('stage')}")
+    if exp.get("state"):
+        got = result.get("state") or (result.get("final") or {}).get("state")
+        if got != exp["state"]:
+            failures.append(f"state: expected {exp['state']} got {got}")
+    if exp.get("refusal"):
+        ref = (result.get("refusal") or {})
+        want = exp["refusal"]
+        if ref.get("refusal") != want and want not in str(ref):
+            failures.append(f"refusal: expected {want} got {ref}")
+    if exp.get("convergence"):
+        got = (result.get("verify") or {}).get("convergence")
+        if got != exp["convergence"]:
+            failures.append(f"convergence: expected "
+                            f"{exp['convergence']} got {got}")
+    # cycle 4.1 §130–136 — rollback-aware expectations
+    rb_res = result.get("rollback") or {}
+    if exp.get("rollback_status"):
+        got = ((result.get("rollback_plan") or {}).get("status")
+               or rb_res.get("status"))
+        if got != exp["rollback_status"]:
+            failures.append(f"rollback_status: expected "
+                            f"{exp['rollback_status']} got {got}")
+    if exp.get("rollback_verification"):
+        got = rb_res.get("rollback_verification")
+        if got != exp["rollback_verification"]:
+            failures.append(f"rollback_verification: expected "
+                            f"{exp['rollback_verification']} got {got}")
+    if exp.get("rollback_refusal"):
+        ref = rb_res.get("refusal") or {}
+        want = exp["rollback_refusal"]
+        if ref.get("refusal") != want and want not in str(ref):
+            failures.append(f"rollback_refusal: expected {want} "
+                            f"got {ref}")
+    if exp.get("no_rollback") and rb_res:
+        failures.append("expected no rollback execution")
+    if exp.get("ledger_event") and exp["ledger_event"] not in (
+            result.get("ledger_events") or []):
+        failures.append(f"missing ledger event "
+                        f"{exp['ledger_event']}")
+    if not result.get("ledger_valid", True):
+        failures.append("ledger chain invalid")
+    return {"scenario": doc.get("name", "ops-scenario"),
+            "passed": not failures, "failures": failures,
+            "checks": checks,
+            "result": {k: v for k, v in result.items()
+                       if k in ("ok", "stage", "state", "refusal",
+                                "convergence", "dry_run")}}