magi/

conduct.rs

//! The conductor: a single agent seat that arranges the queue.
//!
//! [`crate::queue`] orders runnable tasks by `priority` alone; nothing in it
//! can express that one task should wait for another, or that a task whose
//! last run stopped short deserves a second look before the loop blindly
//! retries it. Once per polling cycle, [`Conductor::maybe_run`] shows one
//! agent seat three things - the runnable tasks, the tasks stuck `running`
//! with no live daemon behind them, and the `failed`/`held` tasks nobody has
//! decided about yet - and asks it to decide `blocked_by` for the first and a
//! recovery for the other two. Everything else about the loop - which
//! unblocked task runs next, one at a time, in `priority` order - is
//! unchanged; see `crate::daemon`.
//!
//! # What the conductor may not do
//!
//! [`Decision`] has no field for `priority`, for deleting a task, or for
//! touching git, a worktree, or a branch directly. [`Recovery::Review`] only
//! ever reopens a branch `crate::daemon` itself resolved from the task's own
//! run record ([`surviving_branch`]) - never a name the model wrote - through
//! `crate::graph::Runner::review`, which reviews and verifies but never
//! rewrites history.
//!
//! # Non-blocking by construction
//!
//! [`crate::ask::ask_and_wait`] is never called from here, and the prompt
//! tells the model the same: that CLI command blocks until a human answers,
//! and calling it from inside the conductor's own invocation would park the
//! whole polling loop behind one task's question. Instead a decision that
//! wants the operator's judgement carries a `question` field, and [`apply`]
//! files it with [`Question::new`] and [`Questions::put`] and moves on in the
//! same call. Something still has to read the owner's reply: the question
//! carries a [`Deputy`] brief, and `magi serve` starts a short-lived seat of
//! its own for it ([`crate::deputy`]) - never this loop.
//!
//! # Fails soft, always
//!
//! [`Conductor::maybe_run`] never returns an error: an unusable roster, a
//! timed-out invocation, or a reply [`verdict::extract_json`] cannot parse are
//! all logged and treated as "this cycle changes nothing." `crate::daemon`'s
//! loop always falls through to its own `Queue::next_runnable` regardless of
//! what happened here.

use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};
use std::time::Duration;

use anyhow::{Context as _, Result};
use serde::{Deserialize, Serialize};

use crate::agent::{self, Invocation, SeatState};
use crate::ask::{ChoiceAction, Deputy, Question, Questions};
use crate::config::Config;
use crate::prompt;
use crate::queue::{Queue, Task, TaskStatus};
use crate::run::RunState;
use crate::verdict;

/// Seat name for the conductor's own CLI-side conversation, scoped away from
/// every other seat magi ever opens - the same rule every other seat follows.
const SEAT: &str = "conduct";

/// Node name reported to the invoked agent (`MAGI_NODE`) and recorded on any
/// question it files, so an operator reading the questions list can tell a
/// conductor's question from one a run's own agent asked.
pub const NODE: &str = "conduct";

/// Wall-clock limit for one conductor turn. The conductor reads a queue
/// listing and replies with json; it does not implement anything or run a
/// build, so this is short - the same order of magnitude as
/// `crate::chat`'s own single-turn, no-write invocations.
const TURN_TIMEOUT: Duration = Duration::from_secs(300);

/// What the conductor may choose for a `running`-but-stalled or a
/// `failed`/`held` task.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Recovery {
    /// Put it back in line, attempts reset - the same effect as
    /// `magi task release`.
    Requeue,
    /// Leave it for a human, unchanged otherwise - the same effect as
    /// `magi task hold`.
    Hold,
    /// Reopen the task's surviving branch as a review-only pass
    /// (`crate::graph::Runner::review`) instead of competing from scratch.
    /// Only takes effect when [`surviving_branch`] can actually name one;
    /// otherwise `crate::daemon` falls back to [`Recovery::Requeue`].
    Review,
    /// Close the task outright, as [`Task::succeed`] - the same effect as
    /// `magi task done`. For a `failed`/`held` task only, never `running`:
    /// this is for a task whose own goal is already known to be met outside
    /// the loop entirely (the branch was merged and the worktree cleaned up
    /// by hand, say) and competing it again would only spend attempts on
    /// work that has nothing left to do, not for a task that merely stopped
    /// mid-competition and might still need to run.
    Done,
}

/// The operation for which the operator's decision is requested. These are
/// fixed protocol values, independent of the language of the displayed choices.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum QuestionOperation {
    /// Choose an existing implementation as the recovery source.
    Recover,
    /// Continue an existing run from its saved state.
    Resume,
    /// Authorize repairing existing work before continuing.
    Repair,
    /// Confirm that the task may be closed as complete.
    Complete,
    /// Request an operator inspection of the target.
    Inspect,
    /// Request a configuration change for the target.
    Configure,
}

/// The concrete object of an operator decision. Sources resolve to commit ids;
/// runs must belong to this task. A generated prose label is never an identity.
#[derive(Debug, Clone, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum QuestionTarget {
    /// The task itself, for decisions without a more specific recorded object.
    Task,
    /// A run already owned by this task.
    Run {
        /// Full recorded run id.
        id: String,
    },
    /// A concrete TOML setting. Different fields on the same task require
    /// different decisions even when both operations are `configure`.
    Setting {
        /// Repository-relative TOML file containing the setting.
        path: String,
        /// Exact table/key components copied from that file.
        keys: Vec<String>,
    },
    /// A recovery source which the repository can resolve to a commit.
    Source {
        /// Existing branch name or commit reference, never a display label.
        reference: String,
    },
}

/// The structured meaning of a question, separate from its displayed wording.
#[derive(Debug, Clone, Deserialize)]
pub struct QuestionDecision {
    /// The concrete type of operator decision requested.
    pub operation: QuestionOperation,
    /// The recorded object the decision concerns.
    pub target: QuestionTarget,
}

impl QuestionDecision {
    fn identity(&self, task: &Task) -> Result<(QuestionOperation, String)> {
        let target = match &self.target {
            QuestionTarget::Task => format!("task:{}", task.id),
            QuestionTarget::Run { id } => {
                anyhow::ensure!(
                    task.runs.contains(id),
                    "question target is not this task's run"
                );
                format!("run:{id}")
            }
            QuestionTarget::Setting { path, keys } => {
                use std::path::Component;
                anyhow::ensure!(
                    !path.is_empty()
                        && Path::new(path)
                            .components()
                            .all(|c| matches!(c, Component::Normal(_)))
                        && !keys.is_empty()
                        && keys.iter().all(|key| !key.is_empty()),
                    "question setting must name a repository file and concrete keys"
                );
                let root = task.repo.canonicalize()?;
                let file = root.join(path).canonicalize()?;
                let relative = file
                    .strip_prefix(&root)
                    .context("question setting is outside the repository")?;
                let content = std::fs::read_to_string(&file)?;
                let value: toml::Value = toml::from_str(&content)?;
                let mut setting = &value;
                for key in keys {
                    setting = setting
                        .get(key)
                        .context("question setting key does not exist")?;
                }
                format!("setting:{}", serde_json::to_string(&(relative, keys))?)
            }
            QuestionTarget::Source { reference } => {
                use crate::proc::Quiet as _;
                let output = std::process::Command::new("git")
                    .args([
                        "rev-parse",
                        "--verify",
                        "--end-of-options",
                        &format!("{reference}^{{commit}}"),
                    ])
                    .current_dir(&task.repo)
                    .quiet()
                    .output()
                    .context("resolve question source")?;
                anyhow::ensure!(
                    output.status.success(),
                    "question source cannot be resolved"
                );
                let commit = String::from_utf8(output.stdout)?.trim().to_owned();
                anyhow::ensure!(
                    !commit.is_empty() && commit.bytes().all(|c| c.is_ascii_hexdigit()),
                    "invalid question source commit"
                );
                format!("source:{commit}")
            }
        };
        Ok((self.operation, target))
    }
}

/// The conductor's decision for one task. Deliberately has no `priority`
/// field: see this module's doc.
#[derive(Debug, Clone, Default, Deserialize)]
pub struct Decision {
    /// Task id, expected to be copied verbatim from what it was shown.
    pub id: String,
    /// Ids this task should be blocked on. Meaningful only for a runnable
    /// (`queued`) task, or a machine-held task whose missing-only decision
    /// is unconfirmed against the queue. Ignored otherwise.
    #[serde(default)]
    pub blocked_by: Vec<String>,
    /// Dependencies claimed missing as the sole reason for this question or
    /// hold. Must name references in `blocked_by`. Empty (including legacy
    /// replies) means the question/hold may have an independent purpose and
    /// must be preserved. Never set for decisions needing separate consent.
    #[serde(default)]
    pub missing_dependencies: Vec<String>,
    /// One line explaining the block or the recovery.
    #[serde(default)]
    pub reason: Option<String>,
    /// Recovery for a stalled or finished task. For a runnable (`queued`)
    /// one, only [`Recovery::Hold`] has any effect. An independent hold takes
    /// precedence over `blocked_by`, so dependency completion cannot release it.
    /// Use a hold when the operator already said the task must not compete,
    /// rather than asking a `question` that restates that answer. `Requeue`, `Review`,
    /// and `Done` have no meaning for a task that is already in line.
    #[serde(default)]
    pub recovery: Option<Recovery>,
    /// A question for the operator. When present, [`apply`] files it (unless
    /// one is already open for this task) and blocks the task on its id
    /// instead of acting on `blocked_by` or `recovery`. Only a missing-only
    /// decision explicitly marked by [`Self::missing_dependencies`] may be
    /// replaced with dependency waiting unless the queue confirms missing blockers.
    #[serde(default)]
    pub question: Option<String>,
    /// Fixed answers for `question`, if it has any. Empty means free text.
    #[serde(default)]
    pub choices: Vec<String>,
    /// Explicit operations keyed by exact choice labels; never inferred from prose.
    #[serde(default)]
    pub actions: BTreeMap<String, ChoiceAction>,
    /// Stable operation and concrete target of a question. Missing on legacy
    /// decisions: those share the task's existing cause, regardless of prose.
    #[serde(default)]
    pub question_decision: Option<QuestionDecision>,
    /// Task or question ids carrying independently verifiable new blocking evidence.
    #[serde(default)]
    pub evidence: Vec<String>,
}

/// The conductor's whole reply for one cycle.
///
/// `decisions` is deliberately **not** `#[serde(default)]`, unlike every
/// other field in this module. [`verdict::extract_json`] disambiguates
/// between several balanced `{...}` spans in one reply by trying the type the
/// caller wants against each of them, last first, and keeping the first that
/// fits - which only works when a span that is not really the answer can
/// fail to fit. A `Verdict` with no required field at all would make every
/// span fit, including a `{}` left by stray trailing prose, and the reply's
/// real `decisions` - earlier in the text - would never be reached. Requiring
/// the key costs nothing: the prompt already asks for it on every reply, `[]`
/// included.
#[derive(Debug, Clone, Default, Deserialize)]
pub struct Verdict {
    /// One entry per task the conductor chose to say something about. A task
    /// left out of this list is left exactly as it was.
    pub decisions: Vec<Decision>,
}

/// A view of a task built for [`prompt::conduct`], shared by the runnable and
/// stalled sections.
fn view(t: &Task, max_attempts: usize) -> prompt::ConductTask {
    prompt::ConductTask {
        id: t.id.clone(),
        title: t.title.clone(),
        instruction: t.instruction.clone(),
        repo: t.repo.display().to_string(),
        priority: t.priority,
        status: t.status.as_str().to_owned(),
        attempts: t.attempts,
        max_attempts: t.effective_attempt_limit(max_attempts),
        last_error: t.last_error.clone(),
        hold_reason: t.hold_reason.clone(),
        held_at: t.held_at.map(|at| at.to_string()),
        hold_source: t.hold_source.map(|source| source.label().to_owned()),
        blocked_by: t.blocked_by.clone(),
        answers: t
            .answers
            .iter()
            .map(|a| prompt::ConductAnswer {
                question: a.question.clone(),
                answer: a.answer.clone(),
            })
            .collect(),
        operator_resume: t.resumption.as_ref().map(|r| format!(
            "Explicit operator resumption generation {} via {} at {}. Approved instruction: {}. \
             The first {} historical answers and prior hold ({:?}) are superseded as waiting premises. \
             To block again cite evidence ids from a later owned question, changed dependency, or new failed run; \
             wording alone is insufficient.",
            r.generation, r.source, r.at, r.instruction, r.answers_through, r.cleared_reason
        )).or_else(|| t.resume_override.as_ref().map(|o| {
            format!(
                "the operator explicitly answered \"resume\" at {}; do not hold this \
                 task again for the same reason unless there is new information",
                o.at
            )
        })),
    }
}

/// Did the operator answer a `magi ask` choice with a `resume` action that
/// this task has not yet acted on? Then `Recovery::Requeue` must not turn the
/// task into a fresh competition either.
fn pinned_resume(task: &Task) -> bool {
    task.resume_override
        .as_ref()
        .is_some_and(|o| o.pinned_run.is_some())
}

/// Verify references independently of the model's reason text. Old evidence
/// cannot become new merely by being described differently.
fn new_blocking_evidence(
    queue: &Queue,
    questions: &Questions,
    task: &Task,
    d: &Decision,
) -> Vec<String> {
    let Some(r) = &task.resumption else {
        return Vec::new();
    };
    d.evidence
        .iter()
        .filter_map(|id| {
            let version = if let Ok(q) = questions.get(id) {
                (q.asked_at > r.at
                    && (q.run == task.id || task.runs.contains(&q.run))
                    && q.node != NODE
                    && q.status != crate::ask::QuestionStatus::Abandoned)
                    .then(|| {
                        format!(
                            "question:{id}:{}:{:?}:{}",
                            q.asked_at,
                            q.status,
                            q.resolution().unwrap_or_default()
                        )
                    })
            } else if d.blocked_by.contains(id) {
                queue
                    .get(id)
                    .ok()
                    .filter(|dep| {
                        dep.id != task.id
                            && dep.status != TaskStatus::Done
                            && (dep.created_at > r.at
                                || dep.held_at.is_some_and(|at| at > r.at)
                                || dep.operator_decided_at.is_some_and(|at| at > r.at)
                                || dep.passes.iter().any(|p| p.settled_at > r.at)
                                || (dep.status == TaskStatus::Blocked
                                    && dep.blocked_at.is_some_and(|at| at > r.at)))
                    })
                    .map(|dep| {
                        format!(
                            "dependency:{id}:{:?}:{:?}:{:?}",
                            dep.status,
                            dep.chat_notice_key(),
                            dep.hold_notice_cause
                        )
                    })
            } else if task.runs.iter().any(|run| run == id) {
                RunState::load(id)
                    .ok()
                    .filter(|run| {
                        // A resumed run keeps its id. Only a pass started after
                        // approval (or a newly created legacy run) is new evidence.
                        run.updated_at > r.at
                            && run
                                .passes
                                .last()
                                .map_or(run.created_at > r.at, |p| p.started_at > r.at)
                            && matches!(
                                run.status,
                                crate::run::RunStatus::Failed
                                    | crate::run::RunStatus::Blocked
                                    | crate::run::RunStatus::Stalled
                            )
                    })
                    .map(|run| {
                        format!(
                            "run:{id}:{:?}:{:?}",
                            run.status,
                            run.passes.last().map(|p| p.index)
                        )
                    })
            } else {
                None
            };
            version.filter(|v| !r.blocking_evidence.contains(v))
        })
        .collect()
}

/// Durable approval is enforced by verified evidence at the mutation boundary.
/// A pinned run stays protected; legacy transient overrides keep their original
/// bounded contradiction policy until an explicit new approval replaces it.
fn may_hold(task: &mut Task, reason: &str) -> bool {
    if pinned_resume(task) {
        return false;
    }
    if task.resumption.is_some() {
        return true; // The mutation boundary already verified new evidence.
    }
    let Some(o) = task.resume_override.as_mut() else {
        return true;
    };
    if o.forced || o.pinned_run.is_some() {
        tracing::warn!(
            "conductor tried to hold task {} after the operator forced a resume: {reason}",
            task.id
        );
        return false;
    }
    if o.conductor_rehold.is_some() {
        return false;
    }
    o.conductor_rehold = Some(reason.to_owned());
    true
}

