magi/

report.rs

//! Terminal rendering.
//!
//! A run produces a lot of state; the report exists so the operator can decide
//! what to do next without opening `run.json`. It leads with the disagreement,
//! because that is the part that carries information: three judges agreeing
//! tells you nothing the winner's diff does not.
//!
//! Colour is a six-line local implementation rather than a crate. The
//! alternatives all decide *for* you whether the stream supports colour, which
//! makes the output untestable — `assert!(text.contains("winner  A"))` fails on
//! an escape sequence the test never asked for.
use std::fmt::Write as _;
use std::sync::atomic::{AtomicBool, Ordering};

use crate::config::{MergeMode, MergeStyle};
use crate::run::{
    CommandOutcome, ContinuationOutcome, E2eStatus, GateStatus, JobStatus, Liveness,
    OperatorFixOutcome, RunState, RunStatus,
};
use crate::stats::{RepoStats, Stats};
use crate::verdict::ReviewVote;

static COLOR: AtomicBool = AtomicBool::new(true);

/// Turn colour on or off for every subsequent render.
pub fn set_color(on: bool) {
    COLOR.store(on, Ordering::Relaxed);
}

fn paint(text: &str, code: &str) -> String {
    if COLOR.load(Ordering::Relaxed) {
        format!("\x1b[{code}m{text}\x1b[0m")
    } else {
        text.to_owned()
    }
}

fn bold(t: &str) -> String {
    paint(t, "1")
}
fn dim(t: &str) -> String {
    paint(t, "2")
}
fn red(t: &str) -> String {
    paint(t, "31")
}
fn green(t: &str) -> String {
    paint(t, "32")
}
fn yellow(t: &str) -> String {
    paint(t, "33")
}
fn cyan(t: &str) -> String {
    paint(t, "36")
}

/// Colour for a status word.
///
/// `Stalled` is deliberately not green: a run whose judges were taken out by a
/// rate limit must not look like a healthy `Ready` in a one-line listing.
///
/// A `Ready` reached via `[merge] mode = "none"` is a second case that must
/// not look like a plain `Ready`: that run is done for good, never picked up
/// by the PR-polling merge watcher or anything else, while an ordinary
/// `Ready` (a PR closed without merging, an already-concluded re-entry) may
/// still be a live landing candidate. See [`RunState::unmerged_by_design`].
fn status_word(state: &RunState) -> String {
    if state.unmerged_by_design() {
        return cyan("unmerged (no-op by design)");
    }
    let text = state.status.display_label();
    if state.needs_attention() {
        return bold(&yellow(&format!("{text} - release needs a human")));
    }
    match state.status {
        RunStatus::Merged => bold(&green(text)),
        RunStatus::Ready => green(text),
        RunStatus::Stalled => bold(&yellow(text)),
        RunStatus::Blocked => yellow(text),
        RunStatus::Failed => red(text),
        // Not `Failed`'s red: every candidate agreed, with evidence, that
        // nothing belongs in this worktree — the opposite of a run that
        // could not do the work. See `RunStatus::VerifiedNoop`'s own doc.
        RunStatus::VerifiedNoop => cyan(text),
        // Muted, not `Blocked`'s yellow: nothing here needs a human's
        // attention any more, a later attempt already settled the task.
        RunStatus::Superseded => dim(text),
        // Neither green nor red: this run landed nothing, and nothing is
        // wrong - the change reached the base by another route.
        RunStatus::AlreadyInBase => dim(text),
        _ => cyan(text),
    }
}

/// Colour for a reviewer vote — the same scale a finding's severity gets:
/// green for no reservations, yellow for proceed-but-look-at-this, red for a
/// vote that says stop.
fn vote_tag(vote: ReviewVote) -> String {
    let text = vote.label();
    match vote {
        ReviewVote::Approve => green(text),
        ReviewVote::ApproveWithFindings => yellow(text),
        ReviewVote::Reject => red(text),
    }
}

/// One-line summary, for `magi list`.
pub fn line(state: &RunState) -> String {
    line_with_liveness(state, Liveness::Unknown)
}

/// [`line`] with the independent process-liveness observation available to
/// `magi list`.
pub fn line_with_liveness(state: &RunState, live: Liveness) -> String {
    let winner = state
        .tally
        .as_ref()
        .map_or("-".to_owned(), |t| t.winner.to_string());
    let agent = state.winner().map_or("-", |c| c.agent.as_str());
    // A below-quorum verdict carries an explicit stamp so a row in a listing
    // reads "stalled" and "2/3 judges" without opening the report.
    let quorum = match state.tally.as_ref() {
        Some(t) if !t.met_quorum => format!(
            "  {}",
            bold(&red(&format!("quorum {}/{}", t.present, t.judges)))
        ),
        Some(t) if t.present > 0 && t.present < t.judges => format!(
            "  {}",
            yellow(&format!("judges {}/{}", t.present, t.judges))
        ),
        _ => String::new(),
    };
    let stale = if !state.status.done() && live == Liveness::Dead {
        format!(
            "  {}",
            bold(&yellow("STALE — driver exited; resume required"))
        )
    } else {
        String::new()
    };
    // The full unknown wording is for `magi show`; a row only needs to say
    // there is no record.
    let origin = state
        .origin
        .as_ref()
        .map_or("origin unknown".to_owned(), crate::run::Origin::label);
    format!(
        "{}  {:<20}  {:>2}c {:>2}j  win {} ({}){quorum}{stale}  {}  {}",
        dim(&state.id),
        status_word(state),
        state.candidates.len(),
        state.judgements.len(),
        winner,
        agent,
        dim(&format!("[{origin}]")),
        first_line(&state.instruction)
    )
}

/// A plainly visible verdict for a non-terminal run whose recorded driver is
/// gone. Kept separate from [`active_seats`] because a process can die at a
/// node boundary with no active seat left in the saved state.
pub fn liveness_notice(state: &RunState, live: Liveness) -> String {
    if !state.status.done() && live == Liveness::Dead {
        format!(
            "{}\n\n",
            yellow("STALE — the process driving this run exited; resume it to continue.")
        )
    } else {
        String::new()
    }
}

/// A plainly visible note for a run a later attempt at the same task already
/// replaced — the terminal counterpart of the web UI's "Superseded by …"
/// line. `later` is the short id of that later attempt, or `None` when this
/// run is not superseded at all (the common case).
///
/// Kept as its own function, concatenated by the caller, rather than an
/// argument threaded through [`run`] itself: `run` is called from `bump.rs`,
/// `tui.rs` and every `magi show`/`magi list` path with no notion of "what
/// replaced this", and adding a parameter there would mean guessing `None`
/// at every one of those call sites instead of only at the one that knows.
pub fn superseded_notice(later: Option<&str>) -> String {
    match later {
        Some(later) => format!(
            "{}\n\n",
            yellow(&format!(
                "SUPERSEDED — a later attempt at this task ({later}) replaced it; this record \
                 is kept but is not the one to act on."
            ))
        ),
        None => String::new(),
    }
}

fn first_line(text: &str) -> String {
    let line = text.lines().next().unwrap_or_default();
    if line.chars().count() > 68 {
        format!("{}…", line.chars().take(67).collect::<String>())
    } else {
        line.to_owned()
    }
}

fn short(commit: &str) -> String {
    commit.chars().take(7).collect()
}

/// A short badge for a [`crate::run::ContinuationRecord`], distinguishing
/// "the seat's own report needed to be resumed" from "there was nothing to
/// address" — a fixer that has never needed this stays silent here, exactly
/// as a record predating the feature (`continuation: None`) does too.
fn continuation_note(c: &crate::run::ContinuationRecord) -> String {
    match c.outcome {
        ContinuationOutcome::NotNeeded => String::new(),
        ContinuationOutcome::Resumed => format!(" [resumed x{}]", c.attempts),
        ContinuationOutcome::Exhausted => format!(" [continuation exhausted x{}]", c.attempts),
        ContinuationOutcome::QuotaLost => " [continuation: quota]".to_owned(),
        ContinuationOutcome::NoSession => " [no session to resume]".to_owned(),
    }
}

/// Commands seats' own CLIs reported running, across every node — see
/// [`crate::run::JobRecord`]. Read-only: renders whatever `run.json` already
/// holds, does not query anything live and does not spawn an agent.
///
/// A CLI this crate has no adapter for (every backend but Codex, as of this
/// writing) never appears here at all — silence is "no evidence", not "no
/// jobs ran", which the trailing coverage line exists to say once rather
/// than per seat.
///
/// There is deliberately no "running" state anywhere in this. A command a
/// CLI never reported finishing has no way to be told apart from one that
/// never started at all: the CLI that would report it has, by construction,
/// already stopped talking (killed by a timeout, or a park) by the time that
/// question matters, so no event — real or guessed at — could ever answer
/// it. Guessing at an unconfirmed event shape to manufacture a "running"
/// entry is exactly the fabrication this feature must not do; recording that
/// limit instead is what the task asks for here. `magi show`'s own
/// seat-completion state ([`active_seats`]) still answers a related but
/// different question honestly — "has this seat's own turn answered yet" —
/// and stays the right place to look for that.
fn jobs_section(state: &RunState) -> String {
    let mut s = String::new();
    if state.jobs.is_empty() {
        // Not silent when it would matter: a run whose roster can actually
        // report this (Codex, today) but has not yet says so explicitly, so
        // "no adapter for this backend" and "nothing reported yet" are never
        // the same blank space to a reader.
        if state
            .config
            .agents
            .iter()
            .any(|a| a.kind == crate::config::AgentKind::Codex)
        {
            let _ = writeln!(
                s,
                "\n{}",
                dim(
                    "background jobs: no completed command evidence yet for this run (see \
                     active seats above for what is still mid-turn)"
                )
            );
        }
        return s;
    }
    let _ = writeln!(
        s,
        "\n{}",
        bold("background jobs (from each seat's own CLI)")
    );
    let mut by_seat: std::collections::BTreeMap<(&str, &str), Vec<&crate::run::JobRecord>> =
        std::collections::BTreeMap::new();
    for j in &state.jobs {
        by_seat
            .entry((j.node.as_str(), j.seat.as_str()))
            .or_default()
            .push(j);
    }
    for ((node, seat), records) in by_seat {
        let _ = writeln!(s, "  {node}/{seat}");
        for j in records {
            let status = match j.status {
                JobStatus::Completed => green("completed"),
                JobStatus::Failed => red("failed"),
                JobStatus::Unknown => yellow("unknown"),
            };
            let _ = writeln!(
                s,
                "    {} {}{}{}  checked {}",
                dim(&j.id),
                status,
                j.exit_code
                    .map_or(String::new(), |c| format!(" (exit {c})")),
                j.round.map_or(String::new(), |r| format!("  round {r}")),
                j.checked_at
                    .to_zoned(jiff::tz::TimeZone::system())
                    .strftime("%Y-%m-%d %H:%M:%S")
            );
            let desc = first_line(&j.description);
            if !desc.trim().is_empty() {
                let _ = writeln!(s, "      $ {desc}");
            }
            let summary = first_line(&j.result_summary);
            if !summary.trim().is_empty() {
                let _ = writeln!(s, "      {}", dim(&summary));
            }
        }
    }
    let _ = writeln!(
        s,
        "  {}",
        dim(
            "(adapter coverage: codex only today; other backends, and a command a CLI never \
             reported finishing, leave no entry here — that is unknown, never \"nothing ran\")"
        )
    );
    s
}

/// Full report for one run.
pub fn run(state: &RunState) -> String {
    let mut s = String::new();
    let _ = writeln!(
        s,
        "{} {}  {}",
        bold("magi run"),
        bold(&state.id),
        status_word(state)
    );
    let _ = writeln!(
        s,
        "  repo    {} ({} @ {})",
        state.repo.display(),
        state.base_branch,
        short(&state.base_commit)
    );
    let _ = writeln!(s, "  created {}", state.created_local());
    let _ = writeln!(s, "  task    {}", first_line(&state.instruction));
    let _ = writeln!(
        s,
        "  origin  {}",
        crate::run::origin_label(state.origin.as_ref())
    );
    let _ = writeln!(s, "  state   {}", state.dir().display());

    let _ = writeln!(s, "\n{}", bold("candidates"));
    for c in &state.candidates {
        let flag = match (&c.failed, c.empty, &c.verified_noop) {
            (Some(e), _, _) => red(&format!("failed: {e}")),
            // Neither red (nothing failed) nor plain yellow "no change" (that
            // reads as an unexplained loss): the candidate gave a reason a
            // human still has to check, not a claim magi itself confirmed.
            (None, true, Some(_)) => cyan("agent-verified no-op (unconfirmed)"),
            (None, true, None) => yellow("no change"),
            _ => format!("{} files, {} commits", c.files, c.commits),
        };
        let crown = if state.tally.as_ref().is_some_and(|t| t.winner == c.label) {
            bold(&green("  <- winner"))
        } else {
            String::new()
        };
        let _ = writeln!(
            s,
            "  {}  {:<12} {:<30} {:>5}s{}",
            bold(&c.label.to_string()),
            c.agent,
            flag,
            c.duration_ms / 1000,
            crown
        );
        if let Some(evidence) = &c.verified_noop {
            let _ = writeln!(s, "      {}", dim(&first_line(evidence)));
        } else if !c.summary.trim().is_empty() {
            // The candidate's own account of what it did and why — the
            // "## SUMMARY" `prompt::implement` asks for — was recorded on
            // every run but never surfaced here, which left `magi show`
            // silent about it even when the summary was the whole point (an
            // implementer explaining *why* it wrote nothing, short of a
            // verified no-op's own line above). One line, matching the
            // house style other prose fields get in this report (see the
            // review findings' `detail` below); the rest is in `run.json`.
            let _ = writeln!(s, "      {}", dim(&first_line(&c.summary)));
        }
    }

    if !state.judgements.is_empty() {
        let _ = writeln!(s, "\n{}", bold("blind judging"));
        for j in &state.judgements {
            match &j.failed {
                Some(e) => {
                    let _ = writeln!(
                        s,
                        "  judge {}  {}",
                        j.judge,
                        red(&format!("no ranking: {e}"))
                    );
                }
                None => {
                    let _ = writeln!(
                        s,
                        "  judge {}  {:<12} {}  confidence {}",
                        j.judge,
                        j.agent,
                        bold(&j.ranking.iter().collect::<String>()),
                        j.confidence.map_or("-".to_owned(), |c| c.to_string())
                    );
                }
            }
        }
    }

    if let Some(t) = &state.tally {
        if t.deliberated {
            let _ = writeln!(s, "\n{}", bold("deliberation"));
            for round in &state.deliberation {
                for turn in &round.turns {
                    let _ = writeln!(
                        s,
                        "  r{} judge {} -> {}",
                        round.round,
                        turn.judge,
                        turn.tentative.map_or("-".to_owned(), |c| c.to_string())
                    );
                }
            }
        }

        if !state.votes.is_empty() {
            let _ = writeln!(s, "\n{}", bold("final votes (collected privately)"));
            for v in &state.votes {
                let _ = writeln!(
                    s,
                    "  judge {}  {:<12} {}{}",
                    v.judge,
                    v.agent,
                    bold(&v.vote.unwrap_or('?').to_string()),
                    if v.changed {
                        yellow("  (changed after deliberation)")
                    } else {
                        String::new()
                    }
                );
            }
        }

        let _ = writeln!(s, "\n{}", bold("tally"));
        // A tally with no panel (`uncontested`) must not fall through the
        // judges/first-choice/after-votes lines below: they are written
        // unconditionally and every one of them reads, in the words a panel
        // that collapsed would also produce, as a run that lost its judges
        // rather than one that never needed them.
        match &t.uncontested {
            Some(reason) => {
                let _ = writeln!(
                    s,
                    "  judging       {}",
                    cyan(&format!("not needed — {reason}"))
                );
            }
            None => {
                let _ = writeln!(
                    s,
                    "  judges        {} present{}",
                    if t.met_quorum {
                        green(&format!("{}/{}", t.present, t.judges))
                    } else {
                        red(&format!("{}/{}", t.present, t.judges))
                    },
                    if t.quorum > 0 {
                        format!(" ({quorum} required)", quorum = t.quorum)
                    } else {
                        String::new()
                    }
                );
                if !t.met_quorum {
                    let _ = writeln!(
                        s,
                        "  {}",
                        bold(&red("BELOW QUORUM — verdict is not trustworthy"))
                    );
                }
                let _ = writeln!(
                    s,
                    "  first choice  {}",
                    t.first_choice
                        .iter()
                        .map(|(k, v)| format!("{k}:{v}"))
                        .collect::<Vec<_>>()
                        .join("  ")
                );
                let _ = writeln!(
                    s,
                    "  initial       {}",
                    match (t.rankings, t.unanimous_initial) {
                        (0, _) => red("no usable ranking"),
                        (1, _) => yellow("one usable ranking - not a consensus"),
                        (_, true) => green("unanimous"),
                        (_, false) => yellow("split"),
                    }
                );
                let _ = writeln!(
                    s,
                    "  after votes   {}  ({} judge(s) moved)",
                    if t.unanimous_final {
                        green("unanimous")
                    } else {
                        yellow("still split")
                    },
                    t.changed_votes
                );
                if let Some(tb) = &t.tie_break {
                    let _ = writeln!(s, "  tie break     {tb}");
                }
            }
        }
        if !state.quota.is_empty() {
            let _ = writeln!(
                s,
                "  unavailable   {}",
                state
                    .quota
                    .iter()
                    .map(|q| if q.cause == crate::agent::QuotaCause::Authentication {
                        format!("{} ({}: re-authenticate)", q.seat, q.agent)
                    } else {
                        format!("{} (usage limit)", q.seat)
                    })
                    .collect::<Vec<_>>()
                    .join(", ")
            );
        }
        let _ = writeln!(s, "  winner        {}", bold(&green(&t.winner.to_string())));
    }

    if !state.handovers.is_empty() {
        let _ = writeln!(s, "\n{}", bold("seats handed over"));
        for h in &state.handovers {
            let _ = writeln!(
                s,
                "  {} {}  {} -> {}  ({}: {})",
                yellow("~"),
                h.seat,
                h.from,
                h.to,
                h.node,
                h.reason
            );
        }
    }

    if !state.withheld.is_empty() {
        let _ = writeln!(s, "\n{}", bold("withheld from commit"));
        for w in &state.withheld {
            let _ = writeln!(
                s,
                "  {} {}  ({} lockfile; the directory uses {})",
                yellow("!"),
                w.path,
                w.manager,
                w.kept_by
            );
        }
    }

    if let Some(r) = &state.recovery {
        let _ = writeln!(s, "\n{}", bold("recovery"));
        let _ = writeln!(s, "  {}", r.summary());
        if r.criteria_inherited {
            let _ = writeln!(s, "  the task's own completion criteria were kept");
        }
        match &r.repair {
            crate::recovery::Repair::NotStarted => {}
            crate::recovery::Repair::WaitingForRestore { .. } => {
                let _ = writeln!(s, "  repair: waiting to restore and retry");
            }
            crate::recovery::Repair::Started { .. } => {
                let _ = writeln!(s, "  repair: {}", yellow("unfinished"));
            }
            crate::recovery::Repair::Done {
                committed, failed, ..
            } => {
                let _ = match failed {
                    Some(why) => writeln!(s, "  repair: {} {why}", yellow("nothing kept:")),
                    None if *committed => writeln!(s, "  repair: {}", green("committed")),
                    None => writeln!(s, "  repair: no commit"),
                };
            }
        }
    }

    if let Some(g) = &state.graft {
        let _ = writeln!(s, "\n{}", bold("graft"));
        let size = g.lines.map_or_else(
            || "  changed lines unavailable".to_owned(),
            |n| format!("  {n} changed lines"),
        );
        let _ = match &g.outcome {
            crate::run::GraftOutcome::Applied => writeln!(s, "  {}{size}", green("applied")),
            crate::run::GraftOutcome::WaitingForRestore => {
                writeln!(s, "  {}{size}", yellow("waiting to restore and retry"))
            }
            crate::run::GraftOutcome::Running => writeln!(s, "  {}{size}", yellow("unfinished")),
            crate::run::GraftOutcome::RolledBack(why) => {
                writeln!(s, "  {} {why}{size}", yellow("rolled back:"))
            }
        };
        if let Some(a) = &g.agent {
            let chain: Vec<String> = state
                .handovers
                .iter()
                .filter(|h| h.node == "graft")
                .map(|h| format!("{} -> {}", h.from, h.to))
                .collect();
            let via = if chain.is_empty() {
                String::new()
            } else {
                format!("  (handovers: {})", chain.join(", "))
            };
            let _ = writeln!(s, "  by {a}{via}");
        }
        if !g.requested.is_empty() {
            let view = crate::report_view::build(state, Liveness::Unknown);
            if let Some(crate::report_view::Section::Graft { graft, .. }) = view
                .sections
                .iter()
                .find(|x| matches!(x, crate::report_view::Section::Graft { .. }))
            {
                let _ = writeln!(
                    s,
                    "  requested {}  confirmed adopted {}  rejected {}  unconfirmed {}",
                    graft.requested.len(),
                    graft.adopted_count,
                    graft.rejected_count,
                    graft.unconfirmed_count
                );
            }
        }
        if let Some(n) = g
            .adoption
            .as_ref()
            .and_then(|a| a.notes.lines().find(|l| !l.trim().is_empty()))
        {
            let _ = writeln!(s, "  fixer notes: {}", n.trim());
        }
    }

    if !state.reviews.is_empty() {
        let _ = writeln!(s, "\n{}", bold("review + verification"));
        for r in &state.reviews {
            let raised: usize = r.reviews.iter().map(|x| x.findings.len()).sum();
            // A build/link failure is not a verdict on the patch (a shared
            // `CARGO_TARGET_DIR` link race looks exactly like one), so it
            // must not read the same as a real test failure. And a deferred
            // round is not a passed one: `e2e.is_empty()` alone cannot tell
            // "not configured" from "skipped on purpose" apart, which is
            // exactly why `e2e_status` exists rather than reading `e2e`
            // directly here.
            let e2e = match r.e2e_status() {
                E2eStatus::NotConfigured => dim("no e2e"),
                E2eStatus::Deferred => yellow(&format!(
                    "e2e deferred{}",
                    r.e2e_defer_reason
                        .as_deref()
                        .map(|why| format!(" ({why})"))
                        .unwrap_or_default()
                )),
                E2eStatus::Passed => green("e2e green"),
                E2eStatus::Failed if r.e2e.iter().any(CommandOutcome::build_failed) => {
                    yellow("e2e could not run (build/link failure)")
                }
                E2eStatus::Failed => red("e2e RED"),
                // Magi's own admission it could not get a command to run —
                // never the same yellow/red a real attempt earns, since
                // nothing here is evidence about the patch (see
                // `E2eStatus::ResourceBlocked`'s own doc).
                E2eStatus::ResourceBlocked => yellow("e2e could not run (resource unavailable)"),
            };
            let e2e = if r.verify_retried {
                format!("{e2e}, retried once")
            } else {
                e2e
            };
            // Three distinct facts, not two: a round can be *open* (blocking
            // findings still standing), *incomplete* (a seat never answered,
            // so what the round says is missing input) or genuinely clean.
            let status = if r.incomplete() {
                yellow("incomplete")
            } else if r.clean {
                green("clean")
            } else {
                yellow("open")
            };
            // A missing seat must stay visible even when `warn` policy let
            // the round gate as clean: the reader should never have to take
            // "clean" on faith when the panel wasn't full.
            let panel = if r.incomplete() {
                let missing: Vec<String> = r
                    .reviews
                    .iter()
                    .filter_map(|x| {
                        x.failed
                            .as_ref()
                            .map(|why| format!("review-{}: {why}", x.reviewer))
                    })
                    .collect();
                format!(
                    "  {}/{} reviewers answered ({})",
                    r.answered,
                    r.expected,
                    missing.join(", ")
                )
            } else {
                String::new()
            };
            // The verdict is the one thing this loop cannot derive from
            // `blocking`/`e2e` alone: three seats can agree there is nothing
            // blocking and still split on whether the patch is fine to
            // proceed as-is, which is exactly the disagreement a vote exists
            // to surface.
            let verdict = r.verdict.map_or(String::new(), |v| {
                format!(
                    ", verdict {}{}",
                    vote_tag(v),
                    if r.vote_split { " (panel split)" } else { "" }
                )
            });
            let _ = writeln!(
                s,
                "  round {}  {} @ {}{}{panel}  {raised} finding(s), {} blocking, {e2e}{verdict}{}",
                r.round,
                status,
                short(&r.head),
                r.verified_head.as_ref().map_or(String::new(), |head| {
                    format!(
                        " (verified @ {}{})",
                        short(head),
                        r.verified_at.map_or(String::new(), |t| format!(
                            " on {}",
                            t.to_zoned(jiff::tz::TimeZone::system())
                                .strftime("%Y-%m-%d %H:%M:%S")
                        ))
                    )
                }),
                r.blocking,
                r.fix.as_ref().map_or(String::new(), |f| {
                    let tree = if r.progressed {
                        green("changed")
                    } else {
                        yellow("unchanged")
                    };
                    let cont = f
                        .continuation
                        .as_ref()
                        .map_or(String::new(), continuation_note);
                    match &f.failed {
                        // Never the same shape as "N addressed / M rejected": the
                        // fixer's diff may well have landed (see the `fix` node's
                        // own event), but whether it addressed anything is
                        // unknown, not zero.
                        Some(reason) => format!(
                            "  fix: {}, tree {tree}{}{cont}",
                            yellow(&format!("adoption report lost ({reason})")),
                            if f.committed {
                                String::new()
                            } else {
                                red(" (NO COMMIT)")
                            }
                        ),
                        None => format!(
                            "  fix: {} addressed / {} rejected, tree {tree}{}{cont}",
                            f.addressed.len(),
                            f.rejected.len(),
                            if f.committed {
                                String::new()
                            } else {
                                red(" (NO COMMIT)")
                            }
                        ),
                    }
                })
            );
            // The aggregate label above (`e2e`) says the round's overall
            // verdict; it never named the commands themselves, so a round
            // with more than one `verify.e2e` command left no way to tell
            // which one actually failed or was blocked without opening
            // `run.json` by hand — the same gap `gate`'s own per-command
            // listing above already closes for the final gate.
            for o in &r.e2e {
                let label = if o.resource_blocked {
                    yellow("blocked")
                } else if o.ok() {
                    green("pass")
                } else {
                    red("FAIL")
                };
                let _ = writeln!(s, "    {label}  {}", o.command);
                if !o.ok() {
                    let _ = writeln!(
                        s,
                        "{}",
                        dim(&crate::run::summarize_verify(&o.output_tail, 2_000))
                    );
                }
            }
            for rec in &r.reviews {
                if let Some(vote) = rec.vote {
                    let _ = writeln!(s, "      review-{} vote {}", rec.reviewer, vote_tag(vote));
                }
                for f in &rec.findings {
                    let adopted = r
                        .fix
                        .as_ref()
                        .is_some_and(|fix| fix.addressed.contains(&f.id));
                    let _ = writeln!(
                        s,
                        "      {} [{:?}] {}{}",
                        dim(&f.id),
                        f.severity,
                        f.title,
                        if adopted {
                            green("  fixed")
                        } else {
                            String::new()
                        }
                    );
                }
            }
            if let Some(fix) = &r.fix {
                for rej in &fix.rejected {
                    let _ = writeln!(
                        s,
                        "      {} {}: {}",
                        dim(&rej.id),
                        yellow("declined"),
                        rej.why
                    );
                }
            }
            // Reconsideration only ever has entries when the round's initial
            // votes split — an empty list here means the panel agreed the
            // first time, same as an empty `deliberation` for judges.
            if !r.reconsideration.is_empty() {
                let _ = writeln!(s, "      {}", dim("reconsideration:"));
                for rv in &r.reconsideration {
                    match rv.vote {
                        Some(v) => {
                            let _ = writeln!(
                                s,
                                "        review-{} -> {}  {}",
                                rv.reviewer,
                                vote_tag(v),
                                rv.reason
                            );
                        }
                        None => {
                            let _ = writeln!(
                                s,
                                "        review-{} -> {}",
                                rv.reviewer,
                                red(&format!(
                                    "no revote ({})",
                                    rv.failed.as_deref().unwrap_or("unknown")
                                ))
                            );
                        }
                    }
                }
            }
        }
        if state.handed_off_with_open_findings() {
            let _ = writeln!(
                s,
                "\n  {}",
                yellow(&format!(
                    "handed off with {} finding(s) still open — gate and e2e were green; \
                     see above for what a person should still look at",
                    state.open_findings().len()
                ))
            );
        }
    }

    if !state.merge_repairs.is_empty() {
        let _ = writeln!(s, "\n{}", bold("merge-gate repairs"));
        for r in &state.merge_repairs {
            let _ = writeln!(
                s,
                "  question {}  head {}  {:?}\n  {}",
                r.question,
                crate::run::short_of(&r.head),
                r.phase,
                r.pr
            );
            if let Some(why) = &r.failure {
                let _ = writeln!(s, "  held: {why}");
            }
            if let Some(round) = r.reviews.last() {
                for f in round.reviews.iter().flat_map(|rec| &rec.findings) {
                    let _ = writeln!(s, "  original [{}] {:?}: {}", f.id, f.severity, f.title);
                }
                for (seat, _, vote) in round.final_votes() {
                    let _ = writeln!(s, "  original reviewer #{seat}: {:?}", vote);
                }
            }
        }
        s.push_str(
            "  Repair never approves a merge; updated results require a fresh owner decision.\n",
        );
    }

    if !state.operator_fixes.is_empty() {
        let _ = writeln!(s, "\n{}", bold("operator fix(es)"));
        for (i, req) in state.operator_fixes.iter().enumerate() {
            let _ = writeln!(
                s,
                "  [{}] {} finding(s) at {}{}",
                i + 1,
                req.findings.len(),
                req.requested_at
                    .to_zoned(jiff::tz::TimeZone::system())
                    .strftime("%Y-%m-%d %H:%M:%S"),
                if req.stale {
                    yellow("  stale head, --allow-stale used")
                } else {
                    String::new()
                }
            );
            let _ = writeln!(s, "      reason: {}", req.reason);
            for f in &req.findings {
                let outcome = match &f.outcome {
                    OperatorFixOutcome::Pending => yellow("pending"),
                    OperatorFixOutcome::Addressed => green("addressed"),
                    OperatorFixOutcome::Rejected { why } => red(&format!("rejected: {why}")),
                    OperatorFixOutcome::Unreported => {
                        red("unreported — no adoption report came back")
                    }
                };
                let _ = writeln!(
                    s,
                    "      {} [{:?}] {}  {outcome}",
                    dim(&f.id),
                    f.severity,
                    f.title
                );
            }
            match &req.follow_up_review_run {
                Some(id) => {
                    let _ = writeln!(s, "      re-verified by run {id}");
                }
                None if req.fix.as_ref().is_some_and(|fx| fx.committed) => {
                    let _ = writeln!(
                        s,
                        "      {}",
                        red("committed, but the follow-up review could not be opened")
                    );
                }
                None => {
                    let _ = writeln!(s, "      no change committed; nothing to re-verify");
                }
            }
        }
    }

    if let Some(bs) = &state.base_sync {
        let _ = writeln!(s, "\n{}", bold("base sync"));
        let status = if let Some(a) = &bs.already_in {
            dim(&format!(
                "already in {} as {} ({} match) - nothing left to land",
                state.base_branch,
                a.names(),
                a.proof.as_str()
            ))
        } else if let Some(c) = &bs.conflict {
            red(&format!("conflict: {}", first_line(c)))
        } else if bs.behind == 0 {
            green("in sync")
        } else {
            yellow(&format!("{} commit(s) behind, not yet rebased", bs.behind))
        };
        let _ = writeln!(
            s,
            "  {} @ {}  {status}{}",
            state.base_branch,
            short(&bs.tip),
            if bs.attempts > 0 {
                format!("  ({} rebase attempt(s))", bs.attempts)
            } else {
                String::new()
            }
        );
    }

    if !state.pre_gate.is_empty() {
        let _ = writeln!(s, "\n{}", bold("pre_gate"));
        for o in &state.pre_gate {
            let _ = writeln!(
                s,
                "  {}  {}",
                if o.ok() {
                    green("pass")
                } else {
                    yellow("warn")
                },
                o.command
            );
            if !o.ok() {
                let _ = writeln!(
                    s,
                    "{}",
                    dim(&crate::run::summarize_verify(&o.output_tail, 2_000))
                );
            }
        }
        if let Some(c) = &state.pre_gate_commit {
            let _ = writeln!(s, "  committed mechanical fixes @ {}", short(c));
        }
    }

    // `state.gate.is_empty()` alone cannot tell "never ran" apart from "ran
    // with nothing configured" — see `RunState::gate_status`'s own doc — so
    // this reads the accessor rather than the raw list.
    match state.gate_status() {
        GateStatus::NotRun => {}
        GateStatus::NotConfigured => {
            let _ = writeln!(s, "\n{}", bold("gate"));
            let _ = writeln!(s, "  {}  no gate commands configured", dim("not tested"));
        }
        GateStatus::Passed | GateStatus::Failed => {
            let _ = writeln!(s, "\n{}", bold("gate"));
            for o in &state.gate {
                let _ = writeln!(
                    s,
                    "  {}  {}",
                    if o.ok() { green("pass") } else { red("FAIL") },
                    o.command
                );
                if !o.ok() {
                    let _ = writeln!(
                        s,
                        "{}",
                        dim(&crate::run::summarize_verify(&o.output_tail, 2_000))
                    );
                }
            }
        }
    }

    if let Some(m) = &state.merge {
        let _ = writeln!(s, "\n{}", bold("merge"));
        if m.mode == MergeMode::None {
            // `ok: true` here means "magi did nothing, as configured", not
            // "landed" — a green `ok` next to a shell command reads as done,
            // and the branch is still sitting unmerged.
            let _ = writeln!(
                s,
                "  mode None  {}",
                cyan("not landed — nothing to do by design")
            );
            if let Some(w) = state.winner() {
                let _ = writeln!(
                    s,
                    "  branch {} still exists, unmerged into {}",
                    w.branch, state.base_branch
                );
            }
            // The squash caveat only applies to that one style: `--no-ff` and
            // `--ff-only` never inherit a candidate's placeholder subject,
            // since neither ever discards the pull request body `message`
            // that `manual_merge_command` (graph.rs) already puts on the
            // squash commit's `-m`.
            let _ = writeln!(
                s,
                "  rebase onto {} before merging by hand{}",
                state.base_branch,
                if state.config.merge.style == MergeStyle::Squash {
                    ", and pass an explicit commit message — a squash merge \
                     otherwise inherits the candidate's placeholder subject"
                } else {
                    ""
                }
            );
            let _ = writeln!(s, "  {}", m.detail.lines().next().unwrap_or(""));
        } else {
            let _ = writeln!(
                s,
                "  mode {:?}  {}\n  {}",
                m.mode,
                if m.empty {
                    yellow("empty candidate — nothing to land")
                } else if m.ok && state.status == RunStatus::Merged {
                    green("merged")
                } else if m.ok && m.mode == MergeMode::Pr {
                    yellow("published; not merged")
                } else {
                    yellow("not merged")
                },
                m.detail.lines().next().unwrap_or("")
            );
        }
        if let Some(pr) = &state.pr
            && !pr.red_at_merge.is_empty()
        {
            let _ = writeln!(
                s,
                "  {} {}",
                yellow("merged with red checks:"),
                pr.red_at_merge.join(", ")
            );
        }
    }

    if !state.followups.is_empty() {
        let _ = writeln!(s, "\n{}", bold("follow-ups"));
        for f in &state.followups {
            let _ = writeln!(
                s,
                "  {} {}",
                crate::queue::short(&f.task),
                f.findings.join(", ")
            );
        }
    }

    if !state.bump_decision_attempts.is_empty() {
        let _ = writeln!(s, "\n{}", bold("release decision attempts"));
        for (n, attempt) in state.bump_decision_attempts.iter().enumerate() {
            let _ = writeln!(s, "  {}. {}: {}", n + 1, attempt.agent, attempt.outcome);
        }
    }
    if let Some(b) = &state.release_bump {
        let _ = writeln!(s, "\n{}", bold("release bump"));
        if let Some(why) = &b.skipped {
            let _ = writeln!(
                s,
                "  {} {why}",
                bold(&yellow("SKIPPED (no release was made):"))
            );
        }
        if let Some(v) = &b.version {
            let _ = writeln!(s, "  version v{v}");
        }
        if let Some(url) = &b.pr_url {
            let _ = writeln!(s, "  pr {url}");
        }
        if b.skipped.is_none() || b.pr_url.is_some() {
            let _ = writeln!(
                s,
                "  automerge {}",
                if b.automerge_enabled {
                    green("enabled")
                } else if b.merged_directly {
                    green("not needed (CI was already green; merged directly)")
                } else if b.local {
                    dim(
                        "not used (release.mode = local: merged on your approval, released by magi serve)",
                    )
                } else if b.problem.is_some() {
                    bold(&red("FAILED"))
                } else {
                    dim("not enabled")
                }
            );
        }
        if let Some(p) = &b.problem {
            let _ = writeln!(s, "  {}", p.lines().next().unwrap_or(""));
        }
        if let Some(j) = &b.release {
            let state = if j.finished {
                "finished"
            } else {
                j.failed.as_deref().unwrap_or("unfinished")
            };
            let _ = writeln!(s, "  release {} at {}: {state}", j.tag(), j.commit);
            for l in &j.log {
                let code = l.code.map_or("none".to_owned(), |c| c.to_string());
                let _ = write!(s, "    {} (exit {code})", l.name);
                if let Some(o) = &l.output {
                    let _ = write!(s, " output {o}");
                }
                let _ = writeln!(s);
            }
        }
        if let Some(a) = &b.action_required {
            let _ = writeln!(s, "  {} {a}", bold(&yellow("action required:")));
        }
    }

    if !state.leaks.is_empty() {
        let _ = writeln!(s, "\n{}", bold(&yellow("blindness warnings")));
        for l in &state.leaks {
            let _ = writeln!(s, "  {} x{} in {}", l.token, l.count, l.site);
        }
    }

    if let Some(w) = state.winner()
        && !w.folded
    {
        let _ = writeln!(
            s,
            "\n{} {}\n  branch {}",
            bold("winner worktree"),
            w.worktree.display(),
            w.branch
        );
    }
    s.push_str(&jobs_section(state));
    s
}

/// The seats currently mid-answer, for `magi show` and the raw report route.
///
/// Separate from [`run`] on purpose: [`run`] is printed straight after `magi
/// run` / `magi review`'s own `execute()`, and by then this process has
/// nothing left in flight to report; the TUI does not track daemon liveness
/// either. Only a caller reading someone *else's* run — `magi show <id>`, or
/// the web UI's raw-report route — needs this, and both already know how to
/// ask whether a daemon is currently driving it.
///
/// `live` is [`RunState::liveness`]: whether a daemon's heartbeat currently
/// names this run, or — absent that claim — whether `driver_pid` still
/// answers alive. An [`ActiveSeat`](crate::run::ActiveSeat) left behind by a
/// killed process is not lied about as running just because nobody has
/// cleared it from disk yet — see that type's own docs for why an entry
/// alone is not proof of anything.
pub fn active_seats(state: &RunState, live: Liveness) -> String {
    let mut s = String::new();
    if let Some(block) = &state.resource_block {
        let _ = writeln!(
            s,
            "\n{}\n  {}. Resume to retry the affected operation.",
            bold("waiting on a resource"),
            block.description()
        );
    }
    if state.active.is_empty() {
        return s;
    }
    let _ = writeln!(s, "\n{}", bold("running now"));
    let now = jiff::Timestamp::now();
    match live {
        Liveness::Live => {}
        Liveness::Dead => {
            let _ = writeln!(
                s,
                "  {}",
                yellow(
                    "no live daemon claims this run right now — likely left behind by a killed process"
                )
            );
        }
        Liveness::Unknown => {
            // `active_all_overrun` is never treated as proof of death here —
            // only ever mentioned alongside "could not confirm", since a
            // seat legitimately overrunning its budget while the process
            // driving it tears the attempt down looks identical on disk (see
            // `RunState::active_all_overrun`'s own doc).
            let overrun = if state.active_all_overrun(now) {
                " — every active seat has already run past its own timeout budget"
            } else {
                ""
            };
            let _ = writeln!(
                s,
                "  {}",
                yellow(&format!(
                    "whether a process is still driving this run could not be confirmed{overrun}"
                ))
            );
        }
    }
    for (seat, a) in state.seats_active() {
        let retry = if a.attempt > 0 {
            format!(" retry {}", a.attempt)
        } else {
            String::new()
        };
        // Before the CLI is spawned there is no agent budget to count down.
        if let Some(w) = state.resource_wait.as_ref().filter(|w| w.node == a.node) {
            let _ = writeln!(
                s,
                "  {:<12} {:<12}{retry}  waiting for the {} ({}), {}s of {}s; agent not started yet",
                seat,
                a.node,
                w.kind,
                w.holder,
                (now.as_second() - w.since.as_second()).max(0),
                w.limit_secs
            );
            continue;
        }
        let _ = writeln!(
            s,
            "  {:<12} {:<12}{retry}  {}s elapsed, {}s left of {}s",
            seat,
            a.node,
            a.elapsed_secs(now),
            a.remaining_secs(now),
            a.timeout_secs
        );
    }
    for (task, a) in state.tasks_active() {
        let retry = if a.attempt > 0 {
            format!(" retry {}", a.attempt)
        } else {
            String::new()
        };
        let progress = match (a.index, a.total) {
            (Some(i), Some(t)) => format!(" ({i}/{t})"),
            _ => String::new(),
        };
        let _ = writeln!(
            s,
            "  {:<12} {:<12}{retry}{progress}  {}s elapsed, {}s left of {}s",
            task,
            a.node,
            a.elapsed_secs(now),
            a.remaining_secs(now),
            a.timeout_secs
        );
        if let Some(command) = &a.command {
            let _ = writeln!(s, "               {command}");
        }
    }
    s
}

/// Render a whole number of seconds as `1h02m`, `3m05s` or `42s`.
fn fmt_secs(secs: i64) -> String {
    let secs = secs.max(0);
    let h = secs / 3600;
    let m = (secs % 3600) / 60;
    let s = secs % 60;
    if h > 0 {
        format!("{h}h{m:02}m")
    } else if m > 0 {
        format!("{m}m{s:02}s")
    } else {
        format!("{s}s")
    }
}

/// A fixed-width text bar, `value` proportional to `max` out of `width` cells.
///
/// Any positive value draws at least one cell, so a short-but-nonzero
/// duration is never mistaken for an unmeasured one.
fn bar(value: f64, max: f64, width: usize) -> String {
    if max <= 0.0 || value <= 0.0 {
        return String::new();
    }
    let cells = ((value / max) * width as f64)
        .round()
        .clamp(1.0, width as f64) as usize;
    "█".repeat(cells)
}

/// Per-repository summary table: repo name, run count, completion rate.
///
/// `main.rs`'s `Command::Stats` is what decides *whether* to print this —
/// only ahead of the plain (no `--repo`) report, and only when `repos.len() >
/// 1` — this function only renders whatever it is handed.
pub fn repo_summary(repos: &[RepoStats]) -> String {
    let mut s = String::new();
    let _ = writeln!(s, "{}", bold("repos"));

    // Two different checkouts can share a leaf directory name (`magi` under
    // two different roots); disambiguate only those with their parent
    // directory rather than paying the extra noise on every row.
    let mut name_counts: std::collections::HashMap<&str, usize> = std::collections::HashMap::new();
    for r in repos {
        *name_counts.entry(r.name.as_str()).or_insert(0) += 1;
    }

    for r in repos {
        let label = if name_counts.get(r.name.as_str()).copied().unwrap_or(0) > 1 {
            match r.repo.parent().and_then(|p| p.file_name()) {
                Some(parent) => format!("{} ({})", r.name, parent.to_string_lossy()),
                None => r.name.clone(),
            }
        } else {
            r.name.clone()
        };
        let _ = writeln!(
            s,
            "  {}  {} runs  {:.0}% completion",
            label,
            r.stats.totals.runs,
            r.stats.totals.completion_rate()
        );
    }
    s
}

/// Aggregate tables, for `magi stats`.
pub fn stats(stats: &Stats) -> String {
    let t = &stats.totals;
    let mut s = String::new();
    let _ = writeln!(s, "{}", bold("runs"));
    let _ = writeln!(
        s,
        "  {} total - {} merged, {} ready, {} blocked, {} failed ({:.0}% completion)",
        t.runs,
        t.merged,
        t.ready,
        t.blocked,
        t.failed,
        t.completion_rate()
    );
    if t.tallied > 0 {
        let _ = writeln!(
            s,
            "  {} tallied - {} split on first choice ({:.0}%), {} deliberated, \
             {} of those changed a mind, {} converged to unanimous",
            t.tallied,
            t.split,
            t.split_rate(),
            t.deliberated,
            t.minds_changed,
            t.converged
        );
    }

    if !stats.retired_hidden.is_empty() {
        let n = stats.retired_hidden.len();
        let _ = writeln!(
            s,
            "{n} retired agent{} hidden: {} (magi stats --all to show)\n",
            if n == 1 { "" } else { "s" },
            stats.retired_hidden.join(", ")
        );
    }

    let has_competitive = stats.agents.iter().any(|a| a.competitive_entered > 0);
    if has_competitive {
        let mut comp_agents = stats.agents.clone();
        comp_agents.retain(|a| a.competitive_entered > 0);
        comp_agents.sort_by(|a, b| {
            let a_tier = if a.competitive_entered < 10 { 1 } else { 0 };
            let b_tier = if b.competitive_entered < 10 { 1 } else { 0 };
            a_tier
                .cmp(&b_tier)
                .then(
                    b.competitive_win_rate()
                        .total_cmp(&a.competitive_win_rate()),
                )
                .then(b.competitive_entered.cmp(&a.competitive_entered))
                .then(a.agent.cmp(&b.agent))
        });

        let _ = writeln!(
            s,
            "\n{}",
            bold("implementation (competitive runs, 2+ candidates)")
        );
        let _ = writeln!(
            s,
            "  {:<14}{:>6}{:>8}{:>8}{:>8}",
            "agent", "won", "entered", "rate", "empty"
        );
        for a in &comp_agents {
            let low_n_marker = if a.competitive_entered < 10 {
                format!(" {}", dim("low n"))
            } else {
                String::new()
            };
            let _ = writeln!(
                s,
                "  {:<14}{:>6}{:>8}{:>7.0}%{:>8}{}",
                a.agent,
                a.competitive_wins,
                a.competitive_entered,
                a.competitive_win_rate(),
                a.empty,
                low_n_marker
            );
        }
    }

    let has_solo = stats.agents.iter().any(|a| a.solo_entered > 0);
    if has_solo {
        let mut solo_agents = stats.agents.clone();
        solo_agents.retain(|a| a.solo_entered > 0);
        solo_agents.sort_by(|a, b| {
            let a_tier = if a.solo_entered < 10 { 1 } else { 0 };
            let b_tier = if b.solo_entered < 10 { 1 } else { 0 };
            a_tier
                .cmp(&b_tier)
                .then(b.solo_adoption_rate().total_cmp(&a.solo_adoption_rate()))
                .then(b.solo_entered.cmp(&a.solo_entered))
                .then(a.agent.cmp(&b.agent))
        });

        let _ = writeln!(
            s,
            "\n{}",
            bold("implementation (solo runs, completion/adoption rate)")
        );
        let _ = writeln!(
            s,
            "  {:<14}{:>8}{:>8}{:>8}",
            "agent", "adopted", "entered", "rate"
        );
        for a in &solo_agents {
            let low_n_marker = if a.solo_entered < 10 {
                format!(" {}", dim("low n"))
            } else {
                String::new()
            };
            let _ = writeln!(
                s,
                "  {:<14}{:>8}{:>8}{:>7.0}%{}",
                a.agent,
                a.solo_adopted,
                a.solo_entered,
                a.solo_adoption_rate(),
                low_n_marker
            );
        }
    }

    if !stats.reviewers.is_empty() {
        let _ = writeln!(s, "\n{}", bold("review"));
        let _ = writeln!(
            s,
            "  {:<14}{:>8}{:>10}{:>11}{:>9}{:>9}{:>9}",
            "reviewer", "rounds", "submitted", "adopted/rd", "precision", "unique", "timeout"
        );
        for r in &stats.reviewers {
            let _ = writeln!(
                s,
                "  {:<14}{:>8}{:>10}{:>11.2}{:>8.0}%{:>8.0}%{:>8.0}%",
                r.agent,
                r.rounds,
                r.submitted,
                r.adopted_per_round(),
                r.precision(),
                r.unique_rate(),
                r.timeout_rate()
            );
        }
    }

    if !stats.advisors.is_empty() {
        let _ = writeln!(
            s,
            "\n{} {}",
            bold("design deliberation"),
            dim(
                "(approximate: reflection is read off word overlap with the synthesis brief, not a precise attribution)"
            )
        );
        let _ = writeln!(
            s,
            "  {:<14}{:>7}{:>10}{:>8}{:>8}{:>9}{:>10}",
            "advisor", "seats", "proposed", "strong", "faint", "absent", "reflect%"
        );
        for a in &stats.advisors {
            let _ = writeln!(
                s,
                "  {:<14}{:>7}{:>10}{:>8}{:>8}{:>9}{:>9.0}%",
                a.agent,
                a.seated,
                a.proposed,
                a.strong,
                a.faint,
                a.absent,
                a.reflection_rate()
            );
        }
    }

    if stats.release_bumps.merged > 0 {
        let b = &stats.release_bumps;
        let _ = writeln!(s, "\n{}", bold("release bumps"));
        let _ = writeln!(
            s,
            "  {} of {} merged run(s) recorded a bump ({:.0}%)",
            b.recorded,
            b.merged,
            b.coverage_rate()
        );
        let _ = writeln!(
            s,
            "  {} release PR(s) opened, {} automerge enabled ({:.0}%), {} merged directly",
            b.pr_opened,
            b.automerge_enabled,
            b.automerge_rate(),
            b.merged_directly
        );
        let _ = writeln!(
            s,
            "  {} clean, {} needed a human ({:.0}%)",
            b.clean(),
            b.needs_attention,
            b.attention_rate()
        );
    }

    if stats.e2e.rounds > 0 || stats.e2e.deferred > 0 {
        let _ = writeln!(s, "\n{}", bold("verification"));
        let _ = writeln!(
            s,
            "  {} rounds ran e2e, {} failed, {} of those with a clean static \
             review ({:.0}% sole detections), {} round(s) deferred it to the fixer",
            stats.e2e.rounds,
            stats.e2e.failures,
            stats.e2e.sole_detections,
            stats.e2e.sole_rate(),
            stats.e2e.deferred
        );
    }

    if !stats.nodes.is_empty() {
        let _ = writeln!(
            s,
            "\n{}",
            bold("node durations (first to last event, per run)")
        );
        let max_mean = stats
            .nodes
            .iter()
            .map(|n| n.mean_secs())
            .fold(0.0_f64, f64::max);
        for n in &stats.nodes {
            let unmeasured = if n.single > 0 {
                format!("  {}", dim(&format!("{} unmeasured", n.single)))
            } else {
                String::new()
            };
            let _ = writeln!(
                s,
                "  {:<14}{:>6} runs{:>8} mean{:>8} max  {}{unmeasured}",
                n.node,
                n.runs,
                fmt_secs(n.mean_secs().round() as i64),
                fmt_secs(n.max_secs),
                bar(n.mean_secs(), max_mean, 20)
            );
        }
    }
    s
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::Config;
    use crate::run::{
        Candidate, CommandOutcome, FixRecord, MergeOutcome, ReviewRecord, ReviewRound, RunState,
        Tally,
    };
    use std::collections::BTreeMap;
    use std::path::PathBuf;
    use std::sync::{Mutex, MutexGuard};

    /// `COLOR` is process-global, so these tests cannot run concurrently.
    static SERIAL: Mutex<()> = Mutex::new(());

    fn plain() -> MutexGuard<'static, ()> {
        let guard = SERIAL.lock().unwrap_or_else(|e| e.into_inner());
        set_color(false);
        guard
    }

    fn state() -> RunState {
        // `run()` prints `state.dir()`, which reads the process-global home;
        // pinning it here keeps this test off the operator's real one. The
        // directory itself is never read, only its path printed, so nothing
        // needs to create or clean it up.
        crate::run::pin_test_home();
        let mut s = RunState::new(
            PathBuf::from("/repo"),
            "main".to_owned(),
            "abcdef1234".to_owned(),
            "add retries to the uploader".to_owned(),
            Config::default(),
        );
        s.candidates = vec![Candidate {
            index: 0,
            label: 'A',
            agent: "opus".to_owned(),
            branch: "magi/x/A".to_owned(),
            worktree: PathBuf::from("/wt/A"),
            summary: String::new(),
            stat: String::new(),
            files: 3,
            commits: 2,
            empty: false,
            failed: None,
            verified_noop: None,
            duration_ms: 42_000,
            folded: false,
        }];
        s.tally = Some(Tally {
            first_choice: BTreeMap::from([('A', 3)]),
            borda: BTreeMap::new(),
            winner: 'A',
            rankings: 3,
            unanimous_initial: true,
            deliberated: false,
            changed_votes: 0,
            unanimous_final: true,
            tie_break: None,
            judges: 3,
            present: 3,
            quorum: 2,
            met_quorum: true,
            uncontested: None,
        });
        s
    }

    #[test]
    fn run_report_names_the_winner_and_its_author() {
        let _guard = plain();
        let text = run(&state());
        assert!(text.contains("<- winner"), "{text}");
        assert!(text.contains("opus"));
        assert!(text.contains("3 files, 2 commits"));
        assert!(text.contains("winner        A"));
        assert!(!text.contains('\x1b'), "colour leaked into a plain render");
    }

    #[test]
    fn a_candidates_own_summary_is_surfaced_not_only_kept_in_run_json() {
        // Recorded on every run (`prompt::implement`'s `## SUMMARY`), but
        // `run()` used to never print it at all — silent even when the
        // summary was the one place an implementer explained itself (e.g.
        // an investigation task's findings), and readable only by opening
        // `run.json` by hand.
        let _guard = plain();
        let mut s = state();
        s.candidates[0].summary =
            "investigated 6c5e/8df3: both already merged, see talk 07fe.\nmore detail below."
                .to_owned();
        let text = run(&s);
        assert!(
            text.contains("investigated 6c5e/8df3: both already merged, see talk 07fe."),
            "{text}"
        );
    }

    #[test]
    fn a_verified_noop_run_does_not_read_as_a_failure() {
        // Same spirit as `a_mode_none_merge_does_not_read_as_landed`: a run
        // that settled without landing anything must not be misreadable as
        // the ordinary failure it is not.
        let _guard = plain();
        let mut s = state();
        s.status = RunStatus::VerifiedNoop;
        s.tally = None;
        s.candidates = vec![Candidate {
            index: 0,
            label: 'A',
            agent: "opus".to_owned(),
            branch: "magi/x/A".to_owned(),
            worktree: PathBuf::from("/wt/A"),
            summary: String::new(),
            stat: String::new(),
            files: 0,
            commits: 0,
            empty: true,
            failed: None,
            verified_noop: Some("already fixed by b32cfc4, which is on main".to_owned()),
            duration_ms: 9_000,
            folded: false,
        }];
        let text = run(&s);
        assert!(
            text.contains("agent-verified no-op"),
            "the status and the candidate flag must both say so: {text}"
        );
        assert!(
            text.contains("already fixed by b32cfc4"),
            "the evidence itself must be readable, not just the verdict: {text}"
        );
        assert!(
            !text.to_lowercase().contains("failed"),
            "a verified no-op must never read as the failure it is not: {text}"
        );
    }

    #[test]
    fn colour_is_emitted_only_when_enabled() {
        let _guard = plain();
        set_color(true);
        let coloured = run(&state());
        set_color(false);
        let plain = run(&state());
        assert!(coloured.contains('\x1b'));
        assert!(!plain.contains('\x1b'));
        assert!(coloured.len() > plain.len());
    }

    #[test]
    fn list_line_is_single_line() {
        let _guard = plain();
        let l = line(&state());
        assert_eq!(l.lines().count(), 1);
        assert!(l.contains("add retries"));
        assert!(l.contains("win A (opus)"));
    }

    #[test]
    fn an_uncontested_run_does_not_read_as_a_collapsed_panel() {
        let _guard = plain();
        let mut s = state();
        s.tally = Some(Tally {
            first_choice: BTreeMap::from([('A', 0)]),
            borda: BTreeMap::new(),
            winner: 'A',
            rankings: 0,
            unanimous_initial: false,
            deliberated: false,
            changed_votes: 0,
            unanimous_final: false,
            tie_break: None,
            judges: 0,
            present: 0,
            quorum: 0,
            met_quorum: true,
            uncontested: Some(
                "only candidate A produced a usable change; no panel was asked".to_owned(),
            ),
        });
        let text = run(&s);
        assert!(
            !text.contains("0/3"),
            "no panel sat, so the judges line must not read as one that collapsed: {text}"
        );
        assert!(!text.contains("no usable ranking"), "{text}");
        assert!(!text.contains("still split"), "{text}");
        assert!(!text.contains("BELOW QUORUM"), "{text}");
        assert!(
            text.contains("not needed"),
            "the report must say judging was skipped, not silent: {text}"
        );
        assert!(text.contains("winner        A"));
    }

    #[test]
    fn a_below_quorum_run_still_reads_as_a_collapsed_panel() {
        let _guard = plain();
        let mut s = state();
        s.tally = Some(Tally {
            first_choice: BTreeMap::from([('A', 1), ('B', 0)]),
            borda: BTreeMap::new(),
            winner: 'A',
            rankings: 1,
            unanimous_initial: false,
            deliberated: false,
            changed_votes: 0,
            unanimous_final: false,
            tie_break: None,
            judges: 3,
            present: 1,
            quorum: 2,
            met_quorum: false,
            uncontested: None,
        });
        let text = run(&s);
        assert!(text.contains("1/3"), "{text}");
        assert!(
            text.contains("BELOW QUORUM"),
            "a real collapse must still be flagged: {text}"
        );
        assert!(
            !text.contains("not needed"),
            "a collapsed panel must not be described as one that was never asked: {text}"
        );
    }

    #[test]
    fn a_mode_none_merge_does_not_read_as_landed() {
        let _guard = plain();
        let mut s = state();
        s.merge = Some(MergeOutcome {
            mode: crate::config::MergeMode::None,
            ok: true,
            detail: "git -C /repo merge --no-ff magi/x/A".to_owned(),
            empty: false,
        });
        let text = run(&s);
        assert!(
            !text.contains("  ok"),
            "mode none must not be shown as a landed merge: {text}"
        );
        assert!(text.contains("not landed"), "{text}");
        assert!(
            text.contains("branch magi/x/A"),
            "the report must say what's left behind: {text}"
        );
        assert!(
            text.contains("rebase"),
            "the report must point at the hand-landing steps: {text}"
        );
        assert!(
            !text.contains("placeholder subject"),
            "the default merge style is `merge`, which never inherits a \
             placeholder subject, so the squash caveat must not appear: {text}"
        );
    }

    #[test]
    fn a_mode_none_squash_merge_warns_about_the_placeholder_subject() {
        let _guard = plain();
        let mut s = state();
        s.config.merge.style = MergeStyle::Squash;
        s.merge = Some(MergeOutcome {
            mode: crate::config::MergeMode::None,
            ok: true,
            detail: "git -C /repo merge --squash magi/x/A && git -C /repo commit -m \"add \
                      retries\""
                .to_owned(),
            empty: false,
        });
        let text = run(&s);
        assert!(
            text.contains("placeholder subject"),
            "a squash-style manual merge must warn about the missing message: {text}"
        );
        assert!(text.contains("--squash"), "{text}");
    }

    #[test]
    fn a_ready_run_left_by_merge_mode_none_does_not_read_as_a_plain_ready() {
        let _guard = plain();
        let mut s = state();
        s.status = RunStatus::Ready;
        s.merge = Some(MergeOutcome {
            mode: crate::config::MergeMode::None,
            ok: true,
            detail: "git -C /repo merge --no-ff magi/x/A".to_owned(),
            empty: false,
        });

        let list = line(&s);
        assert!(
            !list.contains(" ready "),
            "a mode-none run must not read as a plain ready in `magi list`: {list}"
        );
        assert!(list.contains("no-op by design"), "{list}");

        let full = run(&s);
        assert!(
            !full.contains("magi run") || !full.lines().next().unwrap().contains(" ready"),
            "the header line of `magi show` must not say plain ready either: {full}"
        );
        assert!(full.contains("no-op by design"), "{full}");
    }

    #[test]
    fn an_ordinary_ready_run_still_reads_as_ready() {
        let _guard = plain();
        let mut s = state();
        s.status = RunStatus::Ready;
        // A PR closed without merging also ends at `Ready` (see `land.rs`),
        // and unlike the honest mode-none no-op it must keep reading as a
        // plain `ready` — the label exists to flag design, not every non-merge.
        s.merge = Some(MergeOutcome {
            mode: crate::config::MergeMode::Pr,
            ok: false,
            detail: "https://example.com/pr/1 was closed without merging".to_owned(),
            empty: false,
        });

        let list = line(&s);
        assert!(list.contains("ready"), "{list}");
        assert!(!list.contains("no-op by design"), "{list}");
    }

    #[test]
    fn the_list_line_does_not_flag_an_uncontested_run_as_short_judges() {
        let _guard = plain();
        let mut s = state();
        s.tally = Some(Tally {
            first_choice: BTreeMap::from([('A', 0)]),
            borda: BTreeMap::new(),
            winner: 'A',
            rankings: 0,
            unanimous_initial: false,
            deliberated: false,
            changed_votes: 0,
            unanimous_final: false,
            tie_break: None,
            judges: 0,
            present: 0,
            quorum: 0,
            met_quorum: true,
            uncontested: Some("only candidate A produced a usable change".to_owned()),
        });
        let l = line(&s);
        assert!(
            !l.contains("judges") && !l.contains("quorum"),
            "an uncontested run must not carry the same badge a short panel gets: {l}"
        );
    }

    #[test]
    fn long_instructions_are_elided() {
        let _guard = plain();
        let mut s = state();
        s.instruction = "x".repeat(200);
        assert!(line(&s).contains('…'));
    }

    #[test]
    fn a_lost_fix_report_reads_differently_from_zero_adoption() {
        let _guard = plain();
        let mut lost = state();
        lost.reviews = vec![ReviewRound {
            round: 1,
            head: "abc1234".to_owned(),
            verified_head: None,
            verified_at: None,
            reviews: Vec::new(),
            e2e: Vec::new(),
            verify_retried: false,
            e2e_deferred: false,
            e2e_defer_reason: None,
            fix: Some(FixRecord {
                agent: "opus".to_owned(),
                addressed: Vec::new(),
                rejected: Vec::new(),
                notes: String::new(),
                committed: true,
                failed: Some("timed out".to_owned()),
                duration_ms: 0,
                continuation: None,
            }),
            blocking: 3,
            answered: 0,
            expected: 0,
            clean: false,
            progressed: false,
            vote_split: false,
            reconsideration: Vec::new(),
            verdict: None,
        }];
        let text = run(&lost);
        assert!(text.contains("adoption report lost (timed out)"), "{text}");
        assert!(
            !text.contains("0 addressed"),
            "a lost report must never read as `0 addressed`: {text}"
        );

        let mut rejected_all = state();
        rejected_all.reviews = vec![ReviewRound {
            round: 1,
            head: "abc1234".to_owned(),
            verified_head: None,
            verified_at: None,
            reviews: Vec::new(),
            e2e: Vec::new(),
            verify_retried: false,
            e2e_deferred: false,
            e2e_defer_reason: None,
            fix: Some(FixRecord {
                agent: "opus".to_owned(),
                addressed: Vec::new(),
                rejected: Vec::new(),
                notes: String::new(),
                committed: true,
                failed: None,
                duration_ms: 0,
                continuation: None,
            }),
            blocking: 3,
            answered: 0,
            expected: 0,
            clean: false,
            progressed: false,
            vote_split: false,
            reconsideration: Vec::new(),
            verdict: None,
        }];
        let text2 = run(&rejected_all);
        assert!(
            text2.contains("0 addressed / 0 rejected"),
            "a round the fixer actually reported on keeps the count: {text2}"
        );
    }

    #[test]
    fn a_split_round_shows_every_seat_vote_and_the_reconsideration() {
        use crate::run::ReviewRevoteRecord;
        use crate::verdict::ReviewVote;

        let _guard = plain();
        let mut s = state();
        s.reviews = vec![ReviewRound {
            round: 1,
            head: "abc1234".to_owned(),
            verified_head: None,
            verified_at: None,
            reviews: vec![
                ReviewRecord {
                    attempts: 0,
                    reviewer: 1,
                    agent: "alpha".to_owned(),
                    summary: String::new(),
                    findings: Vec::new(),
                    vote: Some(ReviewVote::Approve),
                    failed: None,
                    duration_ms: 0,
                },
                ReviewRecord {
                    attempts: 0,
                    reviewer: 2,
                    agent: "beta".to_owned(),
                    summary: String::new(),
                    findings: Vec::new(),
                    vote: Some(ReviewVote::Reject),
                    failed: None,
                    duration_ms: 0,
                },
            ],
            e2e: Vec::new(),
            verify_retried: false,
            e2e_deferred: false,
            e2e_defer_reason: None,
            fix: None,
            blocking: 0,
            answered: 2,
            expected: 2,
            clean: false,
            progressed: false,
            vote_split: true,
            reconsideration: vec![ReviewRevoteRecord {
                reviewer: 2,
                agent: "beta".to_owned(),
                vote: Some(ReviewVote::ApproveWithFindings),
                reason: "the other seat's read holds up".to_owned(),
                failed: None,
            }],
            verdict: Some(ReviewVote::ApproveWithFindings),
        }];
        let text = run(&s);
        assert!(text.contains("review-1 vote"), "{text}");
        assert!(text.contains("review-2 vote"), "{text}");
        assert!(text.contains("panel split"), "{text}");
        assert!(text.contains("reconsideration"), "{text}");
        assert!(text.contains("the other seat's read holds up"), "{text}");
    }

    #[test]
    fn an_incomplete_panel_and_a_lost_fix_report_both_stay_on_the_round_line() {
        // Two independent facts share this one line, and each arrived from a
        // different change: a seat that never answered, and a fixer whose
        // adoption report was lost. Rendering either must not shadow the
        // other, and neither may collapse into the plain `clean`/`open`
        // pair the line used to carry.
        let _guard = plain();
        let mut s = state();
        s.reviews = vec![ReviewRound {
            round: 1,
            head: "abc1234".to_owned(),
            verified_head: None,
            verified_at: None,
            reviews: vec![
                ReviewRecord {
                    attempts: 0,
                    reviewer: 1,
                    agent: "alpha".to_owned(),
                    summary: String::new(),
                    findings: Vec::new(),
                    vote: None,
                    failed: None,
                    duration_ms: 0,
                },
                ReviewRecord {
                    attempts: 0,
                    reviewer: 2,
                    agent: "beta".to_owned(),
                    summary: String::new(),
                    findings: Vec::new(),
                    vote: None,
                    failed: Some("agent timed out".to_owned()),
                    duration_ms: 0,
                },
            ],
            e2e: Vec::new(),
            verify_retried: false,
            e2e_deferred: false,
            e2e_defer_reason: None,
            fix: Some(FixRecord {
                agent: "opus".to_owned(),
                addressed: Vec::new(),
                rejected: Vec::new(),
                notes: String::new(),
                committed: true,
                failed: Some("timed out".to_owned()),
                duration_ms: 0,
                continuation: None,
            }),
            blocking: 0,
            answered: 1,
            expected: 2,
            clean: false,
            progressed: true,
            vote_split: false,
            reconsideration: Vec::new(),
            verdict: None,
        }];
        let text = run(&s);
        assert!(text.contains("incomplete"), "{text}");
        assert!(text.contains("1/2 reviewers answered"), "{text}");
        assert!(text.contains("review-2: agent timed out"), "{text}");
        assert!(text.contains("adoption report lost (timed out)"), "{text}");
        assert!(
            !text.contains("clean"),
            "a round missing half its panel must never render as clean: {text}"
        );
    }

    #[test]
    fn a_build_failure_is_not_reported_as_a_test_failure() {
        let _guard = plain();
        let mut s = state();
        s.reviews = vec![ReviewRound {
            round: 1,
            head: "abc1234".to_owned(),
            verified_head: None,
            verified_at: None,
            reviews: Vec::new(),
            e2e: vec![CommandOutcome {
                command: "cargo test".to_owned(),
                code: Some(1),
                output_tail: "LINK : fatal error LNK1104: cannot open file".to_owned(),
                duration_ms: 100,
                resource_blocked: false,
            }],
            verify_retried: true,
            e2e_deferred: false,
            e2e_defer_reason: None,
            fix: None,
            blocking: 0,
            answered: 0,
            expected: 0,
            clean: false,
            progressed: false,
            vote_split: false,
            reconsideration: Vec::new(),
            verdict: None,
        }];
        let text = run(&s);
        assert!(text.contains("could not run"), "{text}");
        assert!(text.contains("retried once"), "{text}");
        assert!(!text.contains("e2e RED"), "{text}");
    }

    #[test]
    fn a_resource_blocked_e2e_never_reads_as_red_or_as_a_build_failure() {
        let _guard = plain();
        let mut s = state();
        s.reviews = vec![ReviewRound {
            round: 1,
            head: "abc1234".to_owned(),
            verified_head: None,
            verified_at: None,
            reviews: Vec::new(),
            e2e: vec![CommandOutcome {
                command: "(waiting for the shared build cache)".to_owned(),
                code: None,
                output_tail: "held by run x node e2e seat e2e".to_owned(),
                duration_ms: 100,
                resource_blocked: true,
            }],
            verify_retried: false,
            e2e_deferred: false,
            e2e_defer_reason: None,
            fix: None,
            blocking: 0,
            answered: 0,
            expected: 0,
            clean: false,
            progressed: false,
            vote_split: false,
            reconsideration: Vec::new(),
            verdict: None,
        }];
        let text = run(&s);
        assert!(text.contains("resource unavailable"), "{text}");
        assert!(!text.contains("e2e RED"), "{text}");
        assert!(!text.contains("build/link failure"), "{text}");
    }

    #[test]
    fn a_round_with_more_than_one_e2e_command_names_each_one() {
        // The aggregate `e2e RED` label says the round's overall verdict,
        // never which of several `verify.e2e` commands actually failed —
        // `magi show` must list each command by name, the same way it
        // already does for `gate`.
        let _guard = plain();
        let mut s = state();
        s.reviews = vec![ReviewRound {
            round: 1,
            head: "abc1234".to_owned(),
            verified_head: Some("abc1234".to_owned()),
            verified_at: Some(jiff::Timestamp::now()),
            reviews: Vec::new(),
            e2e: vec![
                CommandOutcome {
                    command: "cargo test --locked --all-targets".to_owned(),
                    code: Some(0),
                    output_tail: String::new(),
                    duration_ms: 0,
                    resource_blocked: false,
                },
                CommandOutcome {
                    command: "cargo make check".to_owned(),
                    code: Some(1),
                    output_tail: "clippy: unused import".to_owned(),
                    duration_ms: 0,
                    resource_blocked: false,
                },
            ],
            verify_retried: false,
            e2e_deferred: false,
            e2e_defer_reason: None,
            fix: None,
            blocking: 0,
            answered: 0,
            expected: 0,
            clean: false,
            progressed: false,
            vote_split: false,
            reconsideration: Vec::new(),
            verdict: None,
        }];
        let text = run(&s);
        assert!(text.contains("cargo test --locked --all-targets"), "{text}");
        assert!(text.contains("cargo make check"), "{text}");
        assert!(text.contains("clippy: unused import"), "{text}");
    }

    #[test]
    fn a_declined_finding_shows_its_reason() {
        use crate::verdict::{Finding, Rejection, Severity};

        let _guard = plain();
        let mut s = state();
        s.status = RunStatus::Ready;
        s.reviews = vec![ReviewRound {
            round: 1,
            head: "deadbee".to_owned(),
            verified_head: None,
            verified_at: None,
            reviews: vec![ReviewRecord {
                attempts: 0,
                reviewer: 1,
                agent: "alpha".to_owned(),
                summary: String::new(),
                findings: vec![Finding {
                    id: "R1-1-1".to_owned(),
                    severity: Severity::Major,
                    file: None,
                    line: None,
                    title: "still open".to_owned(),
                    detail: String::new(),
                }],
                vote: None,
                failed: None,
                duration_ms: 0,
            }],
            e2e: vec![CommandOutcome {
                command: "cargo test".to_owned(),
                code: Some(0),
                output_tail: String::new(),
                duration_ms: 0,
                resource_blocked: false,
            }],
            verify_retried: false,
            e2e_deferred: false,
            e2e_defer_reason: None,
            fix: Some(FixRecord {
                agent: "alpha".to_owned(),
                addressed: Vec::new(),
                rejected: vec![Rejection {
                    id: "R1-1-2".to_owned(),
                    why: "cannot be triggered from any caller".to_owned(),
                }],
                notes: String::new(),
                committed: true,
                failed: None,
                duration_ms: 0,
                continuation: None,
            }),
            blocking: 1,
            answered: 1,
            expected: 1,
            clean: false,
            progressed: true,
            vote_split: false,
            reconsideration: Vec::new(),
            verdict: None,
        }];

        let text = run(&s);
        assert!(text.contains("R1-1-2"), "{text}");
        assert!(text.contains("cannot be triggered"), "{text}");
        assert!(text.contains("still open"), "{text}");
        assert!(
            text.contains("handed off"),
            "a mergeable run with an open round must say so: {text}"
        );
    }

    #[test]
    fn a_failing_gate_command_shows_its_output() {
        let _guard = plain();
        let mut s = state();
        s.status = RunStatus::Blocked;
        s.gate = vec![CommandOutcome {
            command: "cargo make check".to_owned(),
            code: Some(101),
            output_tail: "error[E0308]: mismatched types".to_owned(),
            duration_ms: 0,
            resource_blocked: false,
        }];
        s.gate_ran = true;

        let text = run(&s);
        assert!(text.contains("mismatched types"), "{text}");
    }

    #[test]
    fn a_gate_with_no_commands_is_reported_as_not_tested() {
        let _guard = plain();
        let mut s = state();
        s.status = RunStatus::Ready;
        s.gate_ran = true;
        assert!(s.gate.is_empty());

        let text = run(&s);
        assert!(
            text.contains("gate")
                && text.contains("no gate commands configured")
                && text.contains("not tested"),
            "an unconfigured gate must be explicit: {text}"
        );
    }

    #[test]
    fn a_gate_that_has_not_run_yet_shows_nothing() {
        let _guard = plain();
        let s = state();
        assert!(!s.gate_ran);
        assert!(s.gate.is_empty());

        let text = run(&s);
        assert!(
            !text.contains("no gate commands configured"),
            "an unattempted gate must not be shown as a pass: {text}"
        );
    }

    #[test]
    fn active_seats_shows_who_has_not_answered_and_how_long_is_left() {
        let _guard = plain();
        let mut s = state();
        s.seat_started("judge", "judge-2", std::time::Duration::from_secs(120), 0);
        let text = active_seats(&s, Liveness::Live);
        assert!(text.contains("running now"));
        assert!(text.contains("judge-2"));
        assert!(text.contains("judge"));
        assert!(!text.contains("no live daemon"), "{text}");
        assert!(!text.contains("could not be confirmed"), "{text}");
    }

    #[test]
    fn active_seats_flags_a_leftover_from_a_dead_process() {
        let _guard = plain();
        let mut s = state();
        s.seat_started("implement", "impl-B", std::time::Duration::from_secs(60), 0);
        let text = active_seats(&s, Liveness::Dead);
        assert!(
            text.contains("no live daemon"),
            "a stale entry must not read as running: {text}"
        );
    }

    #[test]
    fn superseded_notice_names_the_run_that_replaced_it() {
        let _guard = plain();
        let text = superseded_notice(Some("bbbb"));
        assert!(text.contains("SUPERSEDED"), "{text}");
        assert!(text.contains("bbbb"), "{text}");
    }

    #[test]
    fn superseded_notice_is_silent_for_the_latest_attempt() {
        let _guard = plain();
        assert_eq!(superseded_notice(None), "");
    }

    #[test]
    fn list_line_marks_a_nonterminal_run_with_a_dead_driver_stale() {
        let _guard = plain();
        let mut s = state();
        s.status = RunStatus::Reviewing;
        let text = line_with_liveness(&s, Liveness::Dead);
        assert!(text.contains("STALE"), "{text}");
        assert!(text.contains("resume required"), "{text}");
        assert!(liveness_notice(&s, Liveness::Dead).contains("STALE"));
    }

    /// A manual `magi run` / `magi review` claims no daemon, but its
    /// `driver_pid` still answers — this is `Unknown`, never `Dead`: see
    /// `RunState::liveness`'s own doc for why an unconfirmed process is never
    /// folded into "confirmed dead".
    #[test]
    fn active_seats_reports_uncertainty_without_claiming_death() {
        let _guard = plain();
        let mut s = state();
        s.seat_started("review", "review-1", std::time::Duration::from_secs(60), 0);
        let text = active_seats(&s, Liveness::Unknown);
        assert!(
            text.contains("could not be confirmed"),
            "an unproven state must read as uncertain, not dead: {text}"
        );
        assert!(!text.contains("no live daemon"), "{text}");
    }

    #[test]
    fn resource_block_reports_saved_evidence_in_text_and_web() {
        use crate::run::{ResourceBlock, ResourceBlockCause};
        let legacy = serde_json::json!({
            "node": "fix", "kind": "shared build cache",
            "detail": "the run is parking", "at": "2026-10-24T09:01:51Z"
        });
        let block: ResourceBlock = serde_json::from_value(legacy).unwrap();
        assert_eq!(block.cause, ResourceBlockCause::Unrecorded);
        for (cause, detail, expected) in [
            (
                ResourceBlockCause::Unrecorded,
                "the run is parking",
                "cancelled for parking",
            ),
            (ResourceBlockCause::Unrecorded, "busy", "cause unrecorded"),
            (
                ResourceBlockCause::Other,
                "metadata write denied",
                "operation blocked",
            ),
            (
                ResourceBlockCause::Timeout {
                    waited_secs: 12,
                    limit_secs: 10,
                },
                "busy",
                "timed out after 12s (limit 10s)",
            ),
            (
                ResourceBlockCause::Cancelled {
                    park: Some(crate::run::ParkCause::Operator),
                },
                "cancelled",
                "cancelled for parking",
            ),
        ] {
            let mut state = state();
            state.resource_block = Some(ResourceBlock {
                cause: cause.clone(),
                detail: detail.into(),
                ..block.clone()
            });
            let text = active_seats(&state, Liveness::Dead);
            assert!(text.contains(expected), "{text}");
            assert!(
                !text.contains("no agent was started"),
                "earlier nodes may have run"
            );
            assert_eq!(
                crate::report_view::build_with(&state, Liveness::Dead, None).active_seats,
                text
            );
            let saved = serde_json::to_value(&state.resource_block).unwrap();
            let reloaded: ResourceBlock = serde_json::from_value(saved).unwrap();
            assert_eq!(reloaded.cause, cause);
        }
    }

    #[test]
    fn active_seats_is_empty_when_nothing_is_running() {
        let _guard = plain();
        assert_eq!(active_seats(&state(), Liveness::Live), "");
    }

    /// A running `verify.e2e` / `verify.gate` task is shown alongside seats,
    /// with which command is currently running and how far through the list
    /// it is — the gap the addendum's second item names: a review-only run
    /// that spends minutes inside `cargo test` between reviewer answers and
    /// the fix's own commit had nothing at all to show for it before this.
    #[test]
    fn active_seats_shows_a_running_verify_task_and_its_command() {
        let _guard = plain();
        let mut s = state();
        s.task_command(
            "e2e",
            "verify",
            0,
            "cargo test",
            2,
            3,
            std::time::Duration::from_secs(600),
        );
        let text = active_seats(&s, Liveness::Live);
        assert!(text.contains("e2e"), "{text}");
        assert!(text.contains("(2/3)"), "{text}");
        assert!(text.contains("cargo test"), "{text}");
    }

    #[test]
    fn no_jobs_section_appears_when_nothing_was_ever_collected() {
        let _guard = plain();
        // The common case today (every backend but codex): silence, not a
        // clutter line repeated on every single `magi show`.
        assert!(!run(&state()).contains("background jobs"));
    }

    #[test]
    fn a_codex_roster_with_no_completed_jobs_yet_says_so_instead_of_staying_silent() {
        let _guard = plain();
        let mut s = state();
        s.config.agents.push(crate::config::AgentSpec {
            id: "codex-one".to_owned(),
            kind: crate::config::AgentKind::Codex,
            model: None,
            command: vec!["codex".to_owned()],
            extra_args: Vec::new(),
            env: BTreeMap::new(),
            prompt_delivery: None,
            max_turn_secs: None,
        });
        let text = run(&s);
        assert!(
            text.contains("background jobs"),
            "a run that could report this must not read the same as one that never could: \
             {text}"
        );
        assert!(text.contains("no completed command evidence yet"));
    }

    #[test]
    fn recovered_running_and_unreadable_jobs_are_told_apart() {
        let _guard = plain();
        let mut s = state();
        s.jobs = vec![
            crate::run::JobRecord {
                node: "implement".to_owned(),
                round: None,
                seat: "impl-A".to_owned(),
                id: "item49".to_owned(),
                description: "cargo test --test graph_cached_gate".to_owned(),
                checked_at: jiff::Timestamp::now(),
                status: crate::run::JobStatus::Completed,
                exit_code: Some(0),
                result_summary: "test result: 2 passed; 0 failed".to_owned(),
                source: "codex".to_owned(),
            },
            crate::run::JobRecord {
                node: "fix".to_owned(),
                round: None,
                seat: "impl-A".to_owned(),
                id: "item52".to_owned(),
                description: "cargo test --test graph_split".to_owned(),
                checked_at: jiff::Timestamp::now(),
                status: crate::run::JobStatus::Failed,
                exit_code: Some(101),
                result_summary: "test result: 1 passed; 1 failed".to_owned(),
                source: "codex".to_owned(),
            },
            crate::run::JobRecord {
                node: "fix".to_owned(),
                round: None,
                seat: "impl-A".to_owned(),
                id: "item60".to_owned(),
                description: "cargo build".to_owned(),
                checked_at: jiff::Timestamp::now(),
                status: crate::run::JobStatus::Unknown,
                exit_code: None,
                result_summary: String::new(),
                source: "codex".to_owned(),
            },
        ];
        let text = run(&s);
        assert!(text.contains("background jobs"));
        assert!(text.contains("item49"));
        assert!(text.contains("item52"));
        assert!(text.contains("item60"));
        // The three states this run actually has evidence for must read
        // differently from one another — never collapsed into a single
        // "ran" or "did not run".
        assert!(text.contains("completed"));
        assert!(text.contains("failed"));
        assert!(text.contains("unknown"));
        // Coverage limit stated once, not fabricated per seat.
        assert!(text.contains("adapter coverage"));
    }

    #[test]
    fn a_jobs_own_round_is_shown_when_known() {
        let _guard = plain();
        let mut s = state();
        s.jobs = vec![crate::run::JobRecord {
            node: "review".to_owned(),
            round: Some(2),
            seat: "review-1".to_owned(),
            id: "item9".to_owned(),
            description: "cargo test --test graph_cached_gate".to_owned(),
            checked_at: jiff::Timestamp::now(),
            status: crate::run::JobStatus::Completed,
            exit_code: Some(0),
            result_summary: "test result: 2 passed; 0 failed".to_owned(),
            source: "codex".to_owned(),
        }];
        let text = run(&s);
        assert!(
            text.contains("round 2"),
            "the round this seat's own command ran in must be visible, distinct from magi's \
             own recorded verify: {text}"
        );
    }

    #[test]
    fn stats_table_renders_without_runs() {
        let _guard = plain();
        let text = stats(&Stats::default());
        assert!(text.contains("0 total"));
        assert!(!text.contains("implementation"));
        assert!(!text.contains("node durations"));
    }

    #[test]
    fn repo_summary_lists_run_count_and_completion_rate() {
        let _guard = plain();
        let a = crate::stats::RepoStats {
            repo: PathBuf::from("/repos/a"),
            name: "a".to_owned(),
            stats: Stats {
                totals: crate::stats::Totals {
                    runs: 4,
                    merged: 2,
                    ready: 1,
                    ..Default::default()
                },
                ..Default::default()
            },
        };
        let text = repo_summary(&[a]);
        assert!(text.contains("repos"), "{text}");
        assert!(text.contains("a  4 runs  75% completion"), "{text}");
    }

    #[test]
    fn repo_summary_disambiguates_colliding_names_with_the_parent_directory() {
        let _guard = plain();
        let a = crate::stats::RepoStats {
            repo: PathBuf::from("/roots/one/magi"),
            name: "magi".to_owned(),
            stats: Stats::default(),
        };
        let b = crate::stats::RepoStats {
            repo: PathBuf::from("/roots/two/magi"),
            name: "magi".to_owned(),
            stats: Stats::default(),
        };
        let text = repo_summary(&[a, b]);
        assert!(text.contains("magi (one)"), "{text}");
        assert!(text.contains("magi (two)"), "{text}");
    }

    #[test]
    fn stats_table_renders_advisor_reflection() {
        let _guard = plain();
        let st = Stats {
            advisors: vec![crate::stats::AdvisorStats {
                agent: "alpha".to_owned(),
                seated: 3,
                proposed: 2,
                absent: 1,
                faint: 1,
                strong: 1,
            }],
            ..Default::default()
        };
        let text = stats(&st);
        assert!(text.contains("design deliberation"));
        assert!(
            text.contains("approximate"),
            "must note the heuristic: {text}"
        );
        assert!(text.contains("alpha"));
        assert!(text.contains("50%"));
    }

    #[test]
    fn stats_table_shows_release_bump_coverage_even_when_nothing_was_recorded() {
        // A repository that has merged runs but never wired up (or never hit)
        // the release-bump step must still show "0 of N merged runs recorded
        // a bump" - hiding the whole section on `recorded == 0` would make
        // that gap invisible instead of reporting it.
        let _guard = plain();
        let st = Stats {
            release_bumps: crate::stats::ReleaseBumpStats {
                merged: 3,
                ..Default::default()
            },
            ..Default::default()
        };
        let text = stats(&st);
        assert!(text.contains("release bumps"), "{text}");
        assert!(
            text.contains("0 of 3 merged run(s) recorded a bump"),
            "{text}"
        );
    }

    #[test]
    fn stats_table_renders_release_bump_coverage_and_attention() {
        let _guard = plain();
        let st = Stats {
            release_bumps: crate::stats::ReleaseBumpStats {
                merged: 4,
                recorded: 2,
                pr_opened: 2,
                automerge_enabled: 1,
                merged_directly: 0,
                needs_attention: 1,
            },
            ..Default::default()
        };
        let text = stats(&st);
        assert!(text.contains("release bumps"), "{text}");
        assert!(
            text.contains("2 of 4 merged run(s) recorded a bump (50%)"),
            "{text}"
        );
        assert!(text.contains("1 clean, 1 needed a human (50%)"), "{text}");
    }

    #[test]
    fn stats_table_renders_node_durations_with_a_bar_and_unmeasured_count() {
        let _guard = plain();
        let st = Stats {
            nodes: vec![
                crate::stats::NodeDuration {
                    node: "implement".to_owned(),
                    runs: 2,
                    total_secs: 200,
                    max_secs: 150,
                    single: 1,
                },
                crate::stats::NodeDuration {
                    node: "gate".to_owned(),
                    runs: 0,
                    total_secs: 0,
                    max_secs: 0,
                    single: 3,
                },
            ],
            ..Default::default()
        };
        let text = stats(&st);
        assert!(text.contains("node durations"));
        assert!(text.contains("implement"));
        assert!(text.contains("2 runs"));
        assert!(text.contains('█'), "the leader must draw a bar: {text}");
        assert!(text.contains("1 unmeasured"));
        assert!(text.contains("gate"));
        assert!(text.contains("3 unmeasured"));
        assert!(!text.contains('\x1b'), "colour leaked into a plain render");
    }

    #[test]
    fn implementation_rates_use_independent_low_n_boundaries() {
        let _guard = plain();
        for (competitive_n, solo_n) in [(9, 10), (10, 9)] {
            let text = stats(&Stats {
                agents: vec![crate::stats::AgentStats {
                    agent: "alpha".to_owned(),
                    competitive_entered: competitive_n,
                    competitive_wins: 1,
                    solo_entered: solo_n,
                    solo_adopted: 2,
                    ..Default::default()
                }],
                ..Default::default()
            });
            let (competitive, solo) = text
                .split_once("implementation (solo runs, completion/adoption rate)")
                .unwrap();
            for (section, n, numerator) in [(competitive, competitive_n, 1), (solo, solo_n, 2)] {
                let row = section.lines().find(|line| line.contains("alpha")).unwrap();
                let cells: Vec<_> = row.split_whitespace().collect();
                assert_eq!(cells[1], numerator.to_string());
                assert_eq!(cells[2], n.to_string());
                assert_eq!(row.contains("low n"), n < 10);
            }
        }
    }

    #[test]
    fn stats_table_renders_competitive_and_solo_tables_with_low_n() {
        let _guard = plain();
        let st = Stats {
            agents: vec![
                crate::stats::AgentStats {
                    agent: "alpha".to_owned(),
                    entered: 15,
                    wins: 10,
                    empty: 0,
                    competitive_entered: 12,
                    competitive_wins: 9,
                    solo_entered: 3,
                    solo_adopted: 1,
                },
                crate::stats::AgentStats {
                    agent: "beta".to_owned(),
                    entered: 5,
                    wins: 2,
                    empty: 1,
                    competitive_entered: 4,
                    competitive_wins: 2,
                    solo_entered: 1,
                    solo_adopted: 0,
                },
            ],
            ..Default::default()
        };
        let text = stats(&st);
        assert!(text.contains("implementation (competitive runs, 2+ candidates)"));
        assert!(text.contains("alpha"));
        assert!(text.contains("75%"));
        assert!(text.contains("beta"));
        assert!(text.contains("50%"));
        assert!(text.contains("implementation (solo runs, completion/adoption rate)"));
        assert!(text.contains("33%"));
        assert!(text.contains("low n"));
    }
}