evalrx 0.1.2__py3-none-any.whl

evalrx/analysis/prompts/stats_agent.py

@@ -0,0 +1,72 @@
+"""Prompt templates for M2 statistical analysis."""
+
+_ANALYSIS_PROMPT = """\
+You are an expert in ML failure analysis for vision-language models and agentic systems.
+
+Experiment protocol:
+{protocol_text}
+
+Task domain: {task_domain}
+
+Analyzer summary:
+{narrative}
+
+Raw per-analyzer findings (JSON):
+{findings_json}
+
+WHO READS THIS: an engineer who builds and runs evaluations but does not do
+statistics. They know what a benchmark, a prompt and a failure case are. They
+have never met an e-value, a McNemar test, a bootstrap interval or a
+Benjamini-Hochberg correction, and they will not go and look them up.
+
+HOW TO WRITE FOR THEM:
+- Answer first. The opening sentence says what is going wrong, in ordinary
+  words. Numbers, mechanism and caveats all come after it.
+- A bare number tells this reader nothing. Give the count AND what it amounts
+  to: "the model got 45 of the 125 wrong, and almost all of those were lists
+  longer than eight words" — not "fail rate 0.36, effect +0.28".
+- Prefer counts to rates, and give both when you have them ("24 of 30 cases,
+  80%"). For a comparison, name both groups and how many cases each holds.
+- If a statistical term really is the clearest word, define it in the same
+  sentence the first time it appears: "an e-value of 45 — the evidence runs
+  about 45 to 1 against this being chance". Never leave one standing bare.
+- Never make a bare metric identifier the subject of a sentence. Say what it
+  measures, then put the identifier in parentheses if the reader needs the
+  handle: "how often the model answered Yes (answer_extraction_audit.answered_yes)".
+- No symbols standing in for words (→, ρ, σ), and no "p<0.05" shorthand.
+- These are patterns on the analysis split, not proven causes. Write "shows up
+  more often on" or "is linked with", never "causes" or "explains", unless an
+  intervention actually tested it.
+
+Based on the protocol and the findings above, write:
+
+CONCLUSION: <one paragraph. FIRST sentence: what is going wrong, in plain words,
+  no numbers. Then the evidence for it, with counts. Then what this evidence
+  does NOT settle. If the model looks healthy given the protocol, say that
+  plainly in the first sentence.>
+EVIDENCE_CHAIN:
+- <step 1: which measurement first caught your attention — say what it measures
+  in words, not just its identifier — and why it stood out>
+- <step 2: how it connects to the protocol's stated failure patterns>
+- <step 3: any corroborating or contradicting signals from other analyzers>
+QUALITATIVE:
+- <observation 1: a pattern not captured by numbers alone>
+- <observation 2: anything unexpected or surprising>
+
+Keep each bullet to one sentence."""
+
+_TOOL_SELECT_PROMPT = """\
+You are selecting statistical tools to test why a model fails, given the data on hand.
+
+Experiment protocol:
+{protocol_text}
+
+Available statistical tools:
+{tool_catalog}
+
+Data shape available for testing:
+{data_shape}
+
+Pick the tools whose data requirements are satisfied and that best test the \
+protocol's question. Return ONLY a JSON object, no other text:
+{{"tools": ["name1", "name2", ...], "rationale": "one sentence"}}"""

evalrx/analysis/prompts/stats_tool_generator.py

@@ -0,0 +1,43 @@
+"""Prompt templates for generated code-writing stages."""
+
+from __future__ import annotations
+
+_INPUT_FILENAME = "m2_stats_input.json"
+_RESULT_MARKER = "STATS_RESULT_JSON="
+
+_GENERATE_PROMPT = """\
+You are writing a self-contained Python statistics script for a model-failure analysis.
+
+GOAL (what statistic to compute):
+{need}
+
+DATA: a JSON file named "{input_filename}" sits in the current working directory with:
+{{
+  "labels":   {{case_id: is_fail_bool}},          # PASS/FAIL labels
+  "per_case": {{"analyzer.metric": {{case_id: value}}}},  # per-case signals
+  "scalars":  {{"analyzer.metric": value}},         # aggregate metrics
+  "groups":   {{strategy: {{case_id: success}}}} or null  # strategy comparison
+}}
+
+Data shape available for THIS run:
+{data_shape}
+
+REQUIREMENTS:
+- Read "{input_filename}" from the current directory. Do NOT hardcode the data.
+- You MAY `import numpy`. No network, no file writes, no other I/O.
+- You decide WHAT statistic to compute, but you do NOT adjudicate significance.
+  Do NOT emit a "reject", "e_value", or "p_value" verdict — the HOST recomputes
+  the decision from your SUFFICIENT STATISTICS with its validated,
+  multiplicity-aware core; a self-declared verdict is ignored.
+- The LAST line of stdout MUST be exactly one line of the form:
+  {marker}{{"summary": "<one sentence>", "effect": <number or null>, "ci": [lo, hi] or null, "underpowered": <true/false>, "details": {{}}, "sufficient": <a SUFFICIENT-STATISTICS object or null>}}
+- "sufficient" must be ONE of these host-adjudicable shapes:
+    {{"kind": "paired_binary", "b": <int: #cases that flipped the GOOD way>, "c": <int: #cases that flipped the BAD way>}}
+    {{"kind": "two_group", "a": [0/1, ...], "b": [0/1, ...]}}   # two independent success/indicator vectors (e.g. is_fail among signal-absent vs signal-present)
+  If your statistic cannot be expressed as one of these, set "sufficient": null —
+  your tool is then DESCRIPTIVE (it reports effect/CI but can never claim a
+  rejection). Choose the shape that captures your test; the host owns the verdict.
+- Print NOTHING after that line. Keep the script under ~60 lines.
+
+Return ONLY the Python code{fences_hint}."""
+

evalrx/analysis/result_marker.py

@@ -0,0 +1,47 @@
+"""Shared parser for ``<MARKER>=<json>`` result lines printed by agent-written scripts.
+
+The explorer (``EXPLORATORY_RESULT_JSON=``) and the M2 stats-tool generator
+(``STATS_RESULT_JSON=``) both ask the generated Python to print its result as
+one JSON object after a fixed marker. The original parsers read only the
+remainder of the marker LINE, so ``print(f"MARKER={json.dumps(obj, indent=2)}")``
+— a perfectly valid object that merely spans several lines — parsed as ``{`` and
+failed (qwen3.5-2b / gsm8k, 2026-08-27: three explorer attempts in a row, the
+report lost). The marker is the contract; the line break is not.
+
+:func:`extract_marker_json` therefore decodes from the LAST marker to wherever
+the JSON value ends (``json.JSONDecoder.raw_decode``), so single-line,
+pretty-printed and trailing-noise outputs all read the same object.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+def extract_marker_json(stdout: str, marker: str) -> tuple[Any, str]:
+    """Return ``(value, "")`` for the JSON value that follows the last *marker*
+    line in *stdout*, or ``(None, error)`` when there is none / it is invalid.
+
+    The marker must start a line (after whitespace); the value may continue on
+    the following lines and may be followed by unrelated output. When the
+    marker appears more than once the last occurrence wins, matching the
+    line-oriented behaviour these parsers always had.
+    """
+    start = -1
+    pos = 0
+    for line in stdout.splitlines(keepends=True):
+        stripped = line.lstrip()
+        if stripped.startswith(marker):
+            start = pos + (len(line) - len(stripped)) + len(marker)
+        pos += len(line)
+    if start < 0:
+        return None, f"no {marker} line in output"
+    payload = stdout[start:].lstrip()
+    if not payload:
+        return None, f"empty {marker} payload"
+    try:
+        value, _end = json.JSONDecoder().raw_decode(payload)
+    except json.JSONDecodeError as exc:
+        return None, f"unparseable {marker} JSON: {exc}"
+    return value, ""

evalrx/analysis/run_codebase.py

@@ -0,0 +1,242 @@
+"""Run a user's existing evaluation codebase and feed its results into
+exploratory analysis.
+
+``run_codebase()`` bridges the run infrastructure (:mod:`evalrx.agent_runtime`)
+and the analysis entry (:func:`evalrx.analysis.api.explore`): given a
+path to a codebase, a CLI coding agent runs it inside an isolated copy,
+harvests the per-case records it produces, and (by default) hands them
+straight to ``explore()``.
+
+Flow::
+
+    run_codebase(path)
+      -> copy repo into an isolated workspace (the original is never touched)
+      -> CodegenRunner.run(prompt)     # the agent runs the eval in-place
+      -> harvest workspace/records.json (one repair turn if empty/missing)
+      -> explore(records)              # M2 + M3, unchanged
+
+``run_codebase_cli`` is the CLI-facing counterpart: same pipeline, prints a
+summary and optionally opens the dashboard.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from evalrx.agent_runtime.cli_types import CliAgentConfig
+from evalrx.agent_runtime.codegen.runner import CodegenRunner
+from evalrx.analysis.api import ExploreRunResult, explore
+from evalrx.analysis.explorer import RECORDS_FILENAME, load_records_from_path
+from evalrx.analysis.prompts.run_codebase import REPAIR_PROMPT_TEMPLATE, RUN_PROMPT_TEMPLATE
+
+_IGNORE_DIR_NAMES = {".git", "__pycache__", "node_modules", ".venv", "venv", ".mypy_cache", ".pytest_cache"}
+_HARVEST_MAX_ROWS = 20_000
+
+
+@dataclass
+class CodebaseRunResult:
+    """Outcome of one :func:`run_codebase` call."""
+
+    records: list[dict[str, Any]] = field(default_factory=list)
+    records_path: Path | None = None
+    workspace: Path | None = None
+    ran_ok: bool = False
+    explore: ExploreRunResult | None = None
+    error: str | None = None
+    audit: dict | None = None
+
+
+def _copy_ignore(_dir: str, names: list[str]) -> set[str]:
+    return {n for n in names if n in _IGNORE_DIR_NAMES}
+
+
+def _harvest(workspace: Path, records_name: str) -> list[dict[str, Any]]:
+    target = workspace / records_name
+    if not target.exists():
+        return []
+    return load_records_from_path(target, max_rows=_HARVEST_MAX_ROWS, max_files=1)
+
+
+def run_codebase(
+    path: "str | Path",
+    *,
+    out: "str | Path | None" = None,
+    analyze: bool = True,
+    provider: str = "claude_code",
+    model: str = "",
+    binary: str = "",
+    outcome_col: str | None = None,
+    records_name: str = RECORDS_FILENAME,
+    timeout_sec: int = 1200,
+    max_attempts: int = 2,
+    question: str = "Explore this dataset and surface the patterns that matter.",
+    progress_sink: Any = None,
+    **explore_kwargs: Any,
+) -> CodebaseRunResult:
+    """Run a user's evaluation codebase at *path* and analyze its results.
+
+    A CLI coding agent (*provider*) runs inside an isolated copy of *path* —
+    the original directory is never modified — and is instructed to produce
+    *records_name* (default ``"records.json"``, a JSON array or JSON-Lines
+    file with one row per evaluation case, each carrying a ``label`` plus
+    input/prediction/target fields). Those records are then handed to
+    :func:`evalrx.analysis.api.explore` (M2 + M3) unless *analyze* is
+    False.
+
+    When *out* is given, the workspace lives under ``out/workspace`` and is
+    kept on disk (harvested records plus explore artifacts are persisted
+    there too), which is useful for inspecting what the agent did — including
+    after a failed run. Without *out* everything runs in a temporary
+    directory that is removed before returning; only the returned
+    :class:`CodebaseRunResult` carries the records in memory.
+    """
+    src = Path(path).resolve()
+    if not src.exists():
+        return CodebaseRunResult(error=f"path does not exist: {src}")
+
+    out_dir = Path(out).resolve() if out is not None else None
+    cleanup: tempfile.TemporaryDirectory | None = None
+    if out_dir is not None:
+        out_dir.mkdir(parents=True, exist_ok=True)
+        workspace = out_dir / "workspace"
+        if workspace.exists():
+            shutil.rmtree(workspace)
+    else:
+        cleanup = tempfile.TemporaryDirectory(prefix="evalrx_run_codebase_")
+        workspace = Path(cleanup.name) / "workspace"
+    shutil.copytree(src, workspace, ignore=_copy_ignore)
+
+    cli_config = CliAgentConfig(provider=provider, binary_path=binary, model=model, timeout_sec=timeout_sec)
+    runner = CodegenRunner(cli_config)
+
+    if progress_sink is not None:
+        progress_sink.emit("run", "started", f"Running codebase at {src}")
+
+    prompt = RUN_PROMPT_TEMPLATE.format(records_name=records_name, question=question)
+    result = runner.run(prompt, workdir=workspace, timeout_sec=timeout_sec)
+    audit = result.audit
+    records = _harvest(workspace, records_name)
+
+    attempts = 1
+    while not records and attempts < max_attempts:
+        reason = result.error or "no records found"
+        repair_prompt = REPAIR_PROMPT_TEMPLATE.format(records_name=records_name, reason=reason)
+        result = runner.run(repair_prompt, workdir=workspace, timeout_sec=timeout_sec)
+        audit = result.audit or audit
+        records = _harvest(workspace, records_name)
+        attempts += 1
+
+    if not records:
+        error = result.error or f"the coding agent did not produce '{records_name}'"
+        if progress_sink is not None:
+            progress_sink.emit("run", "failed", error)
+        if cleanup is not None:
+            cleanup.cleanup()
+        return CodebaseRunResult(workspace=workspace, ran_ok=False, error=error, audit=audit)
+
+    if progress_sink is not None:
+        progress_sink.emit("run", "completed", f"Harvested {len(records)} record(s)")
+
+    run_result = CodebaseRunResult(
+        records=records,
+        records_path=workspace / records_name,
+        workspace=workspace,
+        ran_ok=True,
+        audit=audit,
+    )
+
+    if analyze:
+        run_result.explore = explore(
+            records,
+            question=question,
+            out=out_dir,
+            provider=provider,
+            model=model,
+            binary=binary,
+            outcome_col=outcome_col,
+            progress_sink=progress_sink,
+            **explore_kwargs,
+        )
+
+    if out_dir is not None:
+        (out_dir / records_name).write_text(json.dumps(records, default=str), encoding="utf-8")
+    if cleanup is not None:
+        cleanup.cleanup()
+
+    return run_result
+
+
+def run_codebase_cli(
+    path: "str | Path",
+    *,
+    out: "str | Path" = "evalrx_run_codebase_output",
+    coder_provider: str = "claude_code",
+    coder_model: str = "",
+    coder_binary: str = "",
+    outcome_col: str | None = None,
+    records_name: str = RECORDS_FILENAME,
+    timeout_sec: int = 1200,
+    max_attempts: int = 2,
+    question: str = "Explore this dataset and surface the patterns that matter.",
+    analyze: bool = True,
+    dashboard: bool = False,
+    dashboard_port: int | None = None,
+    progress_sink: Any = None,
+) -> int:
+    """Run *path* and persist its harvested records + explore artifacts under *out*.
+
+    Prints a short summary and returns a process exit code: ``0`` if records
+    were harvested (and, when *analyze*, the exploration succeeded), else
+    ``1``. When *dashboard* is set, the return value is the dashboard
+    process's code instead.
+    """
+    out_dir = Path(out).resolve()
+    result = run_codebase(
+        path,
+        out=out_dir,
+        analyze=analyze,
+        provider=coder_provider,
+        model=coder_model,
+        binary=coder_binary,
+        outcome_col=outcome_col,
+        records_name=records_name,
+        timeout_sec=timeout_sec,
+        max_attempts=max_attempts,
+        question=question,
+        progress_sink=progress_sink,
+    )
+
+    print(f"ran_ok: {result.ran_ok}")
+    print(f"records harvested: {len(result.records)}")
+    print(f"output: {out_dir}")
+    if result.error:
+        print(f"error: {result.error}")
+    if result.explore is not None:
+        report = result.explore.report
+        print(f"explore ok: {report.ok}")
+        if report.hypotheses:
+            print("\nhypotheses (M3, proposed only — not validated):")
+            for h in report.hypotheses[:8]:
+                print(f"- {h.get('statement')}")
+        if report.observations:
+            print("\nobservations:")
+            for obs in report.observations[:8]:
+                print(f"- {obs}")
+
+    ok = result.ran_ok and (result.explore is None or result.explore.ok)
+
+    if ok:
+        from evalrx.reporting.html_report import build_html_report
+
+        build_html_report(out_dir, out_path=out_dir / "report.html")
+
+    if dashboard:
+        from evalrx.analysis.dashboard import launch_dashboard
+
+        return launch_dashboard(out_dir, port=dashboard_port)
+    return 0 if ok else 1

evalrx/analysis/run_view.py

@@ -0,0 +1,205 @@
+"""Normalized, UI-facing representation of an EvalRX run.
+
+The persisted formats predate the web workbench and intentionally differ:
+``exploratory_report.json`` is a finished M2/M3 artifact, while a diagnostic
+loop is an event stream.  Rendering either format directly made the UI grow
+two incompatible information architectures.  This module is the compatibility
+boundary: readers turn either source into the small, stable model the UI uses.
+
+It deliberately does *not* replace the wire contract.  New producers should
+write the contract; these adapters keep existing report bundles and
+``run.json``/``M<n>/log.json`` run directories readable during that migration.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any, Literal
+
+
+class _StrEnum(str, Enum):
+    """``enum.StrEnum`` for the Python floor this package declares.
+
+    ``StrEnum`` is 3.11+, and ``pyproject.toml`` says ``requires-python >=3.10``
+    with 3.10 in the CI matrix — so importing it here broke collection of this
+    module, and of its tests, on the oldest version we claim to support.
+
+    ``(str, Enum)`` is what the rest of the codebase already uses
+    (:class:`evalrx.core.case.Label`); the explicit ``__str__`` is what
+    keeps it interchangeable, since plain ``(str, Enum)`` formats as
+    ``StageId.M1`` where ``StrEnum`` formats as ``M1``.
+    """
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+
+class StageId(_StrEnum):
+    """Pipeline identifiers retained for auditability, not navigation order."""
+
+    M1 = "M1"
+    M2 = "M2"
+    M3 = "M3"
+    M4 = "M4"
+    M5 = "M5"
+
+
+class StageState(_StrEnum):
+    """Reader-visible stage state; absence is distinct from an empty result."""
+
+    NOT_STARTED = "not_started"
+    RUNNING = "running"
+    SUCCEEDED = "succeeded"
+    EMPTY = "empty"
+    PARTIAL = "partial"
+    FAILED = "failed"
+    UNAVAILABLE = "unavailable"
+
+
+@dataclass(frozen=True)
+class StageView:
+    id: StageId
+    label: str
+    state: StageState
+    count: int | None = None
+    detail: str = ""
+
+
+@dataclass
+class RunView:
+    """One source-independent run consumed by the unified web shell."""
+
+    kind: Literal["explore", "diagnostic", "casebench", "empty"]
+    root: Path
+    title: str
+    stages: list[StageView]
+    report: dict[str, Any] | None = None
+    confirm: dict[str, Any] | None = None
+    fix_report: dict[str, Any] | None = None
+    story: dict[str, Any] | None = None
+    case_studies: list[Any] = field(default_factory=list)
+
+    @property
+    def is_diagnostic(self) -> bool:
+        return self.kind in {"diagnostic", "casebench"}
+
+    def stage(self, stage_id: StageId) -> StageView:
+        return next(s for s in self.stages if s.id == stage_id)
+
+
+_STAGE_LABELS = {
+    StageId.M1: "Measure",
+    StageId.M2: "Explore evidence",
+    StageId.M3: "Explain hypotheses",
+    # M4 precedes M5 in the actual current loop.  The UI uses this action
+    # order rather than implying the numeric labels are execution order.
+    StageId.M4: "Validate hypotheses",
+    StageId.M5: "Intervene & repair",
+}
+
+
+def _stages(states: dict[StageId, tuple[StageState, int | None, str]]) -> list[StageView]:
+    return [
+        StageView(stage_id, _STAGE_LABELS[stage_id], *states[stage_id])
+        for stage_id in StageId
+    ]
+
+
+def _sibling_json(root: Path, name: str) -> dict[str, Any] | None:
+    import json
+
+    try:
+        value = json.loads((root / name).read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return value if isinstance(value, dict) else None
+
+
+def from_session(session: dict[str, Any]) -> RunView:
+    """Adapt the dict returned by :func:`dashboard.load_run`.
+
+    Keeping the adapter dependent on the public loader result, rather than on
+    paths or event parsing, makes it usable by both ``dashboard`` and ``web``.
+    """
+
+    root = Path(str(session.get("root") or ".")).resolve()
+    kind = str(session.get("kind") or "empty")
+    if kind == "loop":
+        return _from_loop(root, session.get("story") or {})
+    if kind == "casebench":
+        studies = list(session.get("case_studies") or [])
+        title = getattr(studies[0], "name", root.name) if studies else root.name
+        ready = StageState.SUCCEEDED if studies else StageState.EMPTY
+        return RunView(
+            kind="casebench", root=root, title=str(title), case_studies=studies,
+            stages=_stages({stage: (ready if stage is StageId.M1 else StageState.UNAVAILABLE, None, "")
+                            for stage in StageId}),
+        )
+    runs = list(session.get("runs") or [])
+    if runs:
+        turn = runs[0]
+        report = turn.get("report") if isinstance(turn, dict) else None
+        artifact_dir = Path(str(turn.get("dir") or root)) if isinstance(turn, dict) else root
+        return _from_explore(root, artifact_dir, report if isinstance(report, dict) else {})
+    return RunView(
+        kind="empty", root=root, title=root.name,
+        stages=_stages({stage: (StageState.UNAVAILABLE, None, "No readable run artifact.") for stage in StageId}),
+    )
+
+
+def _from_explore(root: Path, artifact_dir: Path, report: dict[str, Any]) -> RunView:
+    confirm = _sibling_json(artifact_dir, "confirm_report.json")
+    fix_report = _sibling_json(artifact_dir, "fix_report.json")
+    ok = bool(report.get("ok", True))
+    m2 = StageState.SUCCEEDED if ok else StageState.FAILED
+    hypotheses = [h for h in report.get("hypotheses") or [] if isinstance(h, dict)]
+    m3 = StageState.SUCCEEDED if hypotheses else StageState.EMPTY
+    records = report.get("data_profile") or {}
+    has_measurement = bool(records or (artifact_dir / "records.json").exists())
+    title = str(report.get("plain_question") or report.get("question") or root.name)
+    states = {
+        StageId.M1: (StageState.SUCCEEDED if has_measurement else StageState.UNAVAILABLE, None,
+                     "Normalized input records" if has_measurement else "No per-case measurement artifact."),
+        StageId.M2: (m2, len(report.get("takeaways") or []), "Exploratory report"),
+        StageId.M3: (m3, len(hypotheses), "Falsifiable hypotheses"),
+        StageId.M4: (StageState.SUCCEEDED if confirm else StageState.NOT_STARTED,
+                     len((confirm or {}).get("hypothesis_verdicts") or []) if confirm else None,
+                     "Held-out validation" if confirm else "No held-out validation artifact."),
+        StageId.M5: (StageState.SUCCEEDED if fix_report else StageState.NOT_STARTED,
+                     len(((fix_report or {}).get("fix") or {}).get("attempted") or []) if fix_report else None,
+                     "Intervention and repair sweep" if fix_report else "No repair artifact."),
+    }
+    return RunView("explore", root, title, _stages(states), report, confirm, fix_report)
+
+
+def _from_loop(root: Path, story: dict[str, Any]) -> RunView:
+    probes = list(story.get("probes") or [])
+    analyses = list(story.get("analyses") or [])
+    diagnoses = list(story.get("diagnoses") or [])
+    surgeries = list(story.get("surgeries") or [])
+    fixes = list(story.get("fixes") or [])
+    lifecycle = story.get("run_start") or {}
+    stored_name = root.parent.name if root.name.lower() in {"output", "outputs", "results", "run"} else root.name
+    title = str(lifecycle.get("protocol_description") or lifecycle.get("question") or stored_name)
+
+    def outcome(events: list[Any], detail: str) -> tuple[StageState, int | None, str]:
+        if not events:
+            return StageState.NOT_STARTED, None, detail
+        return StageState.SUCCEEDED, len(events), detail
+
+    m4 = [event for event in surgeries if str(event.get("module", "")).lower() == "m4"]
+    m5 = [event for event in surgeries if str(event.get("module", "")).lower() == "m5"]
+    # A legacy/post-loop ``fix`` event is semantically M5 even when it does
+    # not carry an explicit m5 module tag.
+    m5_count = len(m5) + len(fixes)
+    states = {
+        StageId.M1: outcome(probes, "Analyzer measurements"),
+        StageId.M2: outcome(analyses, "Evidence screening"),
+        StageId.M3: outcome(diagnoses, "Mechanism hypotheses"),
+        StageId.M4: outcome(m4, "Hypothesis validation"),
+        StageId.M5: (StageState.SUCCEEDED, m5_count, "Interventions and repair attempts")
+                    if m5_count else (StageState.NOT_STARTED, None, "No intervention or repair run."),
+    }
+    return RunView("diagnostic", root, title, _stages(states), story=story)