/// Severity as a lowercase word, matching how `crate::verdict::Severity` is
/// spelled everywhere else an operator or a model reads it.
fn severity_str(s: crate::verdict::Severity) -> &'static str {
    match s {
        crate::verdict::Severity::Nit => "nit",
        crate::verdict::Severity::Minor => "minor",
        crate::verdict::Severity::Major => "major",
        crate::verdict::Severity::Blocker => "blocker",
    }
}

/// The branch a task's last run left behind, if the tally ever ran on it -
/// what [`Recovery::Review`] reopens. Derived from `crate::run::RunState`
/// alone, never from anything the conductor wrote, so a hallucinated branch
/// name can never reach `crate::graph::Runner::review`.
fn surviving_branch(task: &Task) -> Option<String> {
    let last = task.runs.last()?;
    let state = RunState::load(last).ok()?;
    if !crate::daemon::compatible_run_instruction(&state, task) {
        return None;
    }
    state.winner().map(|c| c.branch.clone())
}

/// The reason to record when the conductor holds a `failed`/`held` task via
/// [`Recovery::Hold`]. Always `Some`, never a bare `d.reason.clone()`.
///
/// [`Task::hold_machine`] only overwrites [`Task::hold_reason`] when given
/// one, precisely so a stalled task's existing diagnosis survives a
/// decision that has nothing new to add. That is the right default when the
/// task was not already `held` - but a task that *is* already `held`, and
/// is being held again here, is a different case: its current
/// `hold_reason` may still read as a cause `crate::triage` knows how to
/// re-check on its own (a disk-pressure message, say - see
/// `triage::machine_cause_resolved`), and if the model gives no reason,
/// leaving that text untouched would make this decision - the conductor
/// choosing, informed by the operator's own answer, to keep the task held
/// anyway - indistinguishable from the original, never-reconsidered hold.
/// `crate::triage` would then read the stale text the next time its one
/// recognised cause looks resolved and release the task straight through
/// the decision this call was recording. Prepending (not appending) the new
/// note keeps the old text as context without leaving the string starting
/// with whatever pattern `crate::triage` matched before.
///
/// Two bounds keep the string from growing, which it once did without limit
/// (every re-hold nested the whole previous reason one level deeper, and every
/// change relit the task's notice): a note equal to the current reason - or to
/// its outermost note - adds nothing, so the result is `None` and the caller
/// writes nothing; and only ONE `(previously: ...)` level is ever kept, the
/// prior being cut back to its outermost note before it is embedded.
fn reaffirmed_hold_reason(task: &Task, d: &Decision) -> Option<String> {
    let note = match &d.reason {
        Some(reason) => reason.clone(),
        None => match task.answers.last() {
            Some(a) => format!(
                "conduct held this again with no new reason given; last operator \
                 answer on record: {}",
                a.answer
            ),
            None => "conduct held this again with no reason given".to_owned(),
        },
    };
    match task.hold_reason.as_deref() {
        Some(prior) if !prior.is_empty() => {
            let outer = outermost_hold_note(prior);
            if note.trim() == prior.trim() || note.trim() == outer {
                None
            } else {
                Some(format!("{note}\n\n(previously: {outer})"))
            }
        }
        _ => Some(note),
    }
}

/// Separator [`reaffirmed_hold_reason`] puts between a note and the reason it
/// replaced.
const PREVIOUSLY: &str = "\n\n(previously: ";

/// A hold reason without any `(previously: ...)` tail: the text before the
/// first separator, trimmed.
fn outermost_hold_note(reason: &str) -> &str {
    reason.split(PREVIOUSLY).next().unwrap_or(reason).trim()
}

/// The conductor's stated reason for a hold, or a stand-in when it gave none.
fn hold_note(d: &Decision) -> String {
    d.reason
        .clone()
        .unwrap_or_else(|| "(no reason given)".to_owned())
}

/// Everything the conductor is shown about a `failed`/`held` task's last run.
async fn outcome_for(task: &Task, repo: &Path) -> prompt::ConductOutcome {
    let Some(run_id) = task.runs.last().cloned() else {
        return prompt::ConductOutcome {
            run_id: "(none)".to_owned(),
            unreadable: Some("this task has not produced a run yet".to_owned()),
            run_status: None,
            open_findings: Vec::new(),
            rounds_used: 0,
            rounds_max: 0,
            rounds: Vec::new(),
            branch: None,
            branch_head: None,
            references: None,
            empty_candidate: false,
        };
    };
    let state = match RunState::load(&run_id) {
        Ok(s) => s,
        Err(e) => {
            // The exact failure this feature exists to stop hiding: a schema
            // mismatch (or any other unreadable state) must never be treated
            // as "nothing to recover" - it is surfaced here, verbatim, rather
            // than swallowed into a quiet re-competition.
            tracing::warn!(
                "conductor: could not read run {run_id} for task {}: {e:#}",
                task.short()
            );
            return prompt::ConductOutcome {
                run_id,
                unreadable: Some(format!("{e:#}")),
                run_status: None,
                open_findings: Vec::new(),
                rounds_used: 0,
                rounds_max: 0,
                rounds: Vec::new(),
                branch: None,
                branch_head: None,
                references: None,
                empty_candidate: false,
            };
        }
    };

    let finding_view = |f: &crate::verdict::Finding| prompt::ConductFinding {
        id: f.id.clone(),
        title: f.title.clone(),
        severity: severity_str(f.severity).to_owned(),
    };
    let open_findings = state
        .open_findings()
        .into_iter()
        .map(finding_view)
        .collect();
    let rounds = state
        .reviews
        .iter()
        .map(|r| prompt::ConductRound {
            round: r.round,
            findings: r
                .reviews
                .iter()
                .flat_map(|rec| rec.findings.iter())
                .map(finding_view)
                .collect(),
            addressed: r
                .fix
                .as_ref()
                .map(|fx| fx.addressed.clone())
                .unwrap_or_default(),
            rejected: r
                .fix
                .as_ref()
                .map(|fx| {
                    fx.rejected
                        .iter()
                        .map(|rej| prompt::ConductRejection {
                            id: rej.id.clone(),
                            why: rej.why.clone(),
                        })
                        .collect()
                })
                .unwrap_or_default(),
        })
        .collect();
    let branch = state.winner().map(|c| c.branch.clone());
    let branch_head = match &branch {
        Some(b) => crate::git::rev_parse(repo, b)
            .await
            .ok()
            .map(|h| h.chars().take(8).collect()),
        None => None,
    };

    prompt::ConductOutcome {
        run_id,
        unreadable: None,
        run_status: Some(state.status.as_str().to_owned()),
        open_findings,
        rounds_used: state.reviews.len(),
        rounds_max: state.config.graph.review_rounds,
        rounds,
        branch,
        branch_head,
        references: crate::refs::describe(&state.seeds),
        empty_candidate: state.merge.as_ref().is_some_and(|m| m.empty),
    }
}

/// Whether the task's latest run's winner branch already has an open pull
/// request into the run's own base - a fact the repository can answer, so the
/// operator is never asked it. `None` when there is no run or winner to check.
async fn open_pr_fact(task: &Task, repo: &Path) -> Option<String> {
    let id = task.runs.last()?;
    let state = match RunState::load(id) {
        Ok(s) => s,
        Err(e) => return Some(format!("could not check open pull requests: {e:#}")),
    };
    let branch = state.winner()?.branch.clone();
    let base = state.base_branch.clone();
    match crate::land::find_open_pr(repo, &branch, &base).await {
        Ok(crate::land::OpenPr::None) => None,
        Ok(crate::land::OpenPr::One { url, .. }) => Some(format!(
            "pull request {url} is already open for {branch} into {base}"
        )),
        Ok(crate::land::OpenPr::Many(urls)) => Some(format!(
            "several pull requests are already open for {branch} into {base}: {}",
            urls.join(" ")
        )),
        Err(e) => Some(format!("could not check open pull requests: {e:#}")),
    }
}

/// Append what the repository says about the branches and commits a task
/// names to every question the conductor is about to file, so the operator is
/// never asked a fact git can answer ("is it already on main?"). Done here,
/// in code, rather than trusted to the model: a question the model wrote
/// without checking still reaches the operator with the answer attached.
/// When it cannot be checked the question says so instead of guessing.
async fn attach_facts(cfg: &Config, repo: &Path, queue: &Queue, verdict: &mut Verdict) {
    for d in verdict
        .decisions
        .iter_mut()
        .filter(|d| d.question.is_some())
    {
        let Ok(task) = queue.get(&d.id) else {
            continue;
        };
        let text = format!("{}\n{}", task.title, task.instruction);
        let pr_fact = open_pr_fact(&task, repo_for(&task, repo).as_path()).await;
        if crate::refs::scan(&text).is_empty() {
            if let (Some(fact), Some(q)) = (pr_fact, d.question.as_mut()) {
                q.push_str(&format!(
                    "\n\nChecked against the repository (magi did this, not the model):\n{fact}"
                ));
            }
            continue;
        }
        let repo = repo_for(&task, repo);
        let remote = &cfg.merge.remote;
        let base = crate::git::merge_base_branch(&repo, remote, cfg.merge.base.as_deref())
            .await
            .ok();
        let facts = match base {
            Some(base) => {
                let base_name = base.clone();
                let tracking = format!("{remote}/{base}");
                // Best effort: a stale tracking ref would report work that
                // has since landed as still missing from the base.
                let refreshed = crate::git::fetch(&repo, remote, &base)
                    .await
                    .is_ok_and(|o| o.ok());
                // Only the remote's tip counts: a local branch of the same
                // name is whatever the checkout happens to hold.
                let against = tracking;
                match crate::git::rev_parse(&repo, &against).await {
                    Ok(tip) => crate::refs::describe(
                        &crate::refs::resolve(&repo, &tip, remote, &text).await,
                    )
                    .map(|facts| {
                        if refreshed {
                            facts
                        } else {
                            format!(
                                "{facts}\n(could not fetch {remote}/{base_name}: this is \
                                 against the last fetched `{against}`, which may be behind \
                                 the remote)"
                            )
                        }
                    }),
                    Err(_) => Some(format!(
                        "could NOT be checked against the repository: {against} is not \
                         available here, so whether the work is in the base is unknown"
                    )),
                }
            }
            None => Some("could not check the repository: no base branch known".to_owned()),
        };
        let facts = match (facts, pr_fact) {
            (Some(f), Some(p)) => Some(format!("{f}\n{p}")),
            (f, p) => f.or(p),
        };
        if let (Some(facts), Some(q)) = (facts, d.question.as_mut()) {
            q.push_str(&format!(
                "\n\nChecked against the repository (magi did this, not the model):\n{facts}"
            ));
        }
    }
}

/// A `failed`/`held` task together with how its last run ended.
async fn finished_view(t: &Task, repo: &Path, max_attempts: usize) -> prompt::ConductFinished {
    prompt::ConductFinished {
        task: view(t, max_attempts),
        outcome: outcome_for(t, &repo_for(t, repo)).await,
    }
}

/// The repository containing a task's branch. A task filed without a
/// repository uses the daemon's repository, exactly as its later attempt does.
fn repo_for(task: &Task, fallback: &Path) -> PathBuf {
    if task.repo.as_os_str().is_empty() || task.repo == Path::new(".") {
        fallback.to_path_buf()
    } else {
        task.repo.clone()
    }
}

/// Apply one decision to the queue and the question store.
///
/// Takes the task's own claim before touching it: a model call spans a whole
/// agent turn, and the queue can have moved on by the time its answer comes
/// back. A claim that cannot be taken means something else owns this task
/// right now - most often a live daemon mid-competition on it - so the
/// conductor's now-stale view of it is dropped rather than raced against; see
/// `crate::queue::Queue::claim`'s own doc on why a claim is proof, not a
/// guess.
///
/// A decision is matched against the task's *current* status, re-read under
/// the claim, not against whichever section of the prompt it came from: a
/// `blocked_by` only takes effect on a `queued` task, and `recovery` only on
/// one `running` (stalled) or `failed`/`held`, so a decision that no longer
/// matches what the task actually is - it moved on between the read that
/// built the prompt and this write - changes nothing.
fn apply_one(
    queue: &Queue,
    questions: &Questions,
    d: &Decision,
    snapshot: Option<&Task>,
) -> Result<()> {
    let _claim = queue
        .claim(&d.id)
        .with_context(|| format!("task {} is claimed elsewhere right now", d.id))?;
    let mut task = queue.get(&d.id).context("no such task")?;

    // Compare the actual input, not a generation echoed by the model. Even
    // question creation must be discarded after an intervening operator edit.
    if snapshot.is_some_and(|old| decision_input(old) != decision_input(&task)) {
        return Ok(());
    }
    let blocking =
        d.question.is_some() || !d.blocked_by.is_empty() || d.recovery == Some(Recovery::Hold);
    let evidence = new_blocking_evidence(queue, questions, &task, d);
    if blocking && task.resumption.is_some() && evidence.is_empty() {
        crate::notices::raise(crate::notices::conductor_resumption(
            &task.id,
            task.short(),
            d.reason.as_deref(),
            &d.blocked_by,
            &d.evidence,
            d.question.is_some(),
        ));
        return Ok(());
    }

    if blocking && !evidence.is_empty() {
        let mut cause = evidence.clone();
        cause.sort();
        cause.dedup();
        task.notice_cause(
            &format!("conductor-evidence:{}", cause.join(",")),
            None,
            None,
        );
    }
    if blocking {
        if let Some(r) = task.resumption.as_mut() {
            r.blocking_evidence.extend(evidence);
        }
    }

    // A conductor answer is never operator authorization.  In particular,
    // do this before questions and blocking too: either would reclassify a
    // manual hold and let a later deterministic resolver queue it.
    if task.operator_held() {
        return Ok(());
    }

    // A claimed task may have deferred the pre-scheduling triage sweep.
    // Leave an open or answered-unapplied question to that sweep rather
    // than move the task out from under it.
    if task.status == TaskStatus::Held && crate::triage::pending_for(questions, &task) {
        return Ok(());
    }

    // The operator's `resume` action is waiting for its turn: a question or a
    // dependency would park the task before the daemon can run it.
    let pinned = pinned_resume(&task);
    if pinned && (d.question.is_some() || !d.blocked_by.is_empty()) {
        return Ok(());
    }

    // A missing-only decision with unverifiable aliases is not evidence for
    // a question or hold. Do not guess that two ambiguous/unknown references
    // mean the same record, or treat failure to prove that as proof of absence.
    if matches!(task.status, TaskStatus::Queued | TaskStatus::Held)
        && !d.missing_dependencies.is_empty()
        && (d.question.is_some() || d.recovery == Some(Recovery::Hold))
        && d.missing_dependencies
            .iter()
            .any(|id| !d.blocked_by.contains(id))
        && d.missing_dependencies
            .iter()
            .chain(&d.blocked_by)
            .any(|id| {
                matches!(
                    crate::queue::dependency(queue, questions, id),
                    crate::queue::Dependency::Ambiguous | crate::queue::Dependency::Unknown
                )
            })
    {
        return Ok(());
    }

    // Only an explicit missing-only claim can justify replacing a question
    // or hold. Existing prerequisites alone say nothing about independent
    // consent, destructive-operation questions, or other reasons to stay held.
    // Ambiguous or unreadable inventories cannot confirm absence either: keep
    // the original reference waiting until it can be resolved authoritatively.
    if matches!(task.status, TaskStatus::Queued | TaskStatus::Held)
        && !d.missing_dependencies.is_empty()
        && d.missing_dependencies.iter().all(|id| {
            let claim = crate::queue::dependency(queue, questions, id);
            claim != crate::queue::Dependency::Missing
                && d.blocked_by.iter().any(|blocker| {
                    blocker == id
                        || (matches!(
                            &claim,
                            crate::queue::Dependency::Task(_)
                                | crate::queue::Dependency::Question(_)
                                | crate::queue::Dependency::Deleted(_)
                        ) && crate::queue::dependency(queue, questions, blocker) == claim)
                })
        })
        && (d.question.is_some() || d.recovery == Some(Recovery::Hold))
        && crate::queue::missing_blockers(queue, questions, &d.blocked_by).is_empty()
    {
        let mut ids = d.blocked_by.clone();
        crate::queue::normalize_blockers(queue, questions, &mut ids);
        let reason = format!("Waiting on dependencies: {}", ids.join(", "));
        task.block(ids, Some(reason));
        return queue.put(&mut task);
    }

    if let Some(text) = &d.question {
        if task.status == TaskStatus::Done {
            return Ok(());
        }
        let mut held = task.clone();
        held.status = TaskStatus::Held;
        let targets: BTreeSet<_> = d
            .blocked_by
            .iter()
            .filter_map(|id| {
                if let Ok(dep) = queue.get(id) {
                    Some(format!("task:{id}:{:?}", dep.chat_notice_key()))
                } else if questions.get(id).is_ok() {
                    Some(format!("question:{id}"))
                } else {
                    None
                }
            })
            .collect();
        let decision = d
            .question_decision
            .as_ref()
            .and_then(|q| match q.identity(&task) {
                Ok(identity) => Some(identity),
                Err(error) => {
                    // Invalid optional metadata must not discard the question
                    // or leave a runnable task without its decision barrier.
                    tracing::warn!(task = %task.id, %error, "ignoring invalid question decision target");
                    None
                }
            });
        let context_value =
            serde_json::json!([&task.instruction, held.chat_notice_key(), targets, decision]);
        let context = serde_json::to_string(&context_value)?;
        // An answer alone does not justify asking the same decision again.
        // New producer evidence, an instruction edit or a different dependency
        // target can open another question; rewording cannot.
        if questions.list().iter().any(|q| {
            q.node == NODE
                && q.run == task.id
                && q.status == crate::ask::QuestionStatus::Answered
                && q.decision_context.as_ref().is_some_and(|stored| {
                    if stored == &context {
                        return true;
                    }
                    // Missing metadata cannot manufacture a new target. This
                    // also baselines older contexts whose last item was labels.
                    decision.is_none()
                        && serde_json::from_str::<serde_json::Value>(stored)
                            .ok()
                            .and_then(|v| {
                                v.as_array().map(|items| {
                                    items.len() == 4
                                        && items[..3]
                                            == context_value.as_array().expect("context")[..3]
                                })
                            })
                            == Some(true)
                })
        }) {
            return Ok(());
        }
        // `Question::run` is a task id for conductor questions, but ordinary
        // graph questions use it as a run id. A coincidental equality must
        // not block this task on an answer meant for another node.
        let question_id = match questions
            .list()
            .into_iter()
            .find(|q| q.status.open() && q.node == NODE && q.run == task.id)
        {
            Some(existing) => existing.id,
            None => {
                let mut q = Question::new(
                    task.id.clone(),
                    NODE.to_owned(),
                    SEAT.to_owned(),
                    text.clone(),
                    d.reason.clone().unwrap_or_default(),
                    d.choices.clone(),
                );
                q.actions = d.actions.clone();
                crate::choice_effect::executable_conductor(&mut q);
                q.decision_context = Some(context);
                // The wait is handed to a deputy (`crate::deputy`), so a
                // free-text reply reaches an agent that knows why this was
                // asked. The conductor still never blocks: this only records
                // what the deputy will be told, and `serve` starts it.
                q.deputy = Some(Deputy::new(crate::deputy::brief(
                    &task.id,
                    d.reason.as_deref().unwrap_or_default(),
                    &q.choices,
                    &q.actions,
                )));
                if task.repo.is_dir() && task.repo != Path::new(".") {
                    q.cwd = Some(task.repo.to_string_lossy().into_owned());
                }
                questions.put_executable(&mut q)?;
                q.id
            }
        };
        task.block(vec![question_id], d.reason.clone());
        return queue.put(&mut task);
    }

    match task.status {
        // See `Decision::recovery`'s doc: the only lever a runnable task has
        // besides `blocked_by` is holding it outright, for a task whose
        // answers already say it should not compete again.
        TaskStatus::Queued if d.recovery == Some(Recovery::Hold) => {
            if may_hold(&mut task, &hold_note(d)) {
                task.hold_machine(d.reason.clone());
                queue.put(&mut task)?;
            }
        }
        TaskStatus::Queued if !d.blocked_by.is_empty() => {
            let mut ids = d.blocked_by.clone();
            crate::queue::normalize_blockers(queue, questions, &mut ids);
            task.block(ids, d.reason.clone());
            queue.put(&mut task)?;
        }
        TaskStatus::Running => match d.recovery {
            Some(Recovery::Requeue) if pinned_resume(&task) => {}
            Some(Recovery::Requeue) => {
                task.requeue();
                queue.put(&mut task)?;
            }
            Some(Recovery::Hold) if may_hold(&mut task, &hold_note(d)) => {
                task.hold_machine(d.reason.clone());
                queue.put(&mut task)?;
            }
            // `Review` reopens a branch, which only makes sense once a run
            // has actually stopped; a task still `running` has nothing to
            // reopen yet.
            _ => {}
        },
        TaskStatus::Failed | TaskStatus::Held => match d.recovery {
            // The operator picked a specific run to continue; a fresh
            // competition would throw that run away.
            Some(Recovery::Requeue) if pinned_resume(&task) => {}
            Some(Recovery::Requeue) => {
                task.requeue();
                queue.put(&mut task)?;
            }
            Some(Recovery::Hold) => {
                // Decided before `may_hold`, which spends the one override: a
                // note that adds nothing writes nothing (and so raises no
                // notice and moves no queue revision).
                if let Some(reason) = reaffirmed_hold_reason(&task, d) {
                    if may_hold(&mut task, &hold_note(d)) {
                        task.hold_machine(Some(reason));
                        queue.put(&mut task)?;
                    }
                }
            }
            Some(Recovery::Review) => {
                if let Some(branch) = surviving_branch(&task) {
                    task.request_review(branch);
                    queue.put(&mut task)?;
                }
                // No survivable branch: a decision naming `review` here is
                // simply not actionable, and is dropped rather than guessed
                // at - `crate::daemon` applies the same "no branch, no
                // review" rule again, from its own read, right before it
                // would actually start the run.
            }
            Some(Recovery::Done) => {
                task.succeed();
                // Same reason `magi task done` and the web UI's equivalent
                // do this: the conductor closing a task by hand is just as
                // much a finished story as the loop's own settle path.
                crate::daemon::supersede_prior_runs(&task, &crate::run::home());
                queue.put(&mut task)?;
            }
            None => {}
        },
        // `queued` with nothing to block on, `done`, or already `blocked`:
        // nothing for this decision to do.
        _ => {}
    }
    Ok(())
}

/// Apply every decision in `verdict`. A single bad decision - a task id that
/// no longer exists, one already claimed elsewhere - is logged and skipped
/// rather than losing every other decision in the same reply.
pub fn apply(queue: &Queue, questions: &Questions, verdict: &Verdict) -> Result<()> {
    for d in &verdict.decisions {
        if let Err(e) = apply_one(queue, questions, d, None) {
            tracing::warn!("conductor decision for task {}: {e:#}", d.id);
        }
    }
    Ok(())
}

/// Where the conductor's seat is kept between turns, so the daemon waiter can
/// resume it when the owner answers a question it asked.
///
/// A graph seat's session lives in its run's `RunState`; the conductor has no
/// run, and until this file its seat existed only in memory.
pub fn seat_path(home: &Path) -> PathBuf {
    home.join("conduct").join("seat.json")
}

/// The seat the conductor last used, if it has taken a turn.
pub fn load_seat(home: &Path) -> Option<SeatState> {
    serde_json::from_str(&std::fs::read_to_string(seat_path(home)).ok()?).ok()
}

fn busy_path(home: &Path) -> PathBuf {
    home.join("conduct").join("busy")
}

/// Is a conductor turn in flight right now?
///
/// A marker file rather than shared memory because the waiter reads it and the
/// conductor is not necessarily in its process. A marker older than one turn's
/// timeout (plus slack) was left by a turn that died and counts for nothing.
pub fn busy(home: &Path) -> bool {
    std::fs::metadata(busy_path(home))
        .and_then(|m| m.modified())
        .ok()
        .and_then(|t| t.elapsed().ok())
        .is_some_and(|age| age < TURN_TIMEOUT + Duration::from_secs(30))
}

/// Removes the busy marker when a turn ends, however it ends.
struct Busy(PathBuf);

impl Busy {
    fn mark(home: &Path) -> Self {
        let path = busy_path(home);
        if let Some(dir) = path.parent() {
            let _ = std::fs::create_dir_all(dir);
        }
        let _ = std::fs::write(&path, std::process::id().to_string());
        Self(path)
    }
}

impl Drop for Busy {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.0);
    }
}

/// The conductor's state across polling cycles: its own CLI-side conversation
/// and the last (revision, stalled ∪ finished ids) pair it actually acted on.
#[derive(Debug, Default)]
pub struct Conductor {
    seat: Option<SeatState>,
    last_seen: Option<(u64, BTreeSet<String>)>,
    /// Content fingerprint of each held task the model was last shown, see
    /// [`input_fingerprint`]. A held task whose fingerprint still matches is
    /// settled: the conductor's own rewrites of it do not count as news.
    considered: BTreeMap<String, String>,
}

/// What the conductor's decision about a held task is a function of: the task
/// without the fields the conductor itself rewrites (`updated_at`,
/// `hold_reason`, the recorded re-hold). Independent of how the model words a
/// repeated decision.
fn decision_input(task: &Task) -> serde_json::Value {
    let mut v = serde_json::to_value(task).unwrap_or_default();
    if let Some(o) = v.as_object_mut() {
        o.remove("chat_notice");
        o.remove("chat_notices");
        // A delivery write changes only bookkeeping, not the decision input.
        o.remove("updated_at");
    }
    v
}

fn input_fingerprint(task: &Task) -> String {
    let mut v = decision_input(task);
    if let Some(o) = v.as_object_mut() {
        o.remove("hold_reason");
        if let Some(ro) = o.get_mut("resume_override").and_then(|r| r.as_object_mut()) {
            ro.remove("conductor_rehold");
        }
    }
    v.to_string()
}

impl Conductor {
    /// A conductor that has never run.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Held tasks among `stalled` / `finished` whose input is unchanged since
    /// the model last saw them. Their files are left out of the revision, so
    /// the conductor re-holding one (however it words it) is not news, while
    /// an owner's answer changes the fingerprint and brings the file back in.
    fn settled(
        considered: &BTreeMap<String, String>,
        stalled: &[Task],
        finished: &[Task],
    ) -> BTreeSet<String> {
        stalled
            .iter()
            .chain(finished)
            .filter(|t| t.status == TaskStatus::Held)
            .filter(|t| considered.get(&t.id) == Some(&input_fingerprint(t)))
            .map(|t| t.id.clone())
            .collect()
    }

    fn snapshot_with(
        considered: &BTreeMap<String, String>,
        queue: &Queue,
        stalled: &[Task],
        finished: &[Task],
    ) -> (u64, BTreeSet<String>) {
        let ids = stalled
            .iter()
            .chain(finished)
            .map(|t| t.id.clone())
            .collect();
        let skip = Self::settled(considered, stalled, finished);
        (queue.revision_excluding(&skip), ids)
    }

    fn snapshot(
        &self,
        queue: &Queue,
        stalled: &[Task],
        finished: &[Task],
    ) -> (u64, BTreeSet<String>) {
        Self::snapshot_with(&self.considered, queue, stalled, finished)
    }

    /// Whether calling the conductor could possibly do anything different
    /// from last time: [`Queue::revision`] moved, or the set of stalled and
    /// finished task ids changed.
    ///
    /// Deliberately **not** "stalled or finished is non-empty" - a task
    /// sitting stalled or finished with nobody changing anything about it
    /// must not be re-shown to the model every single poll forever; only a
    /// change in *which* tasks are stalled or finished, or a queue write
    /// changing something about a runnable one, is worth another look.
    ///
    /// Cheap and config-free on purpose, so `crate::daemon`'s poll loop can
    /// skip `Config::discover`'s synchronous I/O entirely on a cycle where
    /// this says no - which [`Conductor::maybe_run`] would otherwise only
    /// discover after paying for that load. Both ask the identical question,
    /// from the same [`Conductor::last_seen`], so they can never disagree
    /// about whether there is anything to look at.
    #[must_use]
    pub fn worth_a_look(&self, queue: &Queue, stalled: &[Task], finished: &[Task]) -> bool {
        self.last_seen.as_ref() != Some(&self.snapshot(queue, stalled, finished))
    }

    /// Call the conductor once, unless nothing has changed since the last
    /// time it was worth calling - see [`Conductor::worth_a_look`], the exact
    /// same test. Never fatal - see this module's doc.
    #[allow(clippy::too_many_arguments)]
    pub async fn maybe_run(
        &mut self,
        cfg: &Config,
        repo: &Path,
        queue: &Queue,
        questions: &Questions,
        home: &Path,
        queued: &[Task],
        stalled: &[Task],
        finished: &[Task],
        max_attempts: usize,
    ) {
        if self.last_seen.as_ref() == Some(&self.snapshot(queue, stalled, finished)) {
            return;
        }
        // What the model is about to be shown becomes "considered" before the
        // snapshot is taken, so its own re-hold writes land in the excluded set.
        self.considered = stalled
            .iter()
            .chain(finished)
            .filter(|t| t.status == TaskStatus::Held)
            .map(|t| (t.id.clone(), input_fingerprint(t)))
            .collect();
        self.last_seen = Some(self.snapshot(queue, stalled, finished));
        if let Err(e) = self
            .run_once(
                cfg,
                repo,
                queue,
                questions,
                home,
                queued,
                stalled,
                finished,
                max_attempts,
            )
            .await
        {
            // The conductor's own write moves the revision, so one more cycle
            // follows; a repeat decision writes nothing (see
            // `reaffirmed_hold_reason`), which is what ends the loop. The
            // revision is deliberately never re-read here: it cannot tell our
            // write from an owner's concurrent update.
            tracing::warn!("conductor: {e:#}");
        }
    }

    #[allow(clippy::too_many_arguments)]
    async fn run_once(
        &mut self,
        cfg: &Config,
        repo: &Path,
        queue: &Queue,
        questions: &Questions,
        home: &Path,
        queued: &[Task],
        stalled: &[Task],
        finished: &[Task],
        max_attempts: usize,
    ) -> Result<()> {
        if queued.is_empty() && stalled.is_empty() && finished.is_empty() {
            return Ok(());
        }

        let primary = cfg
            .resolve_roles()
            .context("resolving the conductor seat")?
            .conductor;
        // A string keeps today's resolution exactly (no CLI preflight here;
        // an unavailable CLI fails at invocation). Only a multi-id array
        // builds a chain, whose members are each tried at most once.
        let chain = match cfg.roles.conductor.as_ref() {
            Some(c) if c.ids().len() > 1 => {
                agent::pick_chain(&cfg.agents, Some(c), &agent::installed, "conductor")?
            }
            _ => vec![primary],
        };

        let runnable_views: Vec<prompt::ConductTask> =
            queued.iter().map(|t| view(t, max_attempts)).collect();
        let stalled_views: Vec<prompt::ConductTask> =
            stalled.iter().map(|t| view(t, max_attempts)).collect();
        let mut finished_views = Vec::with_capacity(finished.len());
        for t in finished {
            finished_views.push(finished_view(t, repo, max_attempts).await);
        }

        let body = prompt::with_overlay(
            prompt::conduct(
                &runnable_views,
                &stalled_views,
                &finished_views,
                &cfg.graph.language,
            ),
            cfg.prompts.overlay(NODE),
        );

        let body = format!(
            "{body}\n\n{}",
            crate::queue::dependency_facts(queue, questions)
        );
        let artifacts = home.join("conduct").join("artifacts");
        // Bound to a local: `Invocation` only borrows the cache path, and the
        // `Option<PathBuf>` `cache_dir()` returns has to outlive that borrow.
        let cache_dir = cfg.cache_dir();

        // One marker for the whole chain: a fallback is still this turn.
        let busy = Busy::mark(home);
        let mut result: Result<Verdict> = Err(anyhow::anyhow!("no conductor agent ran"));
        for spec in &chain {
            // The prompt carries the whole queue state every cycle, so a
            // fallback agent needs no history - but its seat is its own.
            let needs_new_seat = !matches!(&self.seat, Some(s) if s.agent == spec.id);
            if needs_new_seat {
                self.seat = Some(SeatState::new(SEAT, &spec.id, crate::rng::entropy()));
            }
            let seat = self.seat.as_mut().expect("just ensured a seat exists");
            // The first agent keeps the plain stem; a fallback's own artifacts
            // must not overwrite it.
            let stem = if std::ptr::eq(spec, &chain[0]) {
                format!("turn-{}", seat.turns + 1)
            } else {
                format!("turn-{}-{}", seat.turns + 1, spec.id)
            };
            let inv = Invocation {
                scope: crate::agent::InvocationScope::Repository,
                coordination: cfg.coordination.as_ref(),
                fetched_base: None,
                cwd: repo,
                prompt: &body,
                timeout: TURN_TIMEOUT,
                // The conductor never edits anything - it only decides what
                // blocks a task and what to do about one stuck or finished.
                allow_write: false,
                unsandboxed: false,
                sessions: cfg.graph.sessions,
                artifacts: &artifacts,
                stem: &stem,
                run: NODE,
                node: NODE,
                cache_dir: cache_dir.as_deref(),
                attachments: &[],
                writable: &[],
            };
            let out = agent::invoke(spec, seat, &inv).await;
            // Kept after every turn, failed or not: the CLI-side conversation is
            // what a resumed question needs, and it exists once the turn ran.
            if let Ok(body) = serde_json::to_string(&*seat) {
                let path = seat_path(home);
                if let Some(dir) = path.parent() {
                    let _ = std::fs::create_dir_all(dir);
                }
                let _ = std::fs::write(path, body);
            }
            let advance = agent::chain_advances(&out);
            result = match out {
                Err(e) => Err(e.context("invoking the conductor")),
                Ok(out) if advance => Err(anyhow::anyhow!(
                    "no usable reply ({})",
                    crate::notices::turn_status(
                        out.exit_code,
                        out.timed_out,
                        out.quota_exhausted()
                    )
                )),
                Ok(out) => verdict::extract_json(&out.text)
                    .context("the conductor's reply could not be parsed"),
            };
            if result.is_ok() {
                break;
            }
            if chain.len() > 1 {
                tracing::warn!("conductor: `{}` failed, trying the next agent", spec.id);
            }
        }
        drop(busy);
        let mut verdict = result?;
        attach_facts(cfg, repo, queue, &mut verdict).await;
        for d in &verdict.decisions {
            let snapshot = queued
                .iter()
                .chain(stalled)
                .chain(finished)
                .find(|t| t.id == d.id);
            if let Some(snapshot) = snapshot {
                if let Err(e) = apply_one(queue, questions, d, Some(snapshot)) {
                    tracing::warn!("conductor decision for task {}: {e:#}", d.id);
                }
            }
        }
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use std::collections::BTreeMap;

    use tempfile::tempdir;

    use super::*;
    use crate::ask::{Answer, QuestionStatus};
    use crate::config::{AgentKind, AgentSpec, Graph};
    use crate::queue::Source;

    fn mock_agent(dir: &Path, script: &str, env: BTreeMap<String, String>) -> AgentSpec {
        let path = dir.join("mock-conduct-agent.sh");
        std::fs::write(&path, script).expect("write mock");
        AgentSpec {
            id: "mock".to_owned(),
            kind: AgentKind::Command,
            model: None,
            command: vec!["sh".to_owned(), path.to_string_lossy().into_owned()],
            extra_args: Vec::new(),
            env,
            prompt_delivery: None,
        }
    }

    fn config(spec: AgentSpec) -> Config {
        Config {
            agents: vec![spec],
            graph: Graph {
                language: "en".to_owned(),
                ..Graph::default()
            },
            ..Config::default()
        }
    }

    fn task(title: &str) -> Task {
        Task::new(
            title.to_owned(),
            format!("do {title}"),
            std::path::PathBuf::from("."),
            Source::Human,
        )
    }

    #[test]
    fn delivery_bookkeeping_does_not_restart_conductor_deliberation() {
        let mut t = task("waiting");
        t.hold_machine(Some("waiting for recovery".into()));
        let before = input_fingerprint(&t);
        let snapshot = decision_input(&t);
        t.chat_notice = Some(crate::queue::ChatNotice {
            key: t.chat_notice_key().unwrap(),
            at: jiff::Timestamp::now(),
            outcome: crate::queue::ChatNoticeOutcome::Posted,
        });
        t.chat_notices.push(t.chat_notice_key().unwrap());
        t.updated_at = jiff::Timestamp::now();
        assert_eq!(before, input_fingerprint(&t));
        assert_eq!(snapshot, decision_input(&t));
        t.hold_reason = Some("recovery remains under consideration".into());
        assert_eq!(before, input_fingerprint(&t));
        t.record_answer("a different question".into(), "a new decision".into());
        assert_ne!(before, input_fingerprint(&t));
    }

    const BROKEN: &str = "#!/bin/sh\ncat >/dev/null\nexit 3\n";
    const GARBAGE: &str = "#!/bin/sh\ncat >/dev/null\nprintf 'not json at all\\n'\n";

    fn env(reply: &str) -> BTreeMap<String, String> {
        BTreeMap::from([("MOCK_REPLY".to_owned(), reply.to_owned())])
    }

    const REPLY: &str = "#!/bin/sh\ncat >/dev/null\nprintf '%s\\n' \"$MOCK_REPLY\"\n";

    /// A throwaway repo with one commit on `main` and a second branch ahead
    /// of it, so `outcome_for`'s own `git::rev_parse` call has a real head to
    /// resolve.
    fn init_repo_with_branch(dir: &Path, branch: &str) {
        use crate::proc::Quiet as _;
        let run = |args: &[&str]| {
            let out = std::process::Command::new("git")
                .args(args)
                .current_dir(dir)
                .quiet()
                .output()
                .expect("spawn git");
            assert!(
                out.status.success(),
                "git {args:?} failed: {}",
                String::from_utf8_lossy(&out.stderr)
            );
        };
        run(&["init", "-b", "main"]);
        run(&["config", "user.name", "magi test"]);
        run(&["config", "user.email", "magi@example.com"]);
        std::fs::write(dir.join("README.md"), "# fixture\n").unwrap();
        run(&["add", "-A"]);
        run(&["commit", "-m", "init"]);
        run(&["checkout", "-b", branch]);
        std::fs::write(dir.join("change.txt"), "x\n").unwrap();
        run(&["add", "-A"]);
        run(&["commit", "-m", "candidate work"]);
    }

    fn review_round_with_finding(
        round: usize,
        finding_id: &str,
        title: &str,
        addressed: &[&str],
        rejected: &[(&str, &str)],
    ) -> crate::run::ReviewRound {
        crate::run::ReviewRound {
            round,
            head: "deadbeef".to_owned(),
            verified_head: None,
            verified_at: None,
            reviews: vec![crate::run::ReviewRecord {
                attempts: 0,
                reviewer: 1,
                agent: "mock".to_owned(),
                summary: String::new(),
                findings: vec![crate::verdict::Finding {
                    id: finding_id.to_owned(),
                    severity: crate::verdict::Severity::Major,
                    file: None,
                    line: None,
                    title: title.to_owned(),
                    detail: String::new(),
                }],
                vote: None,
                failed: None,
                duration_ms: 0,
            }],
            e2e: Vec::new(),
            verify_retried: false,
            e2e_deferred: false,
            e2e_defer_reason: None,
            fix: Some(crate::run::FixRecord {
                agent: "mock".to_owned(),
                addressed: addressed.iter().map(|s| (*s).to_owned()).collect(),
                rejected: rejected
                    .iter()
                    .map(|(id, why)| crate::verdict::Rejection {
                        id: (*id).to_owned(),
                        why: (*why).to_owned(),
                    })
                    .collect(),
                notes: String::new(),
                committed: false,
                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,
        }
    }

    #[test]
    fn explicit_resumption_supersedes_history_and_rejects_stale_decisions() {
        crate::run::pin_test_home();
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("recover");
        t.answers.push(crate::queue::AnsweredQuestion {
            question: "Inspect remote first?".into(),
            answer: "Inspect, then await resumption instructions".into(),
        });
        t.hold_machine(Some("waiting for remote inspection".into()));
        queue.put(&mut t).unwrap();
        let snapshot = queue.get(&t.id).unwrap();
        t.edit(
            "recover".into(),
            "Reuse the measured PR head; fix Clippy; review".into(),
        )
        .unwrap();
        t.release_operator("cli", None);
        queue.put(&mut t).unwrap();
        let approval = t.resumption.clone();
        let d = Decision {
            id: t.id.clone(),
            recovery: Some(Recovery::Hold),
            reason: Some("remote inspection still required".into()),
            ..Decision::default()
        };
        apply_one(&queue, &questions, &d, Some(&snapshot)).unwrap();
        let stale_question = Decision {
            question: Some("Inspect remote?".into()),
            ..d.clone()
        };
        apply_one(&queue, &questions, &stale_question, Some(&snapshot)).unwrap();
        assert!(questions.list().is_empty());
        for reason in [
            "waiting for remote inspection",
            "inspection has not been confirmed",
        ] {
            let repeated = Decision {
                reason: Some(reason.into()),
                question: Some("How should we proceed?".into()),
                ..d.clone()
            };
            apply(
                &queue,
                &questions,
                &Verdict {
                    decisions: vec![repeated],
                },
            )
            .unwrap();
            assert_eq!(queue.get(&t.id).unwrap().status, TaskStatus::Queued);
        }
        assert!(
            questions.list().is_empty(),
            "a rejected proposal registers no question"
        );
        let notice = crate::notices::Notices::open()
            .get(&crate::notices::id_of(&format!(
                "conductor-resumption:{}",
                t.id
            )))
            .unwrap();
        assert!(!notice.message.contains("How should we proceed?"));
        assert!(!notice.message.contains("Some("));
        assert!(notice.message.contains("No reply to this notice is needed"));
        let reloaded = Queue::at(dir.path().join("queue")).get(&t.id).unwrap();
        assert_eq!(reloaded.resumption, approval);
        assert_eq!(reloaded.answers, t.answers);
        let v = view(&reloaded, 3);
        assert!(v.operator_resume.unwrap().contains("superseded"));
        let mut dep = task("new prerequisite");
        dep.hold_machine(Some("new authentication failure".into()));
        queue.put(&mut dep).unwrap();
        let new_blocker = Decision {
            blocked_by: vec![dep.id.clone()],
            evidence: vec![dep.id.clone()],
            // Exercise dependency waiting, without inheriting a separate hold.
            recovery: None,
            reason: Some("new prerequisite failed".into()),
            ..d.clone()
        };
        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![new_blocker.clone()],
            },
        )
        .unwrap();
        let mut after = queue.get(&t.id).unwrap();
        assert_eq!(after.status, TaskStatus::Blocked);
        // Automatic release does not grant fresh operator authority or make
        // the same unchanged evidence reusable.
        after.release();
        queue.put(&mut after).unwrap();
        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![new_blocker],
            },
        )
        .unwrap();
        assert_eq!(queue.get(&t.id).unwrap().status, TaskStatus::Queued);
        after.start("new-run".into());
        assert_eq!(after.resumption.as_ref().unwrap().generation, 1);
        after.hold_manual(Some("operator says wait".into()));
        queue.put(&mut after).unwrap();
        apply(&queue, &questions, &Verdict { decisions: vec![d] }).unwrap();
        assert!(queue.get(&t.id).unwrap().operator_held());
    }

    #[test]
    fn newly_blocked_dependency_is_material_evidence_after_approval() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut dep = task("old queued dependency");
        queue.put(&mut dep).unwrap();
        let mut t = task("approved task");
        t.release_operator("test", None);
        queue.put(&mut t).unwrap();
        let mut q = Question::new(
            dep.id.clone(),
            "check".into(),
            "check".into(),
            "New dependency approval".into(),
            String::new(),
            Vec::new(),
        );
        questions.put(&mut q).unwrap();
        dep.block(vec![q.id.clone()], Some("new decision needed".into()));
        let changed = dep.blocked_at;
        queue.put(&mut dep).unwrap();
        dep.block(vec![q.id], Some("same decision paraphrased".into()));
        assert_eq!(
            dep.blocked_at, changed,
            "prose is not new blocking evidence"
        );
        queue.put(&mut dep).unwrap();
        let d = Decision {
            id: t.id.clone(),
            blocked_by: vec![dep.id.clone()],
            evidence: vec![dep.id],
            ..Decision::default()
        };
        assert_eq!(new_blocking_evidence(&queue, &questions, &t, &d).len(), 1);
        apply_one(&queue, &questions, &d, None).unwrap();
        assert_eq!(queue.get(&t.id).unwrap().status, TaskStatus::Blocked);
    }

    #[test]
    fn resumed_run_evidence_uses_approval_time_not_run_list_offsets() {
        crate::run::pin_test_home();
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("resume evidence");
        let mut run = RunState::new(
            t.repo.clone(),
            "main".into(),
            "base".into(),
            "work".into(),
            crate::config::Config::default(),
        );
        run.begin_pass();
        run.status = crate::run::RunStatus::Failed;
        run.save().unwrap();
        t.start(run.id.clone());
        // Model legacy duplicate history, which the next start will deduplicate.
        t.runs.push(run.id.clone());
        t.release_operator("cli", None);
        let approval = t.resumption.as_ref().unwrap().at;
        let decision = Decision {
            evidence: vec![run.id.clone()],
            ..Decision::default()
        };
        assert!(new_blocking_evidence(&queue, &questions, &t, &decision).is_empty());
        t.start(run.id.clone());
        assert_eq!(t.runs.len(), 1);
        run.begin_pass();
        run.save().unwrap();
        assert!(run.passes.last().unwrap().started_at > approval);
        let evidence = new_blocking_evidence(&queue, &questions, &t, &decision);
        assert_eq!(evidence.len(), 1);
        t.resumption.as_mut().unwrap().blocking_evidence = evidence;
        assert!(new_blocking_evidence(&queue, &questions, &t, &decision).is_empty());
        run.begin_pass();
        run.save().unwrap();
        assert_eq!(
            new_blocking_evidence(&queue, &questions, &t, &decision).len(),
            1
        );

        let mut q = Question::new(
            run.id.clone(),
            "review".into(),
            "check".into(),
            "New failure".into(),
            String::new(),
            Vec::new(),
        );
        questions.put(&mut q).unwrap();
        let decision = Decision {
            evidence: vec![q.id.clone()],
            ..Decision::default()
        };
        assert_eq!(
            new_blocking_evidence(&queue, &questions, &t, &decision).len(),
            1
        );
        q.asked_at = approval;
        questions.put(&mut q).unwrap();
        assert!(new_blocking_evidence(&queue, &questions, &t, &decision).is_empty());
        q.asked_at = jiff::Timestamp::now();
        q.run = "unrelated".into();
        questions.put(&mut q).unwrap();
        assert!(new_blocking_evidence(&queue, &questions, &t, &decision).is_empty());

        let mut fresh = RunState::new(
            t.repo.clone(),
            "main".into(),
            "base".into(),
            "fresh work".into(),
            crate::config::Config::default(),
        );
        fresh.status = crate::run::RunStatus::Failed;
        fresh.save().unwrap();
        t.start(fresh.id.clone());
        let decision = Decision {
            evidence: vec![fresh.id.clone()],
            ..Decision::default()
        };
        assert_eq!(
            new_blocking_evidence(&queue, &questions, &t, &decision).len(),
            1
        );
    }

    #[test]
    fn outcome_for_carries_every_rounds_findings_and_the_branch_head() {
        crate::run::pin_test_home();
        let dir = tempdir().unwrap();
        let default_repo = dir.path().join("default");
        let task_repo = dir.path().join("task");
        std::fs::create_dir_all(&default_repo).unwrap();
        std::fs::create_dir_all(&task_repo).unwrap();
        init_repo_with_branch(&default_repo, "other-branch");
        init_repo_with_branch(&task_repo, "magi/f00d/A");

        let mut config = Config::default();
        config.graph.review_rounds = 6;
        let mut state = crate::run::RunState::new(
            task_repo.clone(),
            "main".to_owned(),
            "deadbeef".to_owned(),
            "task".to_owned(),
            config,
        );
        state.status = crate::run::RunStatus::Blocked;
        state.candidates.push(crate::run::Candidate {
            index: 0,
            label: 'A',
            agent: "mock".to_owned(),
            branch: "magi/f00d/A".to_owned(),
            worktree: task_repo.clone(),
            summary: String::new(),
            stat: String::new(),
            files: 1,
            commits: 1,
            empty: false,
            failed: None,
            verified_noop: None,
            duration_ms: 0,
            folded: false,
        });
        state.tally = Some(crate::run::Tally {
            first_choice: std::collections::BTreeMap::new(),
            borda: std::collections::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("solo".to_owned()),
        });
        state.reviews = vec![
            review_round_with_finding(
                1,
                "R1-1-2",
                "answer content is dropped",
                &[],
                &[("R1-1-2", "the id leaving blocked_by is enough")],
            ),
            review_round_with_finding(2, "R2-1-3", "answer content is still dropped", &[], &[]),
        ];
        state.save().unwrap();

        let mut t = task("outcome test");
        t.repo = task_repo;
        t.runs.push(state.id.clone());

        let finished = tokio_test_block_on(finished_view(&t, &default_repo, 2));
        let outcome = finished.outcome;

        assert!(outcome.unreadable.is_none());
        assert_eq!(outcome.run_status.as_deref(), Some("blocked"));
        assert_eq!(outcome.rounds_used, 2);
        assert_eq!(outcome.rounds_max, 6);
        assert_eq!(outcome.rounds.len(), 2);
        assert_eq!(outcome.rounds[0].findings[0].id, "R1-1-2");
        assert_eq!(outcome.rounds[0].rejected[0].id, "R1-1-2");
        assert!(outcome.rounds[1].addressed.is_empty());
        assert!(outcome.rounds[1].rejected.is_empty());
        assert_eq!(outcome.branch.as_deref(), Some("magi/f00d/A"));
        assert!(
            outcome.branch_head.is_some(),
            "a real branch must resolve a head commit: {outcome:?}"
        );
    }

    /// A tiny single-threaded block-on, so an `async fn` can be exercised
    /// from a plain `#[test]` without pulling `tokio::test`'s multi-thread
    /// runtime into a test that does no other async work.
    fn tokio_test_block_on<F: std::future::Future>(f: F) -> F::Output {
        tokio::runtime::Builder::new_current_thread()
            .enable_all()
            .build()
            .unwrap()
            .block_on(f)
    }

    #[test]
    fn view_resolves_task_attempt_limit_before_daemon_default() {
        let mut t = task("budget");
        assert_eq!(view(&t, 7).max_attempts, 7);
        t.change_attempt_limit(std::num::NonZeroUsize::new(3))
            .unwrap();
        assert_eq!(view(&t, 7).max_attempts, 3);
        t.change_attempt_limit(None).unwrap();
        assert_eq!(view(&t, 7).max_attempts, 7);
    }

    #[test]
    fn view_carries_a_tasks_recorded_answers_into_the_conductor_prompt_input() {
        let mut t = task("answered");
        t.record_answer("Which backend?".to_owned(), "SQLite".to_owned());
        let v = view(&t, 2);
        assert_eq!(v.answers.len(), 1);
        assert_eq!(v.answers[0].question, "Which backend?");
        assert_eq!(v.answers[0].answer, "SQLite");
    }

    #[tokio::test]
    async fn dependency_resolution_rechecks_questions_in_the_production_conductor_path() {
        for held in [false, true] {
            for reference in ["ca5b", "20261013-193611-ca5b"] {
                for question in [false, true] {
                    let dir = tempdir().unwrap();
                    let queue = Queue::at(dir.path().join("queue"));
                    let questions = Questions::at(dir.path().join("questions"));
                    let mut dep = task("prerequisite");
                    dep.id = "20261013-193611-ca5b".into();
                    dep.start("existing-run".into());
                    queue.put(&mut dep).unwrap();
                    let mut waiting = task("waiting");
                    if held {
                        waiting.hold_machine(Some("dependency could not be located".into()));
                    }
                    queue.put(&mut waiting).unwrap();
                    let missing_reference = if reference == "ca5b" {
                        dep.id.as_str()
                    } else {
                        "ca5b"
                    };
                    let reply = serde_json::json!({"decisions": [{
                        "id": waiting.id, "blocked_by": [reference],
                        "missing_dependencies": [missing_reference],
                        "question": question.then_some("ca5b is missing; where is its replacement?"),
                        "recovery": (!question).then_some("hold"),
                        "reason": "ca5b is missing"
                    }]}).to_string();
                    let cfg = config(mock_agent(dir.path(), REPLY, env(&reply)));
                    let (queued, finished) = if held {
                        (vec![], vec![waiting.clone()])
                    } else {
                        (vec![waiting.clone()], vec![])
                    };
                    Conductor::new()
                        .run_once(
                            &cfg,
                            dir.path(),
                            &queue,
                            &questions,
                            dir.path(),
                            &queued,
                            &[],
                            &finished,
                            2,
                        )
                        .await
                        .unwrap();
                    let after = queue.get(&waiting.id).unwrap();
                    assert_eq!(after.status, TaskStatus::Blocked);
                    assert_eq!(after.blocked_by, [dep.id]);
                    assert_eq!(after.blocked_from, Some(waiting.status));
                    assert!(!after.block_reason.unwrap().contains("missing"));
                    assert!(questions.list().is_empty());
                    assert_eq!(after.instruction, waiting.instruction);
                }
            }
        }
    }

    #[tokio::test]
    async fn dependency_resolution_inconclusive_missing_only_decisions_keep_waiting() {
        for held in [false, true] {
            for unknown in [false, true] {
                for question in [false, true] {
                    let dir = tempdir().unwrap();
                    let queue = Queue::at(dir.path().join("queue"));
                    let questions = Questions::at(dir.path().join("questions"));
                    let mut dep = task("running prerequisite");
                    dep.id = "20261013-193611-ca5b".into();
                    dep.start("existing-run".into());
                    queue.put(&mut dep).unwrap();
                    let reference = if unknown {
                        // Even an exact, existing task id is Unknown when
                        // the question inventory cannot be scanned.
                        std::fs::write(questions.root(), "not a directory").unwrap();
                        dep.id.clone()
                    } else {
                        let mut other = task("another prerequisite");
                        other.id = "20261014-193611-ca5b".into();
                        queue.put(&mut other).unwrap();
                        "ca5b".to_owned()
                    };
                    assert_eq!(
                        crate::queue::dependency(&queue, &questions, &reference),
                        if unknown {
                            crate::queue::Dependency::Unknown
                        } else {
                            crate::queue::Dependency::Ambiguous
                        }
                    );
                    let mut waiting = task("waiting");
                    if held {
                        waiting.hold_machine(Some("dependency could not be located".into()));
                    }
                    queue.put(&mut waiting).unwrap();
                    let reply = serde_json::json!({"decisions": [{
                        "id": waiting.id, "blocked_by": [reference],
                        "missing_dependencies": [reference],
                        "question": question.then_some("ca5b is missing"),
                        "recovery": (!question).then_some("hold"),
                        "reason": "ca5b is missing"
                    }]})
                    .to_string();
                    let cfg = config(mock_agent(dir.path(), REPLY, env(&reply)));
                    let (queued, finished) = if held {
                        (vec![], vec![waiting.clone()])
                    } else {
                        (vec![waiting.clone()], vec![])
                    };
                    Conductor::new()
                        .run_once(
                            &cfg,
                            dir.path(),
                            &queue,
                            &questions,
                            dir.path(),
                            &queued,
                            &[],
                            &finished,
                            2,
                        )
                        .await
                        .unwrap();
                    let after = queue.get(&waiting.id).unwrap();
                    assert_eq!(after.status, TaskStatus::Blocked);
                    assert_eq!(after.blocked_by, [reference]);
                    assert_eq!(after.blocked_from, Some(waiting.status));
                    assert!(!after.block_reason.unwrap().contains("missing"));
                    assert_eq!(after.instruction, waiting.instruction);
                    if unknown {
                        assert!(questions.root().is_file());
                    } else {
                        assert!(questions.list().is_empty());
                    }
                }
            }
        }
    }

    #[tokio::test]
    async fn dependency_resolution_unverifiable_alias_decisions_are_discarded() {
        for held in [false, true] {
            for unknown in [false, true] {
                for question in [false, true] {
                    for short_blocker in [false, true] {
                        let dir = tempdir().unwrap();
                        let queue = Queue::at(dir.path().join("queue"));
                        let questions = Questions::at(dir.path().join("questions"));
                        let mut dep = task("running prerequisite");
                        dep.id = "20261013-193611-ca5b".into();
                        dep.start("existing-run".into());
                        queue.put(&mut dep).unwrap();
                        if unknown {
                            std::fs::write(questions.root(), "not a directory").unwrap();
                        } else {
                            let mut other = task("another prerequisite");
                            other.id = "20261014-193611-ca5b".into();
                            queue.put(&mut other).unwrap();
                        }
                        let (blocker, missing) = if short_blocker {
                            ("ca5b", dep.id.as_str())
                        } else {
                            (dep.id.as_str(), "ca5b")
                        };
                        let mut waiting = task("waiting");
                        if held {
                            waiting.hold_machine(Some("dependency could not be located".into()));
                        }
                        queue.put(&mut waiting).unwrap();
                        let reply = serde_json::json!({"decisions": [{
                            "id": waiting.id, "blocked_by": [blocker],
                            "missing_dependencies": [missing],
                            "question": question.then_some("ca5b is missing"),
                            "recovery": (!question).then_some("hold"),
                            "reason": "ca5b is missing"
                        }]})
                        .to_string();
                        let cfg = config(mock_agent(dir.path(), REPLY, env(&reply)));
                        let (queued, finished) = if held {
                            (vec![], vec![waiting.clone()])
                        } else {
                            (vec![waiting.clone()], vec![])
                        };
                        Conductor::new()
                            .run_once(
                                &cfg,
                                dir.path(),
                                &queue,
                                &questions,
                                dir.path(),
                                &queued,
                                &[],
                                &finished,
                                2,
                            )
                            .await
                            .unwrap();
                        assert_eq!(
                            serde_json::to_value(queue.get(&waiting.id).unwrap()).unwrap(),
                            serde_json::to_value(&waiting).unwrap(),
                            "unverifiable aliases must leave the entire task unchanged"
                        );
                        if unknown {
                            assert!(questions.root().is_file());
                        } else {
                            assert!(questions.list().is_empty());
                        }
                    }
                }
            }
        }
    }

    #[tokio::test]
    async fn dependency_resolution_genuine_missing_reference_still_asks() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut waiting = task("missing prerequisite");
        queue.put(&mut waiting).unwrap();
        let reply = serde_json::json!({"decisions": [{
            "id": waiting.id, "blocked_by": ["not-present"],
            "missing_dependencies": ["not-present"],
            "question": "Which prerequisite replaces the missing task?"
        }]})
        .to_string();
        let cfg = config(mock_agent(dir.path(), REPLY, env(&reply)));
        Conductor::new()
            .run_once(
                &cfg,
                dir.path(),
                &queue,
                &questions,
                dir.path(),
                &[waiting.clone()],
                &[],
                &[],
                2,
            )
            .await
            .unwrap();
        let after = queue.get(&waiting.id).unwrap();
        assert_eq!(after.status, TaskStatus::Blocked);
        assert_eq!(
            questions.get(&after.blocked_by[0]).unwrap().summary,
            "Which prerequisite replaces the missing task?"
        );
    }

    #[tokio::test]
    async fn dependency_resolution_keeps_decisions_during_unrelated_task_progress() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut dep = task("prerequisite");
        dep.id = "20261013-193611-ca5b".into();
        dep.start("existing-run".into());
        queue.put(&mut dep).unwrap();
        let mut unrelated = task("unrelated work");
        unrelated.start("other-run".into());
        queue.put(&mut unrelated).unwrap();
        // Make the old and new revision distinguishable without relying on
        // the filesystem clock advancing while the mock process starts.
        std::fs::File::options()
            .write(true)
            .open(queue.path_of(&unrelated.id))
            .unwrap()
            .set_times(std::fs::FileTimes::new().set_modified(std::time::UNIX_EPOCH))
            .unwrap();
        unrelated.succeed();
        let mut waiting = task("waiting");
        let mut asking = task("needs a product decision");
        let mut holding = task("must stay held");
        queue.put(&mut waiting).unwrap();
        queue.put(&mut asking).unwrap();
        queue.put(&mut holding).unwrap();
        let reply = serde_json::json!({"decisions": [
            {"id": waiting.id, "blocked_by": ["ca5b"], "reason": "wait for implementation"},
            {"id": asking.id, "question": "Which behavior do you want?"},
            {"id": holding.id, "recovery": "hold", "reason": "already implemented elsewhere"}
        ]})
        .to_string();
        let mut vars = env(&reply);
        vars.insert(
            "UNRELATED_PATH".into(),
            queue.path_of(&unrelated.id).to_string_lossy().into_owned(),
        );
        vars.insert(
            "UNRELATED_RECORD".into(),
            serde_json::to_string(&unrelated).unwrap(),
        );
        let script = r#"#!/bin/sh
cat >/dev/null
printf '%s' "$UNRELATED_RECORD" > "$UNRELATED_PATH"
printf '%s\n' "$MOCK_REPLY"
"#;
        let cfg = config(mock_agent(dir.path(), script, vars));
        Conductor::new()
            .run_once(
                &cfg,
                dir.path(),
                &queue,
                &questions,
                dir.path(),
                &[waiting.clone(), asking.clone(), holding.clone()],
                &[],
                &[],
                2,
            )
            .await
            .unwrap();
        assert_eq!(queue.get(&unrelated.id).unwrap().status, TaskStatus::Done);
        let after = queue.get(&waiting.id).unwrap();
        assert_eq!(after.status, TaskStatus::Blocked);
        assert_eq!(after.blocked_by, [dep.id]);
        let asked = queue.get(&asking.id).unwrap();
        assert_eq!(asked.status, TaskStatus::Blocked);
        assert_eq!(
            questions.get(&asked.blocked_by[0]).unwrap().summary,
            "Which behavior do you want?"
        );
        assert_eq!(queue.get(&holding.id).unwrap().status, TaskStatus::Held);
    }

    #[test]
    fn a_dependency_decision_blocks_the_task_and_leaves_priority_alone() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut a = task("a");
        a.priority = 9;
        queue.put(&mut a).unwrap();

        let verdict = Verdict {
            decisions: vec![Decision {
                id: a.id.clone(),
                blocked_by: vec!["20260101-000000-dead".to_owned()],
                reason: Some("waits on the other task".to_owned()),
                recovery: None,
                question: None,
                choices: Vec::new(),
                actions: BTreeMap::new(),
                question_decision: None,
                evidence: Vec::new(),
                missing_dependencies: Vec::new(),
            }],
        };
        apply(&queue, &questions, &verdict).unwrap();

        let back = queue.get(&a.id).unwrap();
        assert_eq!(back.status, TaskStatus::Blocked);
        assert_eq!(back.blocked_by, ["20260101-000000-dead"]);
        assert_eq!(
            back.priority, 9,
            "the conductor's reply cannot carry priority"
        );
    }

    #[test]
    fn a_question_decision_files_one_and_blocks_on_its_id() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("ambiguous");
        queue.put(&mut t).unwrap();

        let verdict = Verdict {
            decisions: vec![Decision {
                id: t.id.clone(),
                blocked_by: Vec::new(),
                reason: Some("which backend?".to_owned()),
                recovery: None,
                question: Some("Which storage backend?".to_owned()),
                choices: vec!["SQLite".to_owned(), "Redis".to_owned()],
                actions: BTreeMap::new(),
                question_decision: None,
                evidence: Vec::new(),
                missing_dependencies: Vec::new(),
            }],
        };
        apply(&queue, &questions, &verdict).unwrap();

        let back = queue.get(&t.id).unwrap();
        assert_eq!(back.status, TaskStatus::Blocked);
        assert_eq!(back.blocked_by.len(), 1);
        let q = questions.get(&back.blocked_by[0]).unwrap();
        assert_eq!(q.summary, "Which storage backend?");
        assert_eq!(q.node, NODE);
        assert!(q.status.open());
    }

    #[test]
    fn a_task_with_an_open_question_already_reuses_it_rather_than_filing_a_second_one() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("asked once");
        queue.put(&mut t).unwrap();

        let decision = Decision {
            id: t.id.clone(),
            reason: Some("still deciding".to_owned()),
            question: Some("Which backend?".to_owned()),
            ..Decision::default()
        };
        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![decision.clone()],
            },
        )
        .unwrap();
        assert_eq!(questions.list().len(), 1);
        let first_question_id = queue.get(&t.id).unwrap().blocked_by[0].clone();

        // An operator releasing the blocked task by hand, without answering,
        // puts it back at `Queued` while the question stays open - exactly
        // the case the guard in `apply_one` exists for: a later cycle
        // proposing the very same question must reuse it, not file a second.
        let mut released = queue.get(&t.id).unwrap();
        released.release();
        queue.put(&mut released).unwrap();

        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![decision],
            },
        )
        .unwrap();
        assert_eq!(questions.list().len(), 1, "no duplicate question was filed");
        let after = queue.get(&t.id).unwrap();
        assert_eq!(
            after.blocked_by,
            [first_question_id],
            "the existing open question is reused, not replaced"
        );
    }

    #[test]
    fn a_same_id_question_from_another_node_is_not_reused() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("must ask the conductor");
        queue.put(&mut t).unwrap();

        let mut unrelated = Question::new(
            t.id.clone(),
            "review".to_owned(),
            "reviewer-1".to_owned(),
            "An unrelated review question".to_owned(),
            String::new(),
            Vec::new(),
        );
        questions.put(&mut unrelated).unwrap();

        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![Decision {
                    id: t.id.clone(),
                    question: Some("Which backend?".to_owned()),
                    ..Decision::default()
                }],
            },
        )
        .unwrap();

        let blocked_by = &queue.get(&t.id).unwrap().blocked_by;
        assert_eq!(blocked_by.len(), 1);
        assert_ne!(blocked_by[0], unrelated.id);
        assert!(questions.get(&unrelated.id).unwrap().status.open());
        assert_eq!(questions.get(&blocked_by[0]).unwrap().node, NODE);
    }

    #[test]
    fn answering_the_question_lets_the_resolver_clear_the_block_with_the_answer_kept() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("waits on an answer");
        queue.put(&mut t).unwrap();

        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![Decision {
                    id: t.id.clone(),
                    blocked_by: Vec::new(),
                    reason: None,
                    recovery: None,
                    question: Some("Which backend?".to_owned()),
                    choices: Vec::new(),
                    actions: BTreeMap::new(),
                    question_decision: None,
                    evidence: Vec::new(),
                    missing_dependencies: Vec::new(),
                }],
            },
        )
        .unwrap();
        let blocked = queue.get(&t.id).unwrap();
        let question_id = blocked.blocked_by[0].clone();

        let mut q = questions.get(&question_id).unwrap();
        q.answer(Answer::Text("SQLite".to_owned())).unwrap();
        questions.put(&mut q).unwrap();
        assert_eq!(q.status, QuestionStatus::Answered);

        // `crate::daemon::resolve_blockers` is the deterministic resolver
        // that actually does this on the real queue; here it is enough to
        // prove the pure steps it is built from behave together.
        let mut task_after = queue.get(&t.id).unwrap();
        task_after.record_answer(q.summary.clone(), "SQLite".to_owned());
        task_after.unblock(&question_id);
        assert_eq!(task_after.status, TaskStatus::Queued);
        assert_eq!(task_after.answers[0].answer, "SQLite");
    }

    #[test]
    fn a_stalled_task_can_be_requeued_or_held() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));

        let mut requeue_me = task("stuck a");
        requeue_me.start("run-1".to_owned());
        queue.put(&mut requeue_me).unwrap();

        let mut hold_me = task("stuck b");
        hold_me.start("run-2".to_owned());
        queue.put(&mut hold_me).unwrap();

        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![
                    Decision {
                        id: requeue_me.id.clone(),
                        recovery: Some(Recovery::Requeue),
                        ..Decision::default()
                    },
                    Decision {
                        id: hold_me.id.clone(),
                        recovery: Some(Recovery::Hold),
                        reason: Some("looks broken".to_owned()),
                        ..Decision::default()
                    },
                ],
            },
        )
        .unwrap();

        let requeued = queue.get(&requeue_me.id).unwrap();
        assert_eq!(requeued.status, TaskStatus::Queued);
        assert_eq!(requeued.attempts, 0);

        let held = queue.get(&hold_me.id).unwrap();
        assert_eq!(held.status, TaskStatus::Held);
        assert_eq!(held.hold_reason.as_deref(), Some("looks broken"));
    }

    #[test]
    fn a_machine_held_task_asked_about_restores_to_held_once_answered() {
        // Reproduces the reported bug: a task held after burning its
        // attempts, once the conductor asks a follow-up question about it,
        // must come back `held` - not `queued` - once the question is
        // answered, whatever the answer said.
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("held out of attempts");
        t.hold_machine(Some("out of attempts".to_owned()));
        queue.put(&mut t).unwrap();

        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![Decision {
                    id: t.id.clone(),
                    reason: Some("what should happen to this one?".to_owned()),
                    question: Some("Hold it, or try again?".to_owned()),
                    ..Decision::default()
                }],
            },
        )
        .unwrap();
        let blocked = queue.get(&t.id).unwrap();
        assert_eq!(blocked.status, TaskStatus::Blocked);
        let question_id = blocked.blocked_by[0].clone();

        let mut q = questions.get(&question_id).unwrap();
        q.answer(Answer::Text("leave it held".to_owned())).unwrap();
        questions.put(&mut q).unwrap();

        // What `crate::daemon::resolve_blockers` does on the real queue.
        let mut after = queue.get(&t.id).unwrap();
        after.record_answer(q.summary.clone(), "leave it held".to_owned());
        after.unblock(&question_id);
        assert_eq!(
            after.status,
            TaskStatus::Held,
            "must not fall back to queued"
        );
        assert_eq!(after.hold_reason.as_deref(), Some("out of attempts"));
    }

    #[test]
    fn a_reaffirmed_hold_with_no_new_reason_is_not_silently_auto_released_by_triage() {
        // A different path to the same bug round 1 fixed: a task
        // machine-held for disk pressure, blocked on a conductor question,
        // answered "keep it held", and restored to `held`. If the
        // conductor's next decision reconfirms `recovery: hold` with no new
        // `reason` - allowed, `Decision::reason` is optional - `hold_machine`
        // must not silently leave the stale disk-pressure text in place, or
        // `crate::triage::run_once` reads it as an unexamined, auto-resolvable
        // hold and releases the task straight through the operator's answer
        // the instant disk space looks fine again.
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("disk pressure, then reconsidered");
        t.hold_machine(Some(
            "not enough free space to start a run: 10 bytes free, 100 required by \
             `[disk] min_free_bytes`"
                .to_owned(),
        ));
        t.record_answer(
            "How should this be handled?".to_owned(),
            "keep it held, a human will look at it later".to_owned(),
        );
        queue.put(&mut t).unwrap();

        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![Decision {
                    id: t.id.clone(),
                    recovery: Some(Recovery::Hold),
                    ..Decision::default()
                }],
            },
        )
        .unwrap();

        let after = queue.get(&t.id).unwrap();
        assert_eq!(after.status, TaskStatus::Held);
        assert!(
            !after
                .hold_reason
                .as_deref()
                .unwrap_or_default()
                .starts_with("not enough free space"),
            "the stale disk-pressure text must not survive a reconfirmed hold: {:?}",
            after.hold_reason
        );

        // The disk gate would report space is fine now - `crate::triage`
        // must not read the old text and release the task through it.
        let cfg_dir = tempdir().unwrap();
        let config = cfg_dir.path().join("magi.toml");
        std::fs::write(&config, "[disk]\nmin_free_bytes = 0\n").unwrap();
        let report =
            crate::triage::run_once(&queue, &questions, Some(&config), jiff::Timestamp::now());
        assert!(report.resumed.is_empty(), "must not be auto-released");
        assert_eq!(queue.get(&t.id).unwrap().status, TaskStatus::Held);
    }

    #[test]
    fn explicit_resumption_rehold_requires_new_evidence_and_another_answer() {
        crate::run::pin_test_home();
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let config = dir.path().join("magi.toml");
        std::fs::write(&config, "[disk]\nmin_free_bytes = 0\n").unwrap();
        let now = jiff::Timestamp::now();
        let triage = || crate::triage::run_once(&queue, &questions, Some(&config), now);
        let open = || {
            questions
                .list()
                .into_iter()
                .filter(|q| q.node == "triage" && q.status.open())
                .collect::<Vec<_>>()
        };
        let hold = Decision {
            recovery: Some(Recovery::Hold),
            reason: Some("waiting on manual worktree cleanup".to_owned()),
            ..Decision::default()
        };

        let mut t = task("looping hold");
        t.hold_machine(Some("waiting on manual worktree cleanup".to_owned()));
        queue.put(&mut t).unwrap();
        let hold = Decision {
            id: t.id.clone(),
            ..hold
        };

        // 1. triage asks the ordinary machine question; the operator resumes.
        assert_eq!(triage().asked.len(), 1);
        let first = open().remove(0);
        let mut q = questions.get(&first.id).unwrap();
        let resume = q.choices[0].clone();
        q.answer(Answer::Choice(resume)).unwrap();
        questions.put(&mut q).unwrap();
        assert_eq!(triage().answered.len(), 1);
        assert_eq!(queue.get(&t.id).unwrap().status, TaskStatus::Queued);

        // Rewording the old cause cannot undo the first explicit answer.
        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![hold.clone()],
            },
        )
        .unwrap();
        assert_eq!(queue.get(&t.id).unwrap().status, TaskStatus::Queued);
        assert!(triage().asked.is_empty());

        // A new independently filed check can justify a later hold.
        let mut evidence = Question::new(
            t.id.clone(),
            "preflight".into(),
            "check".into(),
            "New permission failure".into(),
            String::new(),
            Vec::new(),
        );
        questions.put(&mut evidence).unwrap();
        let hold = Decision {
            evidence: vec![evidence.id.clone()],
            reason: Some("new permission check failed".into()),
            ..hold
        };
        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![hold.clone()],
            },
        )
        .unwrap();
        assert_eq!(queue.get(&t.id).unwrap().status, TaskStatus::Held);

        // The new hold earns one question identifying the new evidence.
        assert_eq!(triage().asked.len(), 1);
        let second = open().remove(0);
        assert!(second.detail.contains("new permission check failed"));
        assert!(triage().asked.is_empty(), "no duplicate question");
        assert_eq!(open().len(), 1);

        // Another explicit answer supersedes this later hold too.
        let mut q = questions.get(&second.id).unwrap();
        let force = q.choices[0].clone();
        q.answer(Answer::Choice(force)).unwrap();
        questions.put(&mut q).unwrap();
        assert_eq!(triage().answered.len(), 1);
        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![hold],
            },
        )
        .unwrap();
        assert_eq!(queue.get(&t.id).unwrap().status, TaskStatus::Queued);
    }

    #[test]
    fn conductor_resumption_notice_does_not_solicit_unregistered_questions() {
        crate::run::pin_test_home();
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));

        let mut t = task("task with explicit resumption");
        t.status = TaskStatus::Queued;
        t.resumption = Some(crate::queue::Resumption {
            generation: 1,
            source: "test".into(),
            question_id: Some("q1".into()),
            at: jiff::Timestamp::now(),
            instruction: "resume".into(),
            answers_through: 0,
            runs_through: 0,
            cleared_reason: None,
            blocking_evidence: Vec::new(),
        });
        queue.put(&mut t).unwrap();

        // Conductor suggests a question and dependencies without new evidence
        let decision = Decision {
            id: t.id.clone(),
            question: Some("How should we proceed with this task?".into()),
            blocked_by: vec!["dep-x".into()],
            reason: Some("needs clarification".into()),
            recovery: Some(Recovery::Hold),
            ..Decision::default()
        };

        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![decision],
            },
        )
        .unwrap();

        // Task stays Queued (not re-blocked on old evidence)
        assert_eq!(queue.get(&t.id).unwrap().status, TaskStatus::Queued);
        // No question was filed in the questions store
        assert!(questions.list().is_empty());

        // A notice was filed with human-readable text and task link
        let notices = crate::notices::Notices::open();
        let notice = notices
            .get(&crate::notices::id_of(&format!(
                "conductor-resumption:{}",
                t.id
            )))
            .expect("conductor-resumption notice filed");

        assert_eq!(
            notice.link,
            Some(crate::notices::Link::Task { id: t.id.clone() })
        );
        // Message does NOT contain the question prose to avoid asking for non-existent answers
        assert!(!notice.message.contains("How should we proceed"));
        // Message explicitly notes that no reply is required
        assert!(
            notice
                .message
                .contains("No reply to this notice is needed.")
        );
        // No raw Rust debug representations
        assert!(!notice.message.contains("Some("));
        assert!(!notice.message.contains("None"));
        assert!(!notice.message.contains("[]"));
        assert!(!notice.message.contains("{:?}"));
        // Mention proposed dependencies cleanly
        assert!(notice.message.contains("Proposed dependencies: dep-x."));
    }

    #[test]
    fn a_runnable_task_can_be_held_directly_without_a_question() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("already answered, should stay put");
        queue.put(&mut t).unwrap();

        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![Decision {
                    id: t.id.clone(),
                    recovery: Some(Recovery::Hold),
                    reason: Some("operator already said keep this held".to_owned()),
                    ..Decision::default()
                }],
            },
        )
        .unwrap();

        let after = queue.get(&t.id).unwrap();
        assert_eq!(after.status, TaskStatus::Held);
        assert_eq!(after.hold_source, Some(crate::queue::HoldSource::Machine));
    }

    #[test]
    fn done_recovery_closes_a_held_task_whose_goal_is_already_met() {
        crate::run::pin_test_home();
        // Reproduces the other half of the reported bug (task 6081): once
        // the operator's answer says the work already happened outside the
        // loop - PR merged, worktree cleaned up - the conductor needs an
        // actual terminal state to put the task in, not just a hold it will
        // keep being re-asked about.
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("already merged by hand");
        t.hold_machine(Some("branch survived, awaiting a decision".to_owned()));
        t.record_answer(
            "Handle this one?".to_owned(),
            "already merged and cleaned up, close it".to_owned(),
        );
        queue.put(&mut t).unwrap();

        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![Decision {
                    id: t.id.clone(),
                    recovery: Some(Recovery::Done),
                    reason: Some("operator confirmed this already landed".to_owned()),
                    ..Decision::default()
                }],
            },
        )
        .unwrap();

        let after = queue.get(&t.id).unwrap();
        assert_eq!(after.status, TaskStatus::Done);
        assert!(after.hold_reason.is_none());
        assert_eq!(after.answers.len(), 1, "the record of why is kept");
    }

    #[test]
    fn done_recovery_is_ignored_for_a_runnable_or_running_task() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));

        let mut queued = task("never ran yet");
        queue.put(&mut queued).unwrap();

        let mut running = task("mid-run");
        running.start("run-1".to_owned());
        queue.put(&mut running).unwrap();

        for id in [queued.id.clone(), running.id.clone()] {
            apply(
                &queue,
                &questions,
                &Verdict {
                    decisions: vec![Decision {
                        id,
                        recovery: Some(Recovery::Done),
                        ..Decision::default()
                    }],
                },
            )
            .unwrap();
        }

        assert_eq!(queue.get(&queued.id).unwrap().status, TaskStatus::Queued);
        assert_eq!(queue.get(&running.id).unwrap().status, TaskStatus::Running);
    }

    #[test]
    fn a_question_after_two_settled_answers_is_still_filed_and_blocks() {
        // A genuine question must stay answerable however many were settled
        // before it: refusing it left `magi answer --list` empty.
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("asked about repeatedly");
        t.hold_machine(Some("out of attempts".to_owned()));
        t.record_answer("Handle this one? (1)".to_owned(), "not yet".to_owned());
        t.record_answer(
            "Handle this one? (2)".to_owned(),
            "still not yet".to_owned(),
        );
        queue.put(&mut t).unwrap();
        assert_eq!(questions.list().len(), 0);

        let verdict = Verdict {
            decisions: vec![Decision {
                id: t.id.clone(),
                question: Some("Branch conflicts with origin/main, how do we proceed?".to_owned()),
                ..Decision::default()
            }],
        };
        apply(&queue, &questions, &verdict).unwrap();

        let filed = questions.list();
        assert_eq!(filed.len(), 1, "the question was filed");
        assert_eq!(
            filed[0].summary,
            "Branch conflicts with origin/main, how do we proceed?"
        );
        let deputy = filed[0]
            .deputy
            .as_ref()
            .expect("the wait is handed to a deputy");
        assert!(deputy.brief.contains(&t.id), "{}", deputy.brief);
        assert_eq!(
            deputy.starts, 0,
            "filing never starts anything: the loop does not wait"
        );
        assert!(filed[0].status.open());
        assert_eq!(filed[0].node, NODE);
        let after = queue.get(&t.id).unwrap();
        assert_eq!(after.status, TaskStatus::Blocked);
        assert_eq!(after.blocked_by, vec![filed[0].id.clone()]);
        assert_eq!(after.answers.len(), 2, "the prior answers are untouched");
        assert!(
            !after
                .hold_reason
                .clone()
                .unwrap_or_default()
                .contains("conduct tried to ask"),
            "no hold was applied"
        );

        apply(&queue, &questions, &verdict).unwrap();
        let again = questions.list();
        assert_eq!(again.len(), 1, "the open question is reused");
        assert_eq!(again[0].id, filed[0].id);
    }

    #[test]
    fn question_source_identity_resolves_aliases_and_rejects_invented_targets() {
        let dir = tempdir().unwrap();
        init_repo_with_branch(dir.path(), "source-a");
        let mut t = task("source decision");
        t.repo = dir.path().into();
        let decision = |reference: &str| QuestionDecision {
            operation: QuestionOperation::Recover,
            target: QuestionTarget::Source {
                reference: reference.into(),
            },
        };
        assert_eq!(
            decision("source-a").identity(&t).unwrap(),
            decision("refs/heads/source-a").identity(&t).unwrap()
        );
        assert_ne!(
            decision("source-a").identity(&t).unwrap(),
            decision("main").identity(&t).unwrap()
        );
        assert!(decision("invented-source-label").identity(&t).is_err());
        let unrelated = QuestionDecision {
            operation: QuestionOperation::Resume,
            target: QuestionTarget::Run {
                id: "unrelated-run".into(),
            },
        };
        assert!(unrelated.identity(&t).is_err());
    }

    #[test]
    fn invalid_question_targets_still_file_and_block_queued_tasks() {
        let dir = tempdir().unwrap();
        init_repo_with_branch(dir.path(), "source-a");
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        for target in [
            QuestionTarget::Source {
                reference: "missing-source".into(),
            },
            QuestionTarget::Run {
                id: "unrelated-run".into(),
            },
        ] {
            let mut t = task("decision with invalid metadata");
            t.repo = dir.path().into();
            queue.put(&mut t).unwrap();
            let d = Decision {
                id: t.id.clone(),
                question: Some("Which recovery should proceed?".into()),
                choices: vec!["inspect first".into(), "keep waiting".into()],
                question_decision: Some(QuestionDecision {
                    operation: QuestionOperation::Recover,
                    target,
                }),
                ..Decision::default()
            };
            apply_one(&queue, &questions, &d, None).unwrap();
            let q = questions
                .list()
                .into_iter()
                .find(|q| q.run == t.id)
                .unwrap();
            assert_eq!(q.summary, d.question.as_deref().unwrap());
            assert!(
                q.choices.iter().all(|c| q.actions.contains_key(c)),
                "manual-only choices must become an executable hold"
            );
            assert!(q.status.open());
            let context: serde_json::Value =
                serde_json::from_str(q.decision_context.as_ref().unwrap()).unwrap();
            assert!(context[3].is_null(), "invalid metadata was discarded");
            let after = queue.get(&t.id).unwrap();
            assert_eq!(after.status, TaskStatus::Blocked);
            assert_eq!(after.blocked_by, vec![q.id.clone()]);
            apply_one(&queue, &questions, &d, None).unwrap();
            assert_eq!(questions.list().iter().filter(|q| q.run == t.id).count(), 1);
        }
    }

    #[test]
    fn answered_conductor_question_needs_changed_facts_before_reasking() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("recovery decision");
        t.hold_machine(Some("out of attempts".into()));
        t.runs = vec!["source-run-a".into(), "source-run-b".into()];
        queue.put(&mut t).unwrap();
        let mut d = Decision {
            id: t.id.clone(),
            question: Some("Recover from source A?".into()),
            choices: vec!["approve source A".into(), "keep held".into()],
            question_decision: Some(QuestionDecision {
                operation: QuestionOperation::Recover,
                target: QuestionTarget::Run {
                    id: "source-run-a".into(),
                },
            }),
            ..Decision::default()
        };
        apply_one(&queue, &questions, &d, None).unwrap();
        let mut q = questions.list().pop().unwrap();
        q.answer(crate::ask::Answer::Choice(q.choices[0].clone()))
            .unwrap();
        questions.put(&mut q).unwrap();
        queue
            .modify(&t.id, |task| {
                task.unblock(&q.id);
                task.hold_machine(Some("recovery remains under consideration".into()));
                true
            })
            .unwrap();
        d.question = Some("Should we keep waiting on recovery?".into());
        d.choices = vec!["recover using source A".into(), "remain on hold".into()];
        apply_one(&queue, &questions, &d, None).unwrap();
        assert_eq!(questions.list().len(), 1, "no repeated operator turn");
        d.question = Some("Recover from source B?".into());
        // The labels can remain identical while the approval target changes.
        d.question_decision.as_mut().unwrap().target = QuestionTarget::Run {
            id: "source-run-b".into(),
        };
        apply_one(&queue, &questions, &d, None).unwrap();
        assert_eq!(
            questions.list().len(),
            2,
            "new decision with unchanged task facts"
        );
        let after = queue.get(&t.id).unwrap();
        assert_eq!(after.instruction, t.instruction);
        assert_eq!(after.runs, t.runs);
        assert_eq!(after.status, TaskStatus::Blocked);
    }

    #[test]
    fn a_second_conductor_question_is_still_allowed_after_one_settled_answer() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("asked about once already");
        t.hold_machine(Some("out of attempts".to_owned()));
        t.record_answer("Handle this one?".to_owned(), "not yet".to_owned());
        queue.put(&mut t).unwrap();

        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![Decision {
                    id: t.id.clone(),
                    question: Some("Still not sure - now what?".to_owned()),
                    ..Decision::default()
                }],
            },
        )
        .unwrap();

        assert_eq!(questions.list().len(), 1, "the second question was filed");
        assert_eq!(queue.get(&t.id).unwrap().status, TaskStatus::Blocked);
    }

    #[test]
    fn a_held_task_with_an_open_triage_question_is_left_to_triage() {
        // `crate::triage` never calls `Task::block`, and only ever looks at
        // tasks still `held` - so a conductor question that moved this task
        // to `blocked` would orphan triage's own open question. The guard in
        // `apply_one` must leave the task alone until triage's question
        // settles.
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("held, triage already asking about it");
        t.hold_machine(Some("cause unclear".to_owned()));
        queue.put(&mut t).unwrap();

        let mut triage_q = Question::new(
            t.id.clone(),
            crate::triage::NODE.to_owned(),
            "triage".to_owned(),
            "Still needed?".to_owned(),
            String::new(),
            vec![
                "resume".to_owned(),
                "not yet".to_owned(),
                "discard".to_owned(),
            ],
        );
        questions.put(&mut triage_q).unwrap();

        for decision in [
            Decision {
                id: t.id.clone(),
                question: Some("what now?".to_owned()),
                ..Decision::default()
            },
            Decision {
                id: t.id.clone(),
                recovery: Some(Recovery::Requeue),
                ..Decision::default()
            },
        ] {
            apply(
                &queue,
                &questions,
                &Verdict {
                    decisions: vec![decision],
                },
            )
            .unwrap();
        }

        let after = queue.get(&t.id).unwrap();
        assert_eq!(
            after.status,
            TaskStatus::Held,
            "triage still owns this hold"
        );
        assert!(after.blocked_by.is_empty());
        assert_eq!(
            questions.list().len(),
            1,
            "no second, conductor-owned question was filed"
        );
    }

    #[test]
    fn a_held_task_with_an_answered_but_unapplied_triage_question_is_still_left_alone() {
        // The race `crate::triage::pending_for` exists to close: the
        // operator has already answered the triage question (it is no
        // longer `open`), but `crate::triage::run_once` - which only runs on
        // a fully idle daemon tick, far less often than the conductor polls
        // - has not had a turn to apply it yet. `apply_one` must not treat
        // "not open" as "settled" here, or it would block the task out from
        // under an answer triage has not read back yet.
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("held, triage question answered but not yet applied");
        t.hold_machine(Some("cause unclear".to_owned()));
        queue.put(&mut t).unwrap();

        let mut triage_q = Question::new(
            t.id.clone(),
            crate::triage::NODE.to_owned(),
            "triage".to_owned(),
            "Still needed?".to_owned(),
            String::new(),
            vec![
                "resume".to_owned(),
                "not yet".to_owned(),
                "discard".to_owned(),
            ],
        );
        questions.put(&mut triage_q).unwrap();
        triage_q
            .answer(Answer::Choice("not yet".to_owned()))
            .unwrap();
        questions.put(&mut triage_q).unwrap();
        assert!(!triage_q.status.open());

        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![Decision {
                    id: t.id.clone(),
                    question: Some("what now?".to_owned()),
                    ..Decision::default()
                }],
            },
        )
        .unwrap();

        let after = queue.get(&t.id).unwrap();
        assert_eq!(
            after.status,
            TaskStatus::Held,
            "triage's own answer is not yet applied - conduct must wait"
        );
        assert_eq!(
            questions.list().len(),
            1,
            "no conductor question was filed over the pending triage answer"
        );
    }

    #[test]
    fn manual_hold_rejects_hostile_or_stale_conductor_recovery() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut held = task("manual recovery");
        held.priority = 300;
        held.runs.push("run20260912-224242-daf5".to_owned());
        held.hold_manual(Some(
            "active manual recovery run20260912-224242-daf5".to_owned(),
        ));
        queue.put(&mut held).unwrap();

        // Every field a conductor may use to alter lifecycle state is ignored:
        // requeue/review would dispatch duplicate work, hold could overwrite
        // evidence, and a question would turn the hold into `blocked`.
        for decision in [
            Decision {
                id: held.id.clone(),
                recovery: Some(Recovery::Requeue),
                ..Decision::default()
            },
            Decision {
                id: held.id.clone(),
                recovery: Some(Recovery::Hold),
                reason: Some("stale replacement reason".to_owned()),
                ..Decision::default()
            },
            Decision {
                id: held.id.clone(),
                recovery: Some(Recovery::Review),
                ..Decision::default()
            },
            Decision {
                id: held.id.clone(),
                blocked_by: vec!["other-task".to_owned()],
                question: Some("retry now?".to_owned()),
                ..Decision::default()
            },
        ] {
            apply(
                &queue,
                &questions,
                &Verdict {
                    decisions: vec![decision],
                },
            )
            .unwrap();
        }

        let after = queue.get(&held.id).unwrap();
        assert_eq!(after.status, TaskStatus::Held);
        assert!(after.operator_held());
        assert_eq!(after.priority, 300);
        assert_eq!(after.runs, ["run20260912-224242-daf5"]);
        assert_eq!(
            after.hold_reason.as_deref(),
            Some("active manual recovery run20260912-224242-daf5")
        );
        assert!(after.blocked_by.is_empty());
        assert!(questions.list().is_empty());
        assert!(
            queue.next_runnable().is_none(),
            "must not dispatch a duplicate"
        );
    }

    #[test]
    fn machine_holds_remain_recoverable_and_manual_release_is_authorization() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));

        let mut automatic = task("disk gate");
        automatic.hold_machine(Some("disk full".to_owned()));
        queue.put(&mut automatic).unwrap();
        let requeue = || Verdict {
            decisions: vec![Decision {
                id: automatic.id.clone(),
                recovery: Some(Recovery::Requeue),
                ..Decision::default()
            }],
        };
        apply(&queue, &questions, &requeue()).unwrap();
        assert_eq!(queue.get(&automatic.id).unwrap().status, TaskStatus::Queued);

        let mut manual = task("operator gate");
        manual.hold_manual(Some("wait for operator".to_owned()));
        queue.put(&mut manual).unwrap();
        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![Decision {
                    id: manual.id.clone(),
                    recovery: Some(Recovery::Requeue),
                    ..Decision::default()
                }],
            },
        )
        .unwrap();
        assert_eq!(queue.get(&manual.id).unwrap().status, TaskStatus::Held);

        // This mirrors the CLI and web release routes: only an explicit
        // operator action clears the manual boundary.
        let mut released = queue.get(&manual.id).unwrap();
        released.release();
        queue.put(&mut released).unwrap();
        assert_eq!(queue.get(&manual.id).unwrap().status, TaskStatus::Queued);
    }

    #[test]
    fn legacy_reasoned_hold_is_protected_without_losing_its_metadata() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut legacy = task("old explicit hold");
        legacy.status = TaskStatus::Held;
        legacy.hold_reason = Some("manual recovery already active".to_owned());
        legacy.hold_source = None;
        legacy.blocked_by = vec!["dependency".to_owned()];
        queue.put(&mut legacy).unwrap();

        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![Decision {
                    id: legacy.id.clone(),
                    recovery: Some(Recovery::Requeue),
                    ..Decision::default()
                }],
            },
        )
        .unwrap();

        let after = queue.get(&legacy.id).unwrap();
        assert_eq!(after.status, TaskStatus::Held);
        assert_eq!(after.hold_source, None);
        assert_eq!(after.hold_reason, legacy.hold_reason);
        assert_eq!(after.blocked_by, legacy.blocked_by);
    }

    #[test]
    fn review_recovery_is_a_no_op_without_a_survivable_branch() {
        // `surviving_branch` reaches `RunState::load`, which reaches the
        // process-global `run::home()` - a `OnceLock`, so this only wins the
        // race the first time it runs in the binary; every other test still
        // reaches the same directory whichever call won, and this test's own
        // run id never collides with another test's.
        crate::run::pin_test_home();
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("blocked with no readable run");
        t.start("20260101-000000-dead".to_owned()); // no such run on disk
        t.fail("blocked", 5);
        queue.put(&mut t).unwrap();

        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![Decision {
                    id: t.id.clone(),
                    recovery: Some(Recovery::Review),
                    ..Decision::default()
                }],
            },
        )
        .unwrap();

        let after = queue.get(&t.id).unwrap();
        assert_eq!(
            after.status,
            TaskStatus::Failed,
            "with nothing to reopen, the decision is dropped rather than guessed at"
        );
        assert!(after.review_branch.is_none());
    }

    #[test]
    fn requeue_and_review_recovery_are_ignored_for_a_runnable_task() {
        // `Hold` is the one exception - see `Decision::recovery`'s doc and
        // `a_runnable_task_can_be_held_directly_without_a_question` - but a
        // task already in line has nothing for `requeue` or `review` to do.
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));

        for recovery in [Recovery::Requeue, Recovery::Review] {
            let mut t = task("ordinary");
            queue.put(&mut t).unwrap();

            apply(
                &queue,
                &questions,
                &Verdict {
                    decisions: vec![Decision {
                        id: t.id.clone(),
                        recovery: Some(recovery),
                        ..Decision::default()
                    }],
                },
            )
            .unwrap();

            assert_eq!(queue.get(&t.id).unwrap().status, TaskStatus::Queued);
        }
    }

    #[tokio::test]
    async fn a_broken_agent_leaves_the_queue_untouched_and_does_not_error() {
        let dir = tempdir().unwrap();
        let cfg = config(mock_agent(dir.path(), BROKEN, BTreeMap::new()));
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("normal");
        queue.put(&mut t).unwrap();

        let mut conductor = Conductor::new();
        conductor
            .maybe_run(
                &cfg,
                dir.path(),
                &queue,
                &questions,
                dir.path(),
                &[t.clone()],
                &[],
                &[],
                2,
            )
            .await;

        assert_eq!(
            queue.get(&t.id).unwrap().status,
            TaskStatus::Queued,
            "a failed invocation must change nothing"
        );
        assert!(
            queue.next_runnable().is_some(),
            "the loop must still be able to take the next task"
        );
    }

    #[tokio::test]
    async fn a_reply_with_no_json_leaves_the_queue_untouched() {
        let dir = tempdir().unwrap();
        let cfg = config(mock_agent(dir.path(), GARBAGE, BTreeMap::new()));
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("normal");
        queue.put(&mut t).unwrap();

        let mut conductor = Conductor::new();
        conductor
            .maybe_run(
                &cfg,
                dir.path(),
                &queue,
                &questions,
                dir.path(),
                &[t.clone()],
                &[],
                &[],
                2,
            )
            .await;

        assert_eq!(queue.get(&t.id).unwrap().status, TaskStatus::Queued);
    }

    #[tokio::test]
    async fn a_conductor_chain_falls_to_the_next_agent_once_each() {
        let dir = tempdir().unwrap();
        let mut t = task("chained");
        let reply = format!(
            "{{\"decisions\":[{{\"id\":\"{}\",\"blocked_by\":[\"x\"],\"reason\":\"why\"}}]}}",
            t.id
        );
        let counted = |id: &str, tail: &str| {
            let calls = dir.path().join(format!("{id}.calls"));
            let path = dir.path().join(format!("{id}.sh"));
            std::fs::write(
                &path,
                format!(
                    "#!/bin/sh\ncat >/dev/null\necho x >> '{}'\n{tail}\n",
                    calls.display()
                ),
            )
            .unwrap();
            AgentSpec {
                id: id.to_owned(),
                kind: AgentKind::Command,
                model: None,
                command: vec!["sh".to_owned(), path.to_string_lossy().into_owned()],
                extra_args: Vec::new(),
                env: BTreeMap::new(),
                prompt_delivery: None,
            }
        };
        let n_calls = |id: &str| {
            std::fs::read_to_string(dir.path().join(format!("{id}.calls")))
                .map_or(0, |s| s.lines().count())
        };
        let mut cfg = config(counted("a", "exit 3"));
        cfg.agents = vec![
            counted("a", "exit 3"),
            counted("b", &format!("printf '%s' '{reply}'")),
        ];
        cfg.roles.conductor = Some(crate::config::AgentChoice::Chain(vec![
            "a".into(),
            "b".into(),
            "a".into(),
        ]));
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        queue.put(&mut t).unwrap();

        let mut conductor = Conductor::new();
        conductor
            .maybe_run(
                &cfg,
                dir.path(),
                &queue,
                &questions,
                dir.path(),
                &[t.clone()],
                &[],
                &[],
                2,
            )
            .await;

        assert_eq!(queue.get(&t.id).unwrap().status, TaskStatus::Blocked);
        assert_eq!(n_calls("a"), 1, "each id is tried once");
        assert_eq!(n_calls("b"), 1);
        let saved = std::fs::read_to_string(seat_path(dir.path())).unwrap();
        assert!(
            saved.contains("\"b\""),
            "the seat on disk is the one that ran: {saved}"
        );
    }

    #[tokio::test]
    async fn json_survives_code_fences_and_a_preamble() {
        let dir = tempdir().unwrap();
        let mut t = task("fenced");
        let reply = format!(
            "Sure, here is my decision.\n\n```json\n{{\"decisions\":[{{\"id\":\"{}\",\
             \"blocked_by\":[\"x\"],\"reason\":\"why\"}}]}}\n```\n",
            t.id
        );
        let cfg = config(mock_agent(dir.path(), REPLY, env(&reply)));
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        queue.put(&mut t).unwrap();

        let mut conductor = Conductor::new();
        conductor
            .maybe_run(
                &cfg,
                dir.path(),
                &queue,
                &questions,
                dir.path(),
                &[t.clone()],
                &[],
                &[],
                2,
            )
            .await;

        let back = queue.get(&t.id).unwrap();
        assert_eq!(back.status, TaskStatus::Blocked);
        assert_eq!(back.blocked_by, ["x"]);
    }

    #[tokio::test]
    async fn the_conductor_is_not_called_again_when_nothing_worth_looking_at_has_changed() {
        // Each real invocation writes its own artifact stem, `turn-<n>`, so
        // whether a second one happened is read off the artifacts directory.
        let dir = tempdir().unwrap();
        let cfg = config(mock_agent(dir.path(), REPLY, env("{\"decisions\":[]}")));
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("stable");
        queue.put(&mut t).unwrap();
        let artifacts = dir.path().join("conduct").join("artifacts");
        let turn = |n: usize| artifacts.join(format!("turn-{n}.out"));

        let mut conductor = Conductor::new();
        conductor
            .maybe_run(
                &cfg,
                dir.path(),
                &queue,
                &questions,
                dir.path(),
                &[t.clone()],
                &[],
                &[],
                2,
            )
            .await;
        assert!(turn(1).is_file(), "the first cycle must call the conductor");

        conductor
            .maybe_run(
                &cfg,
                dir.path(),
                &queue,
                &questions,
                dir.path(),
                &[t.clone()],
                &[],
                &[],
                2,
            )
            .await;
        assert!(
            !turn(2).is_file(),
            "an unchanged revision and an unchanged stalled/finished set must not call the \
             conductor twice"
        );

        // Once the queue actually changes, the next `maybe_run` calls again.
        t.priority = 1;
        queue.put(&mut t).unwrap();
        conductor
            .maybe_run(
                &cfg,
                dir.path(),
                &queue,
                &questions,
                dir.path(),
                &[t.clone()],
                &[],
                &[],
                2,
            )
            .await;
        assert!(turn(2).is_file(), "a moved revision calls it again");
    }

    #[tokio::test]
    async fn a_task_turning_stalled_calls_the_conductor_again_despite_an_unchanged_revision() {
        // The queue's own revision has not moved - nothing wrote to it - but
        // a task now looks stalled, purely because time passed. Calling
        // again here, and never again once this exact set has been shown
        // once, is the whole point of keying `worth_a_look` on the id set
        // rather than on "is it non-empty".
        let dir = tempdir().unwrap();
        let cfg = config(mock_agent(dir.path(), REPLY, env("{\"decisions\":[]}")));
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("quiet");
        queue.put(&mut t).unwrap();
        let artifacts = dir.path().join("conduct").join("artifacts");
        let turn = |n: usize| artifacts.join(format!("turn-{n}.out"));

        let mut conductor = Conductor::new();
        conductor
            .maybe_run(
                &cfg,
                dir.path(),
                &queue,
                &questions,
                dir.path(),
                &[t.clone()],
                &[],
                &[],
                2,
            )
            .await;
        assert!(turn(1).is_file());

        conductor
            .maybe_run(
                &cfg,
                dir.path(),
                &queue,
                &questions,
                dir.path(),
                &[],
                &[t.clone()],
                &[],
                2,
            )
            .await;
        assert!(
            turn(2).is_file(),
            "a task turning stalled must call the conductor again"
        );

        // But once shown at this exact revision, showing the *same* stalled
        // set again must not call a third time.
        conductor
            .maybe_run(
                &cfg,
                dir.path(),
                &queue,
                &questions,
                dir.path(),
                &[],
                &[t.clone()],
                &[],
                2,
            )
            .await;
        assert!(
            !turn(3).is_file(),
            "the same stalled task lingering must not call the conductor every cycle"
        );
    }

    fn rehold(queue: &Queue, questions: &Questions, id: &str, note: &str) {
        apply(
            queue,
            questions,
            &Verdict {
                decisions: vec![Decision {
                    id: id.to_owned(),
                    reason: Some(note.to_owned()),
                    recovery: Some(Recovery::Hold),
                    ..Decision::default()
                }],
            },
        )
        .unwrap();
    }

    #[test]
    fn reholding_with_an_identical_note_changes_nothing() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("held");
        t.hold_machine(Some("waiting on a human".to_owned()));
        queue.put(&mut t).unwrap();

        rehold(&queue, &questions, &t.id, "owner said keep it held");
        let first = queue.get(&t.id).unwrap();
        let rev = queue.revision();
        for _ in 0..5 {
            rehold(&queue, &questions, &t.id, "owner said keep it held");
        }
        let after = queue.get(&t.id).unwrap();
        assert_eq!(after.hold_reason, first.hold_reason);
        assert_eq!(after.updated_at, first.updated_at);
        assert_eq!(queue.revision(), rev, "nothing was written");
    }

    #[test]
    fn reholding_with_different_notes_keeps_one_previously_level() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("held");
        t.hold_machine(Some("original".to_owned()));
        queue.put(&mut t).unwrap();

        for i in 0..20 {
            rehold(&queue, &questions, &t.id, &format!("note {}", i % 2));
        }
        let reason = queue.get(&t.id).unwrap().hold_reason.unwrap();
        assert_eq!(reason.matches("(previously:").count(), 1, "{reason}");
        assert!(reason.starts_with("note "), "the new note leads: {reason}");
    }

    #[test]
    fn an_already_nested_reason_is_matched_by_its_outermost_note() {
        let mut t = task("deep");
        let nested = "same\n\n(previously: same\n\n(previously: same))";
        t.hold_machine(Some(nested.to_owned()));
        let d = Decision {
            id: t.id.clone(),
            reason: Some("same".to_owned()),
            ..Decision::default()
        };
        assert_eq!(reaffirmed_hold_reason(&t, &d), None);
        let d2 = Decision {
            reason: Some("other".to_owned()),
            ..d
        };
        assert_eq!(
            reaffirmed_hold_reason(&t, &d2).as_deref(),
            Some("other\n\n(previously: same)")
        );
    }

    #[tokio::test]
    async fn a_repeated_hold_decision_settles_instead_of_looping() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let reply = r#"{"decisions":[{"id":"ID","reason":"keep held","recovery":"hold"}]}"#;
        let mut t = task("held");
        t.hold_machine(Some("first".to_owned()));
        queue.put(&mut t).unwrap();
        let cfg = config(mock_agent(
            dir.path(),
            REPLY,
            env(&reply.replace("ID", &t.id)),
        ));
        let mut conductor = Conductor::new();
        // Cycle 1 writes the new note; cycle 2 repeats it and writes nothing.
        for _ in 0..2 {
            let held = queue.get(&t.id).unwrap();
            conductor
                .maybe_run(
                    &cfg,
                    dir.path(),
                    &queue,
                    &questions,
                    dir.path(),
                    &[],
                    &[],
                    &[held],
                    2,
                )
                .await;
        }
        let held = queue.get(&t.id).unwrap();
        assert!(
            held.hold_reason
                .as_deref()
                .unwrap()
                .starts_with("keep held")
        );
        assert!(
            !conductor.worth_a_look(&queue, &[], &[held]),
            "an unchanged held task must stop being reconsidered"
        );
    }

    #[tokio::test]
    async fn alternating_wording_does_not_keep_a_held_task_in_the_loop() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("held");
        t.hold_machine(Some("first".to_owned()));
        queue.put(&mut t).unwrap();
        let reply = |note: &str| {
            format!(
                r#"{{"decisions":[{{"id":"{}","reason":"{note}","recovery":"hold"}}]}}"#,
                t.id
            )
        };
        let cfg_a = config(mock_agent(dir.path(), REPLY, env(&reply("keep held"))));
        let cfg_b = config(mock_agent(dir.path(), REPLY, env(&reply("leave held"))));
        let mut conductor = Conductor::new();
        let mut writes = 0;
        for i in 0..6 {
            let held = queue.get(&t.id).unwrap();
            let before = queue.revision();
            conductor
                .maybe_run(
                    if i % 2 == 0 { &cfg_a } else { &cfg_b },
                    dir.path(),
                    &queue,
                    &questions,
                    dir.path(),
                    &[],
                    &[],
                    &[held],
                    2,
                )
                .await;
            if queue.revision() != before {
                writes += 1;
            }
        }
        assert!(writes <= 2, "the loop must settle, saw {writes} writes");
        let mut held = queue.get(&t.id).unwrap();
        held.instruction.push_str(" (edited)");
        queue.put(&mut held).unwrap();
        let held = queue.get(&t.id).unwrap();
        assert!(conductor.worth_a_look(&queue, &[], &[held]));
    }

    #[test]
    fn worth_a_look_is_config_free_and_matches_maybe_runs_own_gate() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let mut t = task("t");
        queue.put(&mut t).unwrap();

        let mut conductor = Conductor::new();
        assert!(
            conductor.worth_a_look(&queue, &[], &[]),
            "a conductor that has never run has something to look at"
        );

        conductor.last_seen = Some(conductor.snapshot(&queue, &[], &[]));
        assert!(
            !conductor.worth_a_look(&queue, &[], &[]),
            "nothing changed and nothing is stalled or finished"
        );
        assert!(
            conductor.worth_a_look(&queue, &[t.clone()], &[]),
            "a stalled task is worth a look even at the same revision"
        );
        assert!(
            conductor.worth_a_look(&queue, &[], &[t.clone()]),
            "a finished task is worth a look even at the same revision"
        );
    }

    #[tokio::test]
    async fn the_conduct_path_never_calls_ask_and_wait() {
        // Structural: grepping this module and `daemon.rs` for
        // `ask_and_wait` is the actual assertion this module's own doc
        // promises; this test exists so the promise has a name in the test
        // output too. `apply_one`'s question path uses `Questions::put`
        // exclusively.
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("asks without blocking");
        queue.put(&mut t).unwrap();

        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![Decision {
                    id: t.id.clone(),
                    question: Some("ok?".to_owned()),
                    ..Decision::default()
                }],
            },
        )
        .unwrap();
        // Reaching here at all (no hang) is the assertion.
        assert_eq!(queue.get(&t.id).unwrap().status, TaskStatus::Blocked);
    }

    #[test]
    fn a_pinned_resume_is_not_held_or_requeued_by_the_conductor() {
        let mut t = Task::new("t".into(), "t".into(), PathBuf::new(), Source::Human);
        t.resume_override = Some(crate::queue::OperatorResume {
            question_id: "q".into(),
            at: jiff::Timestamp::now(),
            conductor_rehold: None,
            forced: false,
            pinned_run: Some("run-1".into()),
        });
        assert!(pinned_resume(&t));
        assert!(!may_hold(&mut t, "waiting for magi resume"));
        assert!(
            t.resume_override
                .as_ref()
                .unwrap()
                .conductor_rehold
                .is_none(),
            "a refused hold is not recorded as an override"
        );
        t.resume_override = None;
        assert!(!pinned_resume(&t));
        assert!(may_hold(&mut t, "no override, so a hold is allowed"));
    }

    #[test]
    fn a_pinned_resume_is_not_blocked_by_a_conductor_question_or_dependency() {
        let dir = tempdir().unwrap();
        let queue = Queue::at(dir.path().join("queue"));
        let questions = Questions::at(dir.path().join("questions"));
        let mut t = task("resume me");
        t.resume_override = Some(crate::queue::OperatorResume {
            question_id: "q".into(),
            at: jiff::Timestamp::now(),
            conductor_rehold: None,
            forced: true,
            pinned_run: Some("run-1".into()),
        });
        queue.put(&mut t).unwrap();

        apply(
            &queue,
            &questions,
            &Verdict {
                decisions: vec![
                    Decision {
                        id: t.id.clone(),
                        question: Some("really?".to_owned()),
                        ..Decision::default()
                    },
                    Decision {
                        id: t.id.clone(),
                        blocked_by: vec!["other".to_owned()],
                        ..Decision::default()
                    },
                ],
            },
        )
        .unwrap();

        assert_eq!(queue.get(&t.id).unwrap().status, TaskStatus::Queued);
        assert!(questions.list().is_empty());
    }
}