Skip to main content

magi/
triage.rs

1//! Held-task triage: walking `held` tasks so a hold left by an accident does
2//! not sit unread forever next to one a human placed on purpose.
3//!
4//! [`crate::queue::HoldSource`] already distinguishes "the daemon or
5//! conductor held this during its own recovery" ([`HoldSource::Machine`],
6//! documented as recoverable) from "an operator held this on purpose"
7//! ([`HoldSource::Manual`]). What was missing was anything that actually acts
8//! on that distinction: nothing walked the held list and asked whether a
9//! machine hold's cause was still true, and a record written before
10//! `hold_source` existed (schema < 3, `None`) was silently protected forever
11//! by [`Task::operator_held`]'s conservative default - never wrong, but also
12//! never looked at again by anything.
13//!
14//! [`run_once`] is that walk. For every `held` task it finds:
15//!
16//! - [`HoldSource::Machine`]: if [`machine_cause_resolved`] can tell the
17//!   cause is gone, the task goes straight back to `queued` - the same effect
18//!   as `magi task release`, just automatic. When it cannot tell, a
19//!   [`Question`] is filed once and the task stays held until answered.
20//! - `None` (a legacy record, or a hold nobody explained): always a question,
21//!   exactly once - the whole point being that "protected forever" must not
22//!   mean "never shown to anyone" either.
23//! - [`HoldSource::Manual`]: never touched automatically. Only once the hold
24//!   has sat untouched past [`MANUAL_STALE_AFTER`] does it earn a question of
25//!   its own, asking whether it is still wanted.
26//!
27//! Every question this module files carries [`NODE`] and uses the task id as
28//! [`Question::run`] - the same convention `crate::conduct`'s own questions
29//! use for a task rather than a run (see `conduct::apply_one`'s own comment
30//! on why the dedupe check there also filters on `node`, not `run` alone: an
31//! ordinary graph question's `run` is a real run id, and a coincidental
32//! equality with some task's id must not be read as "about this task").
33//! [`latest_triage_question`] follows the identical rule.
34//!
35//! # Why answers apply here rather than through `crate::queue::Task::block`
36//!
37//! `crate::conduct` blocks a task on its own question
38//! (`Task::block(vec![question_id], …)`), and `crate::daemon::resolve_blockers`
39//! unblocks it - unconditionally, back to `queued` - the moment that question
40//! is answered, whatever the answer actually said. That is correct for
41//! `conduct`: the *content* of the answer is meant for whoever reads
42//! `Task::answers` next, not for the resolver.
43//!
44//! A triage question's answer is different: "not yet" and "discard it" do two
45//! entirely different, non-resuming things, and only "resume it" may put the
46//! task back in line. Reusing the generic blocked/unblock path would resume
47//! every answer alike, so this module never calls [`Task::block`] and never
48//! leaves a triaged task anything but `held` while its question is open.
49//! [`interpret_answer`] reads [`Question::resolution`] itself and
50//! [`run_once`] acts on it directly: [`Task::release`] for an actual "resume
51//! it" choice, [`Queue::remove`] for "discard it" (捨ててよい really means
52//! "you may throw this away", not "leave it sitting held" - the English
53//! wording must say the same thing, not "leave it held"), and
54//! [`Task::hold_manual`] for anything else - which both keeps the task held
55//! and reclassifies it as a hold an operator has now actually seen, one
56//! `crate::conduct` and a later triage pass leave alone.
57//!
58//! The choice is read by its **position** in [`Question::choices`]
59//! ([`Wording::choices3`]/[`Wording::choices2`] always put "resume" first and
60//! "discard" third), never by comparing the answer text against [`Wording`]'s
61//! own strings picked from whatever config is in force *now* - the language a
62//! question was filed in and the language a later `run_once` call happens to
63//! read back are not guaranteed to be the same call's [`Config`], and a text
64//! comparison would silently misread a real "resume" answer as "keep held"
65//! the moment they disagree.
66//!
67//! # Idempotency
68//!
69//! [`run_once`] runs on every daemon idle tick (see `crate::daemon::poll`)
70//! and on every `magi task triage`, so an answered question must be applied to
71//! a task **at most once**, and a *fresh* question for the same task (once it
72//! is held again, or goes stale) must still be possible. The record is
73//! [`Task::triage_applied`], the question ids already applied. It cannot live
74//! in [`Task::hold_reason`]: [`Task::release`] clears that, so a "resume"
75//! answer left no trace, and a released task that failed back to `held` was
76//! released again by the same old answer with its attempts reset - forever.
77//! A task that comes back to `held` after an applied answer is therefore a
78//! new hold, handled per [`HoldSource`] (a fresh question for a machine hold).
79//! [`already_applied`] also still reads the `[triage:<short>]` marker
80//! [`keep_held_note`] appends to the hold reason, for records that pre-date
81//! the field.
82
83use std::path::{Path, PathBuf};
84use std::time::Duration;
85
86use jiff::Timestamp;
87
88use crate::ask::{Question, QuestionStatus, Questions};
89use crate::config::Config;
90use crate::queue::{HoldSource, OperatorResume, Queue, Task, TaskStatus};
91
92/// Node recorded on every question this module files - `crate::conduct::NODE`
93/// for the same idea applied to a `crate::conduct` decision instead.
94pub const NODE: &str = "triage";
95
96/// Node on the question filed about a stuck dependency root - see
97/// [`ask_about_stuck_roots`]. Separate from [`NODE`] because the choices mean
98/// something else (position 2 is "detach the dependants", not "discard").
99pub const DEPS_NODE: &str = "triage-deps";
100
101/// Seat name on a filed question. Not a real agent seat - there is no model
102/// call anywhere in this module - but every [`Question`] needs one, and every
103/// other deterministic filer (`crate::land`'s merge approval) names itself
104/// the same way.
105const SEAT: &str = "triage";
106
107/// How long a [`HoldSource::Manual`] hold sits untouched before triage asks
108/// whether it is still wanted.
109///
110/// A judgement call, not a `magi.toml` setting - the same reasoning
111/// `ask::REPLY_QUIET_WINDOW` documents for itself: there is no operator
112/// preference for "how long is too long to ignore my own hold" that a
113/// per-repository config could be *right* about. Seven days is long enough
114/// that an ordinary multi-day hold (waiting on a dependency, waiting on the
115/// operator's own schedule) never gets nagged, and short enough that a hold
116/// nobody has looked at in a week surfaces again rather than aging into the
117/// kind of silent backlog this feature exists to prevent.
118const MANUAL_STALE_AFTER: Duration = Duration::from_secs(7 * 24 * 60 * 60);
119
120/// Localised strings for a filed question, the same idea as `crate::land`'s
121/// own `Words`/`words()` - only the languages magi can actually check are
122/// translated, and anything else falls back to English.
123struct Wording {
124    lang: &'static str,
125    resume: &'static str,
126    wait: &'static str,
127    discard: &'static str,
128    resume_now: &'static str,
129    keep_held: &'static str,
130}
131
132const EN: Wording = Wording {
133    lang: "en",
134    resume: "resume it",
135    wait: "not yet",
136    discard: "discard it",
137    resume_now: "resume it",
138    keep_held: "keep it held",
139};
140
141const JA: Wording = Wording {
142    lang: "ja",
143    resume: "再開してよい",
144    wait: "まだ待って",
145    discard: "捨ててよい",
146    resume_now: "再開する",
147    keep_held: "まだ止めておく",
148};
149
150/// Pick the wording. Codes and names both, the same acceptance
151/// `crate::land::words` gives `[graph] language`.
152fn wording(language: &str) -> &'static Wording {
153    if crate::lang::is_japanese(language) {
154        &JA
155    } else {
156        &EN
157    }
158}
159
160impl Wording {
161    fn choices3(&self) -> Vec<String> {
162        vec![
163            self.resume.to_owned(),
164            self.wait.to_owned(),
165            self.discard.to_owned(),
166        ]
167    }
168
169    fn choices2(&self) -> Vec<String> {
170        vec![self.resume_now.to_owned(), self.keep_held.to_owned()]
171    }
172
173    fn source_label(&self, source: Option<HoldSource>) -> &'static str {
174        match (self.lang, source) {
175            ("ja", Some(HoldSource::Machine)) => "machine(機械による自動保留)",
176            ("ja", Some(HoldSource::Manual)) => "manual(操作者による手動保留)",
177            ("ja", None) => "unknown(schema 3 未満の旧レコード、または理由未記録)",
178            (_, Some(HoldSource::Machine)) => "machine (automatic recovery hold)",
179            (_, Some(HoldSource::Manual)) => "manual (an operator held this)",
180            (_, None) => "unknown (pre-schema-3 record, or never recorded)",
181        }
182    }
183
184    /// The body under the summary: everything an operator needs to judge this
185    /// without opening a terminal - id, title, hold reason, hold source.
186    ///
187    /// Falls back to [`Task::last_error`] when [`Task::hold_reason`] is empty:
188    /// a record written before `Task::fail`/`Task::handed_off` started
189    /// copying `why` into `hold_reason` too, or one written by a still older
190    /// build, would otherwise leave the question blank for exactly the case
191    /// requirement 4 exists for.
192    fn detail(&self, task: &Task, why: &str) -> String {
193        let none = if self.lang == "ja" {
194            "(記録なし)"
195        } else {
196            "(none recorded)"
197        };
198        let reason = task
199            .hold_reason
200            .as_deref()
201            .or(task.last_error.as_deref())
202            .unwrap_or(none);
203        format!(
204            "task: {} ({})\ntitle: {}\nhold source: {}\nhold reason: {reason}\n\n{why}",
205            task.id,
206            task.short(),
207            task.title,
208            self.source_label(task.hold_source),
209        )
210    }
211
212    fn summary_machine_unknown(&self, task: &Task) -> String {
213        if self.lang == "ja" {
214            format!("保留タスク {} の再開可否を判断してください", task.short())
215        } else {
216            format!("decide whether to resume held task {}", task.short())
217        }
218    }
219
220    fn why_machine(&self) -> &'static str {
221        if self.lang == "ja" {
222            "機械的な保留(machine hold)ですが、原因がすでに解消しているかを自動では判断できませんでした。"
223        } else {
224            "This is a machine hold, but whether its cause has resolved could not be \
225             checked automatically."
226        }
227    }
228
229    fn summary_conductor_override(&self, task: &Task) -> String {
230        if self.lang == "ja" {
231            format!(
232                "再開と回答済みのタスク {} を conductor が再び保留しました",
233                task.short()
234            )
235        } else {
236            format!(
237                "task {} was resumed at your word, but the conductor held it again",
238                task.short()
239            )
240        }
241    }
242
243    fn why_conductor_override(&self, o: &OperatorResume) -> String {
244        let reason = o.conductor_rehold.as_deref().unwrap_or_default();
245        if self.lang == "ja" {
246            format!(
247                "{} に再開と回答済みですが、conductor が再び hold しました。conductor の理由: \
248                 {reason}\n\n強制再キューを選ぶと、以後 conductor はこのタスクを hold できません。",
249                o.at
250            )
251        } else {
252            format!(
253                "You answered \"resume\" at {}, but the conductor held the task again. \
254                 Its reason: {reason}\n\nForcing a requeue stops the conductor from \
255                 holding this task again.",
256                o.at
257            )
258        }
259    }
260
261    /// Positions match [`AnswerAction`]: 0 resume, 1 keep held, 2 discard.
262    fn choices_conductor_override(&self) -> Vec<String> {
263        if self.lang == "ja" {
264            vec![
265                "強制再キュー(conductor は再 hold 不可)".to_owned(),
266                "手動 hold のまま".to_owned(),
267                "捨ててよい".to_owned(),
268            ]
269        } else {
270            vec![
271                "force requeue (conductor must not hold again)".to_owned(),
272                "keep held (manual)".to_owned(),
273                "discard".to_owned(),
274            ]
275        }
276    }
277
278    fn summary_legacy(&self, task: &Task) -> String {
279        if self.lang == "ja" {
280            format!(
281                "hold_source が不明な保留タスク {} を確認してください",
282                task.short()
283            )
284        } else {
285            format!(
286                "held task {} has no recorded hold source - please take a look",
287                task.short()
288            )
289        }
290    }
291
292    fn why_legacy(&self) -> &'static str {
293        if self.lang == "ja" {
294            "hold_source が記録されていません。schema 3 より前のレコードか、理由が記録されなかった \
295             holdです。人が意図して止めたのか、クラッシュや強制再起動で宙に浮いただけなのか、\
296             このデータからは区別できません。"
297        } else {
298            "No hold_source was recorded - either a pre-schema-3 record, or a hold whose \
299             reason was never written down. Whether this was a deliberate hold or the \
300             leftover of a crash cannot be told from the data alone."
301        }
302    }
303
304    fn summary_manual_stale(&self, task: &Task, days: i64) -> String {
305        if self.lang == "ja" {
306            format!(
307                "{days}日間 保留されたままの手動保留タスク {} を確認してください",
308                task.short()
309            )
310        } else {
311            format!(
312                "held task {} has been on a manual hold for {days} day(s)",
313                task.short()
314            )
315        }
316    }
317
318    fn why_manual(&self) -> &'static str {
319        if self.lang == "ja" {
320            "操作者が明示的に止めた保留ですが、長期間そのままになっています。まだ止めておくか、\
321             再開するか教えてください。"
322        } else {
323            "An operator held this on purpose, but it has sat untouched for a while. Say \
324             whether to keep holding it or resume it."
325        }
326    }
327}
328
329/// Which of the three situations this module recognises a held task is in.
330#[derive(Debug, Clone, Copy, PartialEq, Eq)]
331enum Bucket {
332    /// `HoldSource::Machine`, cause not verifiably resolved.
333    MachineUnknown,
334    /// `HoldSource::Machine`, held by the conductor after the operator
335    /// answered "resume" (see [`Task::resume_override`]).
336    ConductorOverride,
337    /// `hold_source` is `None`.
338    Legacy,
339    /// `HoldSource::Manual`, held past [`MANUAL_STALE_AFTER`].
340    ManualStale,
341}
342
343/// What one [`run_once`] pass did, task ids in each list.
344#[derive(Debug, Clone, Default)]
345pub struct Report {
346    /// A `HoldSource::Machine` hold whose cause was found resolved, put back
347    /// in line automatically.
348    pub resumed: Vec<String>,
349    /// A fresh question was filed this pass.
350    pub asked: Vec<String>,
351    /// An operator's answer to an earlier triage question was applied.
352    pub answered: Vec<String>,
353    /// A `blocked` task whose `blocked_by` named an id that no longer exists
354    /// was moved to a machine hold this pass - see
355    /// [`quarantine_orphaned_blocked`]. Distinct from `asked`: the question
356    /// about it, if any, is filed in the same pass and only counted there.
357    pub quarantined: Vec<String>,
358}
359
360impl Report {
361    /// Is there nothing to report? Callers use this to skip logging an empty
362    /// pass rather than repeating "triaged 0 held task(s)" on every idle tick.
363    pub fn is_empty(&self) -> bool {
364        self.resumed.is_empty()
365            && self.asked.is_empty()
366            && self.answered.is_empty()
367            && self.quarantined.is_empty()
368    }
369}
370
371/// The repository a task's config and disk check should read from. Mirrors
372/// `crate::conduct::repo_for`'s own fallback, duplicated rather than shared
373/// because that one is private to its module and the two are one `if` each.
374fn repo_for(task: &Task) -> PathBuf {
375    if task.repo.as_os_str().is_empty() {
376        PathBuf::from(".")
377    } else {
378        task.repo.clone()
379    }
380}
381
382/// Recognise a `HoldSource::Machine` hold caused by the free-space gate
383/// (`crate::disk::gate`'s message, or `daemon::disk_gate`'s "could not
384/// measure" fallback) from `hold_reason` text alone.
385///
386/// There is no field recording *why* a machine hold happened - `hold_machine`
387/// takes only a reason string - so this is the one signal available, and disk
388/// pressure is the one cause this module can safely re-measure without
389/// touching git, a run, or an agent CLI. Keep the two prefixes here in sync
390/// with `crate::disk::gate`'s formatted string and `daemon::disk_gate`'s own
391/// message if either changes; nothing else ties them together.
392fn is_disk_hold(task: &Task) -> bool {
393    task.hold_reason
394        .as_deref()
395        .is_some_and(crate::disk::is_gate_reason)
396}
397
398/// Has a `HoldSource::Machine` hold's cause resolved? `Some(true)` means yes -
399/// safe to requeue. `Some(false)` means the same cause was checked and is
400/// still in force. `None` means this hold's cause is not one this module
401/// knows how to re-check at all, and a human has to look.
402fn machine_cause_resolved(task: &Task, cfg: &Config) -> Option<bool> {
403    machine_cause_resolved_under(task, cfg, &crate::run::home())
404}
405
406fn machine_cause_resolved_under(task: &Task, cfg: &Config, home: &Path) -> Option<bool> {
407    machine_cause_resolved_with_admission(task, cfg, home, |paths| {
408        crate::retention::OutputLease::admit(home, paths, cfg.disk.min_free_bytes).is_ok()
409    })
410}
411
412fn machine_cause_resolved_with_admission(
413    task: &Task,
414    cfg: &Config,
415    home: &Path,
416    admission_available: impl Fn(&[PathBuf]) -> bool,
417) -> Option<bool> {
418    if task
419        .hold_reason
420        .as_deref()
421        .is_some_and(|r| r.starts_with(crate::cache::RESOURCE_HOLD))
422    {
423        // Require evidence from the exact latest run before auto-releasing.
424        let id = task.runs.last()?;
425        let state = crate::run::RunState::load_under(id, home).ok()?;
426        let block = state.resource_block.as_ref()?;
427        if state.id != *id {
428            return None;
429        }
430        if block.kind == "disk admission"
431            && matches!(block.cause, crate::run::ResourceBlockCause::Other)
432        {
433            // Reuse the actual atomic admission validator, not just df: other
434            // writers may still own headroom on either output volume. Include
435            // saved and current cache locations conservatively across resumes.
436            let mut paths = vec![repo_for(task), state.repo.clone(), state.worktree_root()];
437            paths.extend(state.candidates.iter().map(|c| c.worktree.clone()));
438            paths.extend(state.config.cache_dir());
439            paths.extend(cfg.cache_dir());
440            return Some(admission_available(&paths));
441        }
442        // A free cache lease resolves contention, not malformed manifests,
443        // failed writes, cancellation, or unknown infrastructure failures.
444        if block.kind != "shared build cache"
445            || !matches!(block.cause, crate::run::ResourceBlockCause::Timeout { .. })
446        {
447            return None;
448        }
449        return Some(
450            cfg.cache_dir()
451                .is_none_or(|dir| !crate::cache::in_use(home, &dir)),
452        );
453    }
454    if !is_disk_hold(task) {
455        return None;
456    }
457    let min = cfg.disk.min_free_bytes;
458    if min == 0 {
459        // The operator turned the gate off since this hold was placed - its
460        // one possible cause is gone by construction, no measurement needed.
461        return Some(true);
462    }
463    Some(crate::daemon::disk_gate(&repo_for(task), cfg).is_none())
464}
465
466/// Is a `HoldSource::Manual` hold old enough to earn a "still wanted?"
467/// question? Same comparison `crate::clean::due` uses for a run's fold grace,
468/// against [`MANUAL_STALE_AFTER`] instead of a configured one.
469fn manual_is_stale(task: &Task, now: Timestamp) -> bool {
470    now.as_second() - task.updated_at.as_second() > MANUAL_STALE_AFTER.as_secs() as i64
471}
472
473/// The marker [`apply_answer`] writes into [`Task::hold_reason`] and
474/// [`already_applied`] reads back - see this module's own doc on why.
475fn marker_for(q: &Question) -> String {
476    format!("[triage:{}]", q.short())
477}
478
479/// Has `q`'s answer already been applied to `task`? See this module's doc.
480/// Checks [`Task::triage_applied`] first, which survives [`Task::release`].
481fn already_applied(task: &Task, q: &Question) -> bool {
482    if task.triage_applied(&q.id) {
483        return true;
484    }
485    // Records written before `Task::triage_applied` existed carry only the
486    // "keep held" marker in the hold reason.
487    let marker = marker_for(q);
488    task.hold_reason
489        .as_deref()
490        .is_some_and(|r| r.contains(marker.as_str()))
491}
492
493/// The most recent question this module filed for `task_id`, any status -
494/// open (still waiting), answered (may need applying), or abandoned (settled
495/// with nothing decided). Filters on both `node` and `run`, never `run`
496/// alone - see this module's doc on why a bare `run` match is not safe.
497fn latest_triage_question(questions: &Questions, task_id: &str) -> Option<Question> {
498    latest_question(questions, NODE, task_id)
499}
500
501/// [`latest_triage_question`] for any of this module's nodes.
502fn latest_question(questions: &Questions, node: &str, task_id: &str) -> Option<Question> {
503    questions
504        .list()
505        .into_iter()
506        .filter(|q| q.node == node && q.run == task_id)
507        // `asked_at` first: ids carry only whole seconds plus a random
508        // suffix, so two questions filed in the same second order randomly.
509        .max_by(|a, b| a.asked_at.cmp(&b.asked_at).then_with(|| a.id.cmp(&b.id)))
510}
511
512/// What an answered triage question's choice means, independent of which
513/// language it was filed in.
514#[derive(Debug, Clone, Copy, PartialEq, Eq)]
515enum AnswerAction {
516    /// The first choice, always "resume it" / "再開してよい" / "再開する" -
517    /// see [`Wording::choices3`] and [`Wording::choices2`], whose first entry
518    /// is always the resume choice.
519    Resume,
520    /// The third choice, present only in [`Wording::choices3`]: "discard it"
521    /// / "捨ててよい".
522    Discard,
523    /// Anything else: the second choice ("not yet" / "keep it held"), or an
524    /// answer that does not match any offered choice at all (should not
525    /// happen for a multiple-choice question, but the safe default is to
526    /// keep holding rather than guess at "resume").
527    KeepHeld,
528}
529
530/// Read `q`'s answer as an [`AnswerAction`].
531///
532/// Matched by **position in `q.choices`**, never by comparing the answer text
533/// against [`Wording`]'s own strings: [`Wording`] is picked from the task's
534/// *current* repository config, which can differ from whatever language was
535/// in force when the question was filed (a `--config` override on one `magi
536/// task triage` call and not the next, or the repository's config edited in
537/// between). Comparing text would then silently misread an actual "resume"
538/// answer as "keep held" - the choices themselves are fixed at filing time,
539/// in [`file_question`], and never change afterwards, so their position is
540/// the one thing that stays true regardless of which language reads them
541/// back.
542fn interpret_answer(q: &Question) -> AnswerAction {
543    let resolution = q.resolution().unwrap_or_default();
544    match q.choices.iter().position(|c| *c == resolution) {
545        Some(0) => AnswerAction::Resume,
546        Some(2) => AnswerAction::Discard,
547        _ => AnswerAction::KeepHeld,
548    }
549}
550
551/// Legacy triage has a fixed issuer-owned keep-held slot. Its resume slot
552/// may requeue, so it deliberately does not qualify for contextual resume.
553pub(crate) fn contextual_keep_held(q: &Question, label: &str) -> bool {
554    q.node == NODE
555        && q.seat == SEAT
556        && q.actions.is_empty()
557        && q.choices.get(1).is_some_and(|c| c == label)
558}
559
560/// The note [`already_applied`] looks for, appended to (never replacing)
561/// whatever [`Task::hold_reason`] already said - the original cause is still
562/// worth reading in `magi task show` after the operator answers "not yet",
563/// and [`Task::hold_manual`] would otherwise overwrite it outright.
564fn keep_held_note(task: &Task, q: &Question, resolution: &str) -> String {
565    let marker = format!("{} operator: {resolution}", marker_for(q));
566    match task.hold_reason.as_deref() {
567        Some(existing) if !existing.is_empty() => format!("{existing}\n{marker}"),
568        _ => marker,
569    }
570}
571
572/// File a fresh triage question for `task` and return it. The caller is
573/// responsible for having already established there is no open one - see
574/// [`latest_triage_question`] - so this never checks again.
575fn file_question(
576    questions: &Questions,
577    task: &Task,
578    bucket: Bucket,
579    w: &Wording,
580    now: Timestamp,
581) -> Option<Question> {
582    let (summary, why, choices) = match bucket {
583        Bucket::MachineUnknown => (
584            w.summary_machine_unknown(task),
585            w.why_machine().to_owned(),
586            w.choices3(),
587        ),
588        Bucket::ConductorOverride => (
589            w.summary_conductor_override(task),
590            task.resume_override
591                .as_ref()
592                .map(|o| w.why_conductor_override(o))
593                .unwrap_or_default(),
594            w.choices_conductor_override(),
595        ),
596        Bucket::Legacy => (
597            w.summary_legacy(task),
598            w.why_legacy().to_owned(),
599            w.choices3(),
600        ),
601        Bucket::ManualStale => {
602            let days = (now.as_second() - task.updated_at.as_second()) / (24 * 60 * 60);
603            (
604                w.summary_manual_stale(task, days),
605                w.why_manual().to_owned(),
606                w.choices2(),
607            )
608        }
609    };
610    let mut q = Question::new(
611        task.id.clone(),
612        NODE.to_owned(),
613        SEAT.to_owned(),
614        summary,
615        w.detail(task, &why),
616        choices,
617    );
618    q.triage_generation = Some(task.resumption.as_ref().map_or(0, |r| r.generation));
619    questions.put_executable(&mut q).ok()?;
620    Some(q)
621}
622
623/// What a deputy is told about a triage question: the task, why it is held and
624/// what each position does, in the words [`interpret_answer`] /
625/// [`interpret_deps_answer`] apply them. Written from the stored record; a task
626/// that no longer exists is said to be missing, never reconstructed.
627pub(crate) fn deputy_brief(q: &Question, queue: &Queue) -> String {
628    let task = queue.get(&q.run).ok();
629    let mut s = match &task {
630        Some(t) => format!(
631            "Task {} (`magi task show {}`), \"{}\", is {}. Hold source: {}. Reason: {}.",
632            t.id,
633            t.id,
634            t.title,
635            t.status.as_str(),
636            match t.hold_source {
637                Some(HoldSource::Machine) => "machine (an automatic hold)",
638                Some(HoldSource::Manual) => "manual (an operator held it)",
639                None => "unknown (an old record, treated as the operator's)",
640            },
641            t.hold_reason
642                .as_deref()
643                .or(t.last_error.as_deref())
644                .unwrap_or("(none recorded)")
645        ),
646        None => format!("Task {} no longer exists (its record is gone).", q.run),
647    };
648    s.push_str("\n\nWhat each option does, by position:");
649    let n = q.choices.len();
650    for (i, c) in q.choices.iter().enumerate() {
651        let effect = if q.node == DEPS_NODE {
652            match i {
653                0 => "the dependency is released so the loop runs it",
654                1 => {
655                    "the dependants are detached and the dependency task is DELETED; this cannot be undone"
656                }
657                2 => "the dependants are detached; the dependency stays as it is",
658                _ => "nothing is applied",
659            }
660        } else {
661            match i {
662                0 => "the task is released and requeued",
663                2 if n > 2 => "the task is DELETED; this cannot be undone",
664                _ => "the task stays held, with the answer noted",
665            }
666        };
667        s.push_str(&format!("\n- `{c}`: {effect}"));
668    }
669    s.push_str(
670        "\n\nThe daemon applies the answer on its next pass; you apply nothing. When \
671         the owner's words pick an option - including releasing a task they held \
672         themselves, or deleting it - settle it.",
673    );
674    s
675}
676
677/// Move every `blocked` task whose `blocked_by` names a task or question id
678/// that no longer exists to a machine hold, before the per-`held` walk
679/// [`run_once`] does gets a look at it.
680///
681/// `crate::daemon::resolve_blockers` already catches the same situation on
682/// every idle poll, and [`Queue::remove`] already catches it the moment a
683/// dependency is deleted through `magi task rm` - both call the same
684/// [`crate::queue::missing_blockers`]/[`crate::queue::missing_blocker_hold_reason`]
685/// this does. This third copy exists because a dependency can also be deleted
686/// by hand (the file just removed from disk, not through either of those
687/// paths), and because a queue can carry a `blocked` task with a
688/// long-since-deleted dependency from *before* either catch above ever
689/// existed - and such a task is `blocked`, never `held`, so it is invisible
690/// to the rest of this module without this pass. Running it here, first, is
691/// also what makes `magi task triage` alone - with no daemon running at all -
692/// enough to fix one: the task lands `held` in this same call, and the
693/// ordinary loop below files its question in the very same pass.
694fn quarantine_orphaned_blocked(queue: &Queue, questions: &Questions) -> Vec<String> {
695    let mut quarantined = Vec::new();
696    for listed in queue.list() {
697        if listed.status != TaskStatus::Blocked || listed.blocked_by.is_empty() {
698            continue;
699        }
700        let Ok(_claim) = queue.claim(&listed.id) else {
701            continue;
702        };
703        let Ok(mut task) = queue.get(&listed.id) else {
704            continue;
705        };
706        if task.status != TaskStatus::Blocked {
707            continue;
708        }
709        let deleted = queue.apply_deleted_blockers(&mut task, questions);
710        if !deleted.is_empty() && queue.put(&mut task).is_ok() {
711            for id in &deleted {
712                queue.note_dependency_deleted(&task, id);
713            }
714        }
715        if task.status != TaskStatus::Blocked {
716            continue;
717        }
718        let missing = crate::queue::missing_blockers(queue, questions, &task.blocked_by);
719        if missing.is_empty() {
720            continue;
721        }
722        let language = crate::lang::of_repo(&repo_for(&task));
723        let mut cause = missing.clone();
724        cause.sort();
725        cause.dedup();
726        task.notice_cause(&format!("missing-blockers:{}", cause.join(",")), None, None);
727        task.hold_machine(Some(crate::queue::missing_blocker_hold_reason_in(
728            &task.blocked_by,
729            &missing,
730            &language,
731        )));
732        if queue.put(&mut task).is_ok() {
733            quarantined.push(task.id.clone());
734        }
735    }
736    quarantined
737}
738
739/// Choices of a [`DEPS_NODE`] question, by position: release the root, discard
740/// it, or detach the dependants from it.
741#[derive(Debug, Clone, Copy, PartialEq, Eq)]
742enum DepsAction {
743    Release,
744    Discard,
745    Detach,
746    /// An answer that matches no offered choice: nothing is changed.
747    Nothing,
748}
749
750fn interpret_deps_answer(q: &Question) -> DepsAction {
751    let resolution = q.resolution().unwrap_or_default();
752    match q.choices.iter().position(|c| *c == resolution) {
753        Some(0) => DepsAction::Release,
754        Some(1) => DepsAction::Discard,
755        Some(2) => DepsAction::Detach,
756        _ => DepsAction::Nothing,
757    }
758}
759
760/// Summary, body and choices of the question about one stuck root.
761fn deps_texts(w: &Wording, root: &Task, dependants: &[&Task]) -> (String, String, Vec<String>) {
762    let ja = w.lang == "ja";
763    let reason = root
764        .hold_reason
765        .as_deref()
766        .or(root.last_error.as_deref())
767        .unwrap_or(if ja {
768            "(記録なし)"
769        } else {
770            "(none recorded)"
771        });
772    let list: String = dependants
773        .iter()
774        .map(|t| format!("- {} {}\n", t.short(), t.title))
775        .collect();
776    if ja {
777        (
778            format!(
779                "{} ({}) が {} 件のタスクを止めています",
780                root.short(),
781                root.status.as_str(),
782                dependants.len()
783            ),
784            format!(
785                "task: {} ({})\ntitle: {}\n状態: {}\n理由: {reason}\n\n\
786                 このタスクは自動では実行されないため、依存している次のタスクは永遠に待ち続けます:\n{list}",
787                root.id,
788                root.short(),
789                root.title,
790                root.status.as_str()
791            ),
792            vec![
793                "依存先を再開する".to_owned(),
794                "依存先を捨てる(依存タスクは切り離して実行)".to_owned(),
795                "依存タスクを切り離す(依存先はそのまま)".to_owned(),
796            ],
797        )
798    } else {
799        (
800            format!(
801                "{} ({}) is freezing {} blocked task(s)",
802                root.short(),
803                root.status.as_str(),
804                dependants.len()
805            ),
806            format!(
807                "task: {} ({})\ntitle: {}\nstatus: {}\nreason: {reason}\n\n\
808                 Nothing in the loop will ever run this task, so these dependants wait \
809                 forever:\n{list}",
810                root.id,
811                root.short(),
812                root.title,
813                root.status.as_str()
814            ),
815            vec![
816                "release the dependency".to_owned(),
817                "discard the dependency (dependants are detached and run)".to_owned(),
818                "detach the dependants (the dependency stays as it is)".to_owned(),
819            ],
820        )
821    }
822}
823
824/// Detach every `blocked` task that names `root` directly: drop that one id
825/// from its `blocked_by` (`Task::unblock`), so a dependant with another
826/// unresolved blocker keeps waiting on it. Idempotent.
827fn detach_dependants(queue: &Queue, questions: &Questions, root: &str) {
828    for listed in queue.list() {
829        if listed.status != TaskStatus::Blocked || !listed.blocked_by.iter().any(|b| matches!(crate::queue::dependency(queue, questions, b), crate::queue::Dependency::Task(id) if id == root)) {
830            continue;
831        }
832        let Ok(_claim) = queue.claim(&listed.id) else {
833            continue;
834        };
835        let Ok(mut t) = queue.get(&listed.id) else {
836            continue;
837        };
838        if t.status != TaskStatus::Blocked {
839            continue;
840        }
841        for id in t.blocked_by.clone() {
842            if matches!(crate::queue::dependency(queue, questions, &id), crate::queue::Dependency::Task(full) if full == root)
843            {
844                t.unblock(&id);
845            }
846        }
847        let _ = queue.put(&mut t);
848    }
849}
850
851/// Apply an answered [`DEPS_NODE`] question. Every step is idempotent, so a
852/// pass that dies half way is finished by the next one. Returns whether the
853/// answer was consumed.
854fn apply_deps_answer(queue: &Queue, questions: &Questions, q: &Question, now: Timestamp) -> bool {
855    let Ok(_claim) = queue.claim(&q.run) else {
856        return false;
857    };
858    let Ok(mut root) = queue.get(&q.run) else {
859        return false;
860    };
861    if root.triage_applied(&q.id) {
862        return false;
863    }
864    if root.operator_decided_at.is_some_and(|at| at > q.asked_at)
865        || q.triage_generation
866            .is_some_and(|g| g != root.resumption.as_ref().map_or(0, |r| r.generation))
867    {
868        root.mark_triage_applied(&q.id);
869        return queue.put(&mut root).is_ok();
870    }
871    match interpret_deps_answer(q) {
872        DepsAction::Release => {
873            if root.status == TaskStatus::Running {
874                return false;
875            }
876            root.answers.push(crate::queue::AnsweredQuestion {
877                question: q.summary.clone(),
878                answer: q.resolution().unwrap_or_default(),
879            });
880            if crate::base_sync_recovery::held_task(queue, &root) {
881                root.mark_triage_applied(&q.id);
882                return queue.put(&mut root).is_ok();
883            }
884            root.release_operator("triage-dependencies", Some(&q.id));
885            root.resume_override = Some(OperatorResume {
886                question_id: q.id.clone(),
887                at: now,
888                conductor_rehold: None,
889                forced: false,
890                pinned_run: None,
891            });
892        }
893        DepsAction::Discard => {
894            detach_dependants(queue, questions, &root.id);
895            return queue.remove(&root.id, false, questions).is_ok();
896        }
897        DepsAction::Detach => detach_dependants(queue, questions, &root.id),
898        // Matches no offered choice, so there is nothing to apply. Left unmarked:
899        // marking it applied would read as "settled", and the next stuck check
900        // would file an identical question at once. Unmarked, it stays an
901        // answered question awaiting application, which suppresses re-asking.
902        DepsAction::Nothing => return false,
903    }
904    root.mark_triage_applied(&q.id);
905    queue.put(&mut root).is_ok()
906}
907
908/// One question per stuck dependency root. Answers are applied by the
909/// pre-scheduling sweep. See [`crate::blockers`] for what "stuck" means.
910///
911/// Not re-asked: a root with an open or answered-unapplied question; one whose
912/// own hold question ([`NODE`]) is still pending; and one whose question was
913/// abandoned unless the root or a task it freezes changed since. An *applied*
914/// answer leaves nothing stuck (released, discarded, or detached), so a root
915/// that is stuck again is a new situation and is asked about afresh.
916fn ask_about_stuck_roots(
917    queue: &Queue,
918    questions: &Questions,
919    config_override: Option<&Path>,
920    report: &mut Report,
921) {
922    let all = questions.list();
923    let inv = crate::blockers::Inventory::load(queue, questions);
924    let mut frozen: std::collections::BTreeMap<String, Vec<String>> = Default::default();
925    for (id, roots) in inv.stuck() {
926        for root in roots {
927            if root != id {
928                frozen.entry(root).or_default().push(id.clone());
929            }
930        }
931    }
932    // A cycle root freezes the others but may have no dependants of its own
933    // listed above when it is alone; a root with nothing to name is not asked.
934
935    for mut q in all
936        .iter()
937        .filter(|q| q.node == DEPS_NODE && q.status.open())
938        .cloned()
939    {
940        if !frozen.contains_key(&q.run) {
941            q.abandon("nothing waits on this task anymore");
942            let _ = questions.put_executable(&mut q);
943        }
944    }
945
946    for (root_id, dependant_ids) in &frozen {
947        let Ok(_claim) = queue.claim(root_id) else {
948            continue;
949        };
950        // Recheck the chain immediately before asking: an earlier inventory
951        // may have seen a held prerequisite that has since started running.
952        let current = crate::blockers::Inventory::load(queue, questions);
953        let Some(root) = current.task(root_id) else {
954            continue;
955        };
956        if crate::base_sync_recovery::held_task(queue, root) {
957            continue;
958        }
959        let dependants: Vec<&Task> = dependant_ids
960            .iter()
961            .filter_map(|d| current.task(d))
962            .filter(|t| current.stuck_roots(t).contains(root_id))
963            .collect();
964        if dependants.is_empty() {
965            continue;
966        }
967        let latest = all
968            .iter()
969            .filter(|q| q.node == DEPS_NODE && q.run == *root_id)
970            .max_by(|a, b| a.asked_at.cmp(&b.asked_at).then_with(|| a.id.cmp(&b.id)));
971        match latest {
972            Some(q) if q.status.open() || awaiting_task_chat(q, root) => continue,
973            Some(q) if q.status == QuestionStatus::Answered && !root.triage_applied(&q.id) => {
974                continue;
975            }
976            Some(q) if q.status == QuestionStatus::Abandoned => {
977                let changed = root.updated_at > q.asked_at
978                    || dependants.iter().any(|t| t.updated_at > q.asked_at);
979                if !changed {
980                    continue;
981                }
982            }
983            _ => {}
984        }
985        if pending_for(questions, root) {
986            continue;
987        }
988        let cfg = Config::discover(&repo_for(root), config_override)
989            .ok()
990            .map(|(c, _)| c);
991        let w = wording(cfg.as_ref().map_or("en", |c| c.graph.language.as_str()));
992        let (summary, detail, choices) = deps_texts(w, root, &dependants);
993        let mut question = Question::new(
994            root.id.clone(),
995            DEPS_NODE.to_owned(),
996            SEAT.to_owned(),
997            summary,
998            detail,
999            choices,
1000        );
1001        question.triage_generation = Some(root.resumption.as_ref().map_or(0, |r| r.generation));
1002        if questions.put_executable(&mut question).is_ok() {
1003            report.asked.push(root.id.clone());
1004        }
1005    }
1006}
1007
1008/// Apply settled built-in answers before scheduling or conductor invocation.
1009/// Kept separate from diagnosis so queued tasks can recover legacy answers too.
1010pub fn apply_answers(queue: &Queue, questions: &Questions) -> Vec<String> {
1011    let mut applied = Vec::new();
1012    for q in questions.list() {
1013        if q.node == DEPS_NODE
1014            && q.status == QuestionStatus::Answered
1015            && apply_deps_answer(queue, questions, &q, Timestamp::now())
1016        {
1017            applied.push(q.run.clone());
1018        }
1019    }
1020    for listed in queue.list() {
1021        let Some(q) = latest_triage_question(questions, &listed.id) else {
1022            continue;
1023        };
1024        if q.status != QuestionStatus::Answered || already_applied(&listed, &q) {
1025            continue;
1026        }
1027        let Ok(_claim) = queue.claim(&listed.id) else {
1028            continue;
1029        };
1030        let Ok(mut task) = queue.get(&listed.id) else {
1031            continue;
1032        };
1033        if already_applied(&task, &q)
1034            || !matches!(task.status, TaskStatus::Held | TaskStatus::Queued)
1035        {
1036            continue;
1037        }
1038        let generation = task.resumption.as_ref().map_or(0, |r| r.generation);
1039        let action = interpret_answer(&q);
1040        let mut newer_decision = q.triage_generation.is_some_and(|g| g != generation)
1041            || task.resumption.as_ref().is_some_and(|r| r.at > q.asked_at)
1042            || task.held_at.is_some_and(|at| at > q.asked_at)
1043            || task.operator_decided_at.is_some_and(|at| at > q.asked_at);
1044        // A later explicit keep-held answer is itself a newer operator
1045        // decision, even when the question predates the release. Resume and
1046        // discard still require the question's original scope to match.
1047        if matches!(action, AnswerAction::KeepHeld)
1048            && q.answered_at.is_some_and(|at| {
1049                task.operator_decided_at
1050                    .is_none_or(|decision| at > decision)
1051                    && task.resumption.as_ref().is_none_or(|r| at > r.at)
1052            })
1053        {
1054            newer_decision = false;
1055        }
1056        // Audit the answer even when a later release or manual hold wins.
1057        let resolution = q.resolution().unwrap_or_default();
1058        task.answers.push(crate::queue::AnsweredQuestion {
1059            question: q.summary.clone(),
1060            answer: if newer_decision {
1061                format!("{resolution} (superseded by a later operator decision)")
1062            } else {
1063                resolution
1064            },
1065        });
1066        if !newer_decision {
1067            match action {
1068                AnswerAction::Resume if crate::base_sync_recovery::held_task(queue, &task) => {
1069                    // The original answer remains in answers; it cannot authorize
1070                    // a new implementation or an additional base rebase.
1071                }
1072                AnswerAction::Resume => {
1073                    task.release_operator("triage", Some(&q.id));
1074                    task.resume_override = Some(OperatorResume {
1075                        question_id: q.id.clone(),
1076                        at: Timestamp::now(),
1077                        conductor_rehold: None,
1078                        forced: true,
1079                        pinned_run: None,
1080                    });
1081                }
1082                AnswerAction::KeepHeld => {
1083                    let note = keep_held_note(&task, &q, &q.resolution().unwrap_or_default());
1084                    task.hold_manual(Some(note));
1085                }
1086                AnswerAction::Discard => {
1087                    if queue.remove(&task.id, false, questions).is_ok() {
1088                        applied.push(task.id);
1089                    }
1090                    continue;
1091                }
1092            }
1093        }
1094        task.mark_triage_applied(&q.id);
1095        if queue.put(&mut task).is_ok() {
1096            applied.push(task.id);
1097        }
1098    }
1099    applied
1100}
1101
1102/// Run one deterministic triage pass over every `held` task in `queue`. No
1103/// model call anywhere in this function - see this module's own doc for what
1104/// each `HoldSource` gets instead.
1105///
1106/// `config_override` is threaded straight to [`Config::discover`], the same
1107/// role `daemon::Opts::config` plays for `daemon::prepare` - an explicit
1108/// `--config` from the caller, or `None` to let each task's own repository
1109/// pick its layers.
1110///
1111/// Safe to call on every daemon idle tick and from `magi task triage` alike:
1112/// a task already answered and applied is left alone (see
1113/// [`already_applied`]), and a task with an open question is left alone too,
1114/// so repeated calls with nothing new to say do nothing.
1115///
1116/// Also runs [`quarantine_orphaned_blocked`], so a `blocked` task whose
1117/// dependency no longer exists is caught and turned into a fresh `held`
1118/// question in this same pass, not left for a later call to notice.
1119pub fn run_once(
1120    queue: &Queue,
1121    questions: &Questions,
1122    config_override: Option<&Path>,
1123    now: Timestamp,
1124) -> Report {
1125    let mut report = Report {
1126        answered: apply_answers(queue, questions),
1127        quarantined: quarantine_orphaned_blocked(queue, questions),
1128        ..Report::default()
1129    };
1130    ask_about_stuck_roots(queue, questions, config_override, &mut report);
1131    for listed in queue.list() {
1132        if listed.status != TaskStatus::Held {
1133            continue;
1134        }
1135        let Ok(_claim) = queue.claim(&listed.id) else {
1136            continue;
1137        };
1138        let Ok(mut task) = queue.get(&listed.id) else {
1139            continue;
1140        };
1141        // Re-read under the claim: a release or a re-hold landed by a human
1142        // between the listing above and the claim just taken must not be
1143        // clobbered by a decision based on the stale copy.
1144        if task.status != TaskStatus::Held {
1145            continue;
1146        }
1147        if crate::base_sync_recovery::held_task(queue, &task) {
1148            continue;
1149        }
1150        // A question about what this task freezes is already the one question
1151        // it owes the operator; a second, about the hold itself, would ask two
1152        // things at once.
1153        if deps_pending(questions, &task) {
1154            continue;
1155        }
1156
1157        let cfg = Config::discover(&repo_for(&task), config_override)
1158            .ok()
1159            .map(|(c, _)| c);
1160        let w = wording(cfg.as_ref().map_or("en", |c| c.graph.language.as_str()));
1161
1162        if let Some(q) = latest_triage_question(questions, &task.id) {
1163            if q.status.open() || awaiting_task_chat(&q, &task) {
1164                // Already asked, still waiting - nothing to do this pass.
1165                continue;
1166            }
1167            // Abandoned, or an already-applied answer: fall through to the
1168            // ordinary per-source handling below, which is how a stale
1169            // `HoldSource::Manual` re-ask - or a fresh machine/legacy
1170            // question, once a prior one settled the task back into a hold -
1171            // gets filed.
1172        }
1173
1174        match task.hold_source {
1175            Some(HoldSource::Machine) => {
1176                let overridden = task
1177                    .resume_override
1178                    .as_ref()
1179                    .is_some_and(|o| o.conductor_rehold.is_some() && !o.forced);
1180                if overridden {
1181                    if file_question(questions, &task, Bucket::ConductorOverride, w, now).is_some()
1182                    {
1183                        report.asked.push(task.id.clone());
1184                    }
1185                } else if cfg.as_ref().and_then(|c| machine_cause_resolved(&task, c)) == Some(true)
1186                {
1187                    task.release();
1188                    if queue.put(&mut task).is_ok() {
1189                        report.resumed.push(task.id.clone());
1190                    }
1191                } else if file_question(questions, &task, Bucket::MachineUnknown, w, now).is_some()
1192                {
1193                    report.asked.push(task.id.clone());
1194                }
1195            }
1196            None => {
1197                if file_question(questions, &task, Bucket::Legacy, w, now).is_some() {
1198                    report.asked.push(task.id.clone());
1199                }
1200            }
1201            Some(HoldSource::Manual) => {
1202                if manual_is_stale(&task, now)
1203                    && file_question(questions, &task, Bucket::ManualStale, w, now).is_some()
1204                {
1205                    report.asked.push(task.id.clone());
1206                }
1207            }
1208        }
1209    }
1210    report
1211}
1212
1213/// The open triage question about `task_id`, if any - what `magi task show`
1214/// prints so a held task's card names the question waiting on it, not only
1215/// its hold reason. `None` once it is answered or abandoned: nothing is
1216/// waiting on it anymore.
1217pub fn open_question_for(questions: &Questions, task_id: &str) -> Option<Question> {
1218    latest_triage_question(questions, task_id).filter(|q| q.status.open())
1219}
1220
1221/// Does this module still have unfinished business with `task`?
1222///
1223/// True while its latest triage question is still open (waiting on an
1224/// answer), and true for a beat longer than [`open_question_for`] alone
1225/// would say: once answered, the question sits [`QuestionStatus::Answered`]
1226/// but unread until the next [`run_once`] pass actually applies it (see
1227/// [`already_applied`]), and [`run_once`] only ever runs on a fully idle
1228/// daemon tick - far less often than `crate::conduct` polls. A caller that
1229/// only checked "is a question open" would walk straight through that gap
1230/// the moment the operator answers, moving the task out of `held` before
1231/// [`run_once`] gets a turn - orphaning the very answer it was about to
1232/// apply, the same failure mode this function exists to keep `crate::conduct`
1233/// out of. `crate::conduct::apply_one` is exactly that caller.
1234pub fn pending_for(questions: &Questions, task: &Task) -> bool {
1235    !pending_recovery_questions(questions, task).is_empty()
1236}
1237
1238/// The exact recovery decisions that prevent triage/conductor progress,
1239/// including routed decisions and answers not yet applied to this task.
1240pub(crate) fn pending_recovery_questions(questions: &Questions, task: &Task) -> Vec<Question> {
1241    [NODE, DEPS_NODE]
1242        .into_iter()
1243        .filter_map(|node| {
1244            latest_question(questions, node, &task.id).filter(|q| {
1245                q.status.open()
1246                    || awaiting_task_chat(q, task)
1247                    || (q.status == QuestionStatus::Answered
1248                        && if node == NODE {
1249                            !already_applied(task, q)
1250                        } else {
1251                            !task.triage_applied(&q.id)
1252                        })
1253            })
1254        })
1255        .collect()
1256}
1257
1258fn awaiting_task_chat(q: &Question, task: &Task) -> bool {
1259    q.status != QuestionStatus::Abandoned
1260        && q.routed_chat.is_some()
1261        && !already_applied(task, q)
1262        && task.resumption.as_ref().map_or(0, |r| r.generation) == q.triage_generation.unwrap_or(0)
1263        && task.operator_decided_at.is_none_or(|at| at <= q.asked_at)
1264}
1265
1266/// Is the latest [`DEPS_NODE`] question about `task` still open, or answered
1267/// but not yet applied? Same reasoning as [`pending_for`]: the gap between an
1268/// answer and the next [`run_once`] pass must not be walked through.
1269fn deps_pending(questions: &Questions, task: &Task) -> bool {
1270    match latest_question(questions, DEPS_NODE, &task.id) {
1271        Some(q) if q.status.open() || awaiting_task_chat(&q, task) => true,
1272        Some(q) if q.status == QuestionStatus::Answered => !task.triage_applied(&q.id),
1273        _ => false,
1274    }
1275}
1276
1277/// Every task id with an open triage question right now - what `magi task
1278/// list` uses to mark a held task that is already waiting on an operator
1279/// decision, rather than have it read identically to one nobody has looked
1280/// at yet.
1281pub fn open_task_ids(questions: &Questions) -> std::collections::BTreeSet<String> {
1282    questions
1283        .list()
1284        .into_iter()
1285        .filter(|q| (q.node == NODE || q.node == DEPS_NODE) && q.status.open())
1286        .map(|q| q.run)
1287        .collect()
1288}
1289
1290#[cfg(test)]
1291mod tests {
1292    use super::*;
1293    use crate::ask::Answer;
1294    use crate::queue::Source;
1295    use jiff::SignedDuration;
1296
1297    fn store() -> (tempfile::TempDir, Queue, Questions) {
1298        let dir = tempfile::tempdir().unwrap();
1299        let q = Queue::at(dir.path().join("queue"));
1300        let s = Questions::at(dir.path().join("questions"));
1301        (dir, q, s)
1302    }
1303
1304    fn task(title: &str, repo: PathBuf) -> Task {
1305        Task::new(title.to_owned(), format!("do {title}"), repo, Source::Human)
1306    }
1307
1308    #[test]
1309    fn base_recovery_stops_suppress_generic_and_dependency_resume_offers() {
1310        let (dir, queue, questions) = store();
1311        let mut root = task("base stop", dir.path().to_path_buf());
1312        let mut run = crate::run::RunState::new(
1313            dir.path().to_path_buf(),
1314            "main".into(),
1315            "base".into(),
1316            "retained implementation".into(),
1317            Config::default(),
1318        );
1319        run.status = crate::run::RunStatus::Voting;
1320        run.base_sync = Some(crate::run::BaseSync {
1321            tip: "tip".into(),
1322            behind: 3,
1323            attempts: 4,
1324            conflict: Some("persisted exhaustion".into()),
1325            already_in: None,
1326        });
1327        run.save_under(dir.path()).unwrap();
1328        root.link_run(&run.id);
1329        root.hold_machine(Some("base stop".into()));
1330        queue.put(&mut root).unwrap();
1331        let mut dependent = task("dependent", dir.path().to_path_buf());
1332        dependent.blocked_by = vec![root.id.clone()];
1333        dependent.status = TaskStatus::Blocked;
1334        queue.put(&mut dependent).unwrap();
1335        for _ in 0..2 {
1336            let report = run_once(&queue, &questions, None, Timestamp::now());
1337            assert!(report.asked.is_empty());
1338            assert!(report.resumed.is_empty());
1339        }
1340        // A generic question offered by an older launcher cannot release this
1341        // task into a replacement competition after the fix is installed.
1342        let q = file_question(
1343            &questions,
1344            &root,
1345            Bucket::MachineUnknown,
1346            &EN,
1347            Timestamp::now(),
1348        )
1349        .unwrap();
1350        let mut q = q;
1351        q.answer(Answer::Choice(q.choices[0].clone())).unwrap();
1352        questions.put_executable(&mut q).unwrap();
1353        apply_answers(&queue, &questions);
1354        let saved = queue.get(&root.id).unwrap();
1355        assert_eq!(saved.status, TaskStatus::Held);
1356        assert!(saved.triage_applied(&q.id));
1357        assert_eq!(saved.runs, vec![run.id]);
1358    }
1359
1360    #[test]
1361    fn resource_holds_only_auto_release_a_proven_cache_wait_timeout() {
1362        use crate::run::{ResourceBlock, ResourceBlockCause, RunState};
1363        let dir = tempfile::tempdir().unwrap();
1364        let cfg = Config::default(); // No configured cache means no busy lease.
1365        assert!(cfg.cache_dir().is_none());
1366        let mut state = RunState::new(
1367            dir.path().into(),
1368            "main".into(),
1369            "base".into(),
1370            "verify".into(),
1371            cfg.clone(),
1372        );
1373        let mut task = task("verify", dir.path().into());
1374        task.runs = vec![state.id.clone()];
1375        task.hold_machine(Some("[resource] cache operation stopped".into()));
1376        for cause in [
1377            ResourceBlockCause::Other,
1378            ResourceBlockCause::Unrecorded,
1379            ResourceBlockCause::Cancelled { park: None },
1380        ] {
1381            state.resource_block = Some(ResourceBlock {
1382                node: "gate".into(),
1383                kind: "shared build cache".into(),
1384                detail: "persistent metadata or manifest error".into(),
1385                cause,
1386                at: Timestamp::now(),
1387            });
1388            state.save_under(dir.path()).unwrap();
1389            // Repeated triage must retain the hold even though the lease is free.
1390            for _ in 0..3 {
1391                assert_eq!(machine_cause_resolved_under(&task, &cfg, dir.path()), None);
1392            }
1393        }
1394        let block = state.resource_block.as_mut().unwrap();
1395        block.cause = ResourceBlockCause::Timeout {
1396            waited_secs: 10,
1397            limit_secs: 10,
1398        };
1399        state.save_under(dir.path()).unwrap();
1400        assert_eq!(
1401            machine_cause_resolved_under(&task, &cfg, dir.path()),
1402            Some(true)
1403        );
1404        state.resource_block.as_mut().unwrap().kind = "repository coordination".into();
1405        state.save_under(dir.path()).unwrap();
1406        assert_eq!(machine_cause_resolved_under(&task, &cfg, dir.path()), None);
1407        task.runs = vec!["unreadable-run".into()];
1408        assert_eq!(machine_cause_resolved_under(&task, &cfg, dir.path()), None);
1409    }
1410
1411    #[cfg(unix)]
1412    #[test]
1413    fn disk_admission_holds_recheck_live_reservations_and_the_floor() {
1414        use crate::retention::OutputLease;
1415        use crate::run::{ResourceBlock, ResourceBlockCause, RunState};
1416        let temp = tempfile::tempdir().unwrap();
1417        let home = temp.path().canonicalize().unwrap();
1418        let mut cfg = Config::default();
1419        cfg.graph.worktree_root = Some(home.join("worktrees"));
1420        cfg.disk.min_free_bytes = 100;
1421        let cache = home.join("cache");
1422        cfg.verify.gate = vec![format!(
1423            "CARGO_TARGET_DIR='{}' cargo build",
1424            cache.display()
1425        )];
1426        let mut state = RunState::new(
1427            home.clone(),
1428            "main".into(),
1429            "base".into(),
1430            "verify".into(),
1431            cfg.clone(),
1432        );
1433        state.resource_block = Some(ResourceBlock {
1434            node: "gate".into(),
1435            kind: "disk admission".into(),
1436            detail: "writer headroom unavailable".into(),
1437            cause: ResourceBlockCause::Other,
1438            at: Timestamp::now(),
1439        });
1440        state.save_under(&home).unwrap();
1441        let mut task = task("verify", home.clone());
1442        task.runs = vec![state.id.clone()];
1443        task.hold_machine(Some("[resource] gate: disk admission: blocked".into()));
1444        let gib = 1024 * 1024 * 1024;
1445        let free = std::cell::Cell::new(100 + gib - 1);
1446        let check = || {
1447            machine_cause_resolved_with_admission(&task, &cfg, &home, |paths| {
1448                assert!(
1449                    paths.contains(&cache),
1450                    "the cache volume must also be checked"
1451                );
1452                assert!(paths.contains(&state.worktree_root()));
1453                OutputLease::admit_with(&home, paths, cfg.disk.min_free_bytes, |_| Ok(free.get()))
1454                    .is_ok()
1455            })
1456        };
1457        assert_eq!(check(), Some(false), "the unchanged floor still applies");
1458        free.set(100 + gib);
1459        let writer = OutputLease::admit_with(
1460            &home,
1461            std::slice::from_ref(&home),
1462            cfg.disk.min_free_bytes,
1463            |_| Ok(free.get()),
1464        )
1465        .unwrap();
1466        assert_eq!(
1467            check(),
1468            Some(false),
1469            "df alone cannot resolve a live reservation"
1470        );
1471        drop(writer);
1472        assert_eq!(
1473            check(),
1474            Some(true),
1475            "releasing headroom resolves the machine hold"
1476        );
1477        assert_eq!(
1478            check(),
1479            Some(true),
1480            "the probe must release its temporary reservation"
1481        );
1482
1483        // A broken admission namespace still fails closed after free space recovers.
1484        let namespace = home.join("disk-admission");
1485        let saved = home.join("saved-admission");
1486        std::fs::rename(&namespace, &saved).unwrap();
1487        std::os::unix::fs::symlink(&saved, &namespace).unwrap();
1488        assert_eq!(check(), Some(false));
1489        std::fs::remove_file(&namespace).unwrap();
1490        std::fs::rename(saved, namespace).unwrap();
1491        assert_eq!(check(), Some(true));
1492
1493        state.resource_block.as_mut().unwrap().cause = ResourceBlockCause::Cancelled { park: None };
1494        state.save_under(&home).unwrap();
1495        assert_eq!(
1496            machine_cause_resolved_with_admission(&task, &cfg, &home, |_| panic!(
1497                "a cancelled operation must remain held"
1498            )),
1499            None
1500        );
1501        state.resource_block.as_mut().unwrap().kind = "incremental cache admission".into();
1502        state.resource_block.as_mut().unwrap().cause = ResourceBlockCause::Other;
1503        state.save_under(&home).unwrap();
1504        assert_eq!(
1505            machine_cause_resolved_with_admission(&task, &cfg, &home, |_| panic!(
1506                "unproven incremental caches must remain held"
1507            )),
1508            None
1509        );
1510        task.runs.push("unreadable-run".into());
1511        assert_eq!(
1512            machine_cause_resolved_with_admission(&task, &cfg, &home, |_| panic!(
1513                "missing evidence must not release a hold"
1514            )),
1515            None
1516        );
1517    }
1518
1519    /// `[disk] min_free_bytes = 0` written next to a fictional repo, so
1520    /// `machine_cause_resolved` never has to ask the real disk anything - the
1521    /// same fixture pattern `daemon`'s own idle-loop tests use.
1522    fn gate_disabled_config(dir: &std::path::Path) -> PathBuf {
1523        let config = dir.join("magi.toml");
1524        std::fs::write(&config, "[disk]\nmin_free_bytes = 0\n").unwrap();
1525        config
1526    }
1527
1528    #[test]
1529    fn resumption_later_keep_held_answer_wins_but_an_older_answer_cannot_undo_release() {
1530        for source in ["cli", "web"] {
1531            for answer_after_release in [true, false] {
1532                let (dir, queue, questions) = store();
1533                let mut t = task("recovery", dir.path().join("repo"));
1534                t.hold_machine(Some("inspect remote first".into()));
1535                queue.put(&mut t).unwrap();
1536                let mut q = file_question(
1537                    &questions,
1538                    &t,
1539                    Bucket::MachineUnknown,
1540                    &JA,
1541                    Timestamp::now(),
1542                )
1543                .unwrap();
1544                if !answer_after_release {
1545                    q.answer(Answer::Choice(q.choices[1].clone())).unwrap();
1546                    questions.put(&mut q).unwrap();
1547                }
1548                t.release_operator(source, None);
1549                queue.put(&mut t).unwrap();
1550                if answer_after_release {
1551                    q.answer(Answer::Choice(q.choices[1].clone())).unwrap();
1552                    questions.put(&mut q).unwrap();
1553                }
1554                apply_answers(&queue, &questions);
1555                let after = queue.get(&t.id).unwrap();
1556                assert!(after.triage_applied(&q.id));
1557                assert_eq!(after.operator_held(), answer_after_release);
1558                assert_eq!(
1559                    after.status,
1560                    if answer_after_release {
1561                        TaskStatus::Held
1562                    } else {
1563                        TaskStatus::Queued
1564                    }
1565                );
1566                assert!(apply_answers(&queue, &questions).is_empty());
1567            }
1568        }
1569    }
1570
1571    #[test]
1572    fn explicit_resumption_applies_legacy_queued_triage_once_and_preserves_later_holds() {
1573        let (dir, queue, questions) = store();
1574        let mut t = task("recover", dir.path().join("repo"));
1575        t.hold_machine(Some("inspect first".into()));
1576        queue.put(&mut t).unwrap();
1577        let mut q = file_question(
1578            &questions,
1579            &t,
1580            Bucket::MachineUnknown,
1581            &JA,
1582            Timestamp::now(),
1583        )
1584        .unwrap();
1585        assert!(q.actions.is_empty());
1586        q.answer(Answer::Choice(q.choices[0].clone())).unwrap();
1587        questions.put(&mut q).unwrap();
1588        // Older release paths queued the task without recording approval.
1589        t.release();
1590        t.instruction = "Reuse approved PR head".into();
1591        queue.put(&mut t).unwrap();
1592        assert_eq!(apply_answers(&queue, &questions), [t.id.clone()]);
1593        let mut after = queue.get(&t.id).unwrap();
1594        assert_eq!(
1595            after.resumption.as_ref().unwrap().question_id.as_deref(),
1596            Some(q.id.as_str())
1597        );
1598        assert_eq!(
1599            after.resumption.as_ref().unwrap().instruction,
1600            t.instruction
1601        );
1602        assert_eq!(after.answers[0].answer, JA.resume);
1603        assert!(after.triage_applied(&q.id));
1604        assert!(apply_answers(&Queue::at(dir.path().join("queue")), &questions).is_empty());
1605        after.hold_machine(Some("new blocker".into()));
1606        queue.put(&mut after).unwrap();
1607        let mut late = file_question(
1608            &questions,
1609            &after,
1610            Bucket::MachineUnknown,
1611            &EN,
1612            Timestamp::now(),
1613        )
1614        .unwrap();
1615        after.hold_manual(Some("keep held now".into()));
1616        queue.put(&mut after).unwrap();
1617        late.answer(Answer::Choice(late.choices[0].clone()))
1618            .unwrap();
1619        questions.put(&mut late).unwrap();
1620        apply_answers(&queue, &questions);
1621        let held = queue.get(&t.id).unwrap();
1622        assert!(held.operator_held());
1623        assert_eq!(held.hold_reason.as_deref(), Some("keep held now"));
1624        assert_eq!(held.resumption.as_ref().unwrap().generation, 1);
1625    }
1626
1627    #[test]
1628    fn a_resolved_machine_hold_is_requeued_automatically() {
1629        let (dir, q, questions) = store();
1630        let config = gate_disabled_config(dir.path());
1631        let mut t = task("disk pressure", dir.path().join("repo"));
1632        t.hold_machine(Some(
1633            "not enough free space to start a run: 10 bytes free, 100 required by \
1634             `[disk] min_free_bytes`"
1635                .to_owned(),
1636        ));
1637        q.put(&mut t).unwrap();
1638
1639        let report = run_once(&q, &questions, Some(&config), Timestamp::now());
1640        assert_eq!(report.resumed, [t.id.clone()]);
1641        assert!(report.asked.is_empty());
1642
1643        let back = q.get(&t.id).unwrap();
1644        assert_eq!(back.status, TaskStatus::Queued);
1645        assert!(back.hold_source.is_none());
1646        assert!(questions.list().is_empty(), "nothing needed asking");
1647    }
1648
1649    #[test]
1650    fn a_machine_hold_with_no_recognised_cause_gets_one_question_not_two() {
1651        let (dir, q, questions) = store();
1652        let mut t = task("gate went red", dir.path().join("repo"));
1653        t.hold_machine(Some("gate red".to_owned()));
1654        q.put(&mut t).unwrap();
1655
1656        let first = run_once(&q, &questions, None, Timestamp::now());
1657        assert_eq!(first.asked, [t.id.clone()]);
1658        assert!(first.resumed.is_empty());
1659
1660        let open: Vec<_> = questions
1661            .list()
1662            .into_iter()
1663            .filter(|q| q.status.open())
1664            .collect();
1665        assert_eq!(open.len(), 1);
1666        assert_eq!(open[0].run, t.id);
1667        assert_eq!(open[0].node, NODE);
1668        assert_eq!(open[0].choices.len(), 3);
1669
1670        // A second pass with nothing new must not file a second question.
1671        let second = run_once(&q, &questions, None, Timestamp::now());
1672        assert!(second.asked.is_empty());
1673        assert_eq!(
1674            questions
1675                .list()
1676                .into_iter()
1677                .filter(|q| q.status.open())
1678                .count(),
1679            1
1680        );
1681    }
1682
1683    #[test]
1684    fn a_legacy_hold_with_no_recorded_source_gets_exactly_one_question() {
1685        let (dir, q, questions) = store();
1686        let mut t = task("schema 1 record", dir.path().join("repo"));
1687        t.status = TaskStatus::Held;
1688        assert!(t.hold_source.is_none(), "the case this test is about");
1689        q.put(&mut t).unwrap();
1690
1691        let first = run_once(&q, &questions, None, Timestamp::now());
1692        assert_eq!(first.asked, [t.id.clone()]);
1693
1694        let second = run_once(&q, &questions, None, Timestamp::now());
1695        assert!(
1696            second.asked.is_empty(),
1697            "the same legacy hold must not be asked about twice"
1698        );
1699        assert_eq!(
1700            questions
1701                .list()
1702                .into_iter()
1703                .filter(|q| q.status.open())
1704                .count(),
1705            1
1706        );
1707    }
1708
1709    #[test]
1710    fn dependency_resolution_detaches_legacy_short_refs_without_dropping_other_waits() {
1711        let (dir, queue, questions) = store();
1712        let mut root = task("root", dir.path().join("repo"));
1713        root.id = "20261013-193611-ca5b".into();
1714        root.hold_machine(Some("needs owner decision".into()));
1715        queue.put(&mut root).unwrap();
1716        let mut other = task("other", dir.path().join("repo"));
1717        other.id = "20261013-192213-feb2".into();
1718        queue.put(&mut other).unwrap();
1719        let mut waiting = task("waiting", dir.path().join("repo"));
1720        waiting.block(vec!["ca5b".into(), other.id.clone()], None);
1721        queue.put(&mut waiting).unwrap();
1722        detach_dependants(&queue, &questions, &root.id);
1723        let after = queue.get(&waiting.id).unwrap();
1724        assert_eq!(after.status, TaskStatus::Blocked);
1725        assert_eq!(after.blocked_by, [other.id]);
1726    }
1727
1728    #[test]
1729    fn a_manual_hold_is_never_auto_resumed() {
1730        let (dir, q, questions) = store();
1731        let mut t = task("operator stopped this", dir.path().join("repo"));
1732        t.hold_manual(Some("waiting on a decision".to_owned()));
1733        q.put(&mut t).unwrap();
1734
1735        let report = run_once(&q, &questions, None, Timestamp::now());
1736        assert!(report.resumed.is_empty());
1737        // Fresh, not stale yet - no question either.
1738        assert!(report.asked.is_empty());
1739
1740        let back = q.get(&t.id).unwrap();
1741        assert_eq!(back.status, TaskStatus::Held);
1742        assert_eq!(back.hold_source, Some(HoldSource::Manual));
1743        assert!(questions.list().is_empty());
1744    }
1745
1746    #[test]
1747    fn a_blocked_task_on_a_deleted_dependency_is_held_and_asked_about_in_one_pass() {
1748        // The five real tasks this whole change exists for are `blocked`, not
1749        // `held`, and no daemon has to be running for `magi task triage` alone
1750        // to reach them - `run_once` must both quarantine and ask in the same
1751        // call.
1752        let (dir, q, questions) = store();
1753        let mut still_going = task("still valid", dir.path().join("repo"));
1754        q.put(&mut still_going).unwrap();
1755
1756        let mut t = task("orphaned", dir.path().join("repo"));
1757        t.block(
1758            vec!["20260101-000000-gone".to_owned(), still_going.id.clone()],
1759            Some("waits on both".to_owned()),
1760        );
1761        q.put(&mut t).unwrap();
1762
1763        let report = run_once(&q, &questions, None, Timestamp::now());
1764        assert_eq!(report.quarantined, [t.id.clone()]);
1765        assert_eq!(
1766            report.asked,
1767            [t.id.clone()],
1768            "the fresh machine hold must earn a question in the same pass"
1769        );
1770
1771        let after = q.get(&t.id).unwrap();
1772        assert_eq!(after.status, TaskStatus::Held);
1773        assert_eq!(after.hold_source, Some(HoldSource::Machine));
1774        assert!(after.blocked_by.is_empty());
1775
1776        // The reason is not disk-pressure wording, so this must not be read
1777        // as a disk hold and silently auto-resumed.
1778        assert!(!is_disk_hold(&after));
1779
1780        let open: Vec<_> = questions
1781            .list()
1782            .into_iter()
1783            .filter(|q| q.status.open())
1784            .collect();
1785        assert_eq!(open.len(), 1);
1786        assert_eq!(open[0].run, t.id);
1787
1788        // A second pass with nothing new files no second question.
1789        let second = run_once(&q, &questions, None, Timestamp::now());
1790        assert!(second.quarantined.is_empty());
1791        assert!(second.asked.is_empty());
1792    }
1793
1794    /// A held root with a chain of dependants: 9db7 <- 4135 <- 6081, and a
1795    /// second direct dependant that also waits on a queued task.
1796    fn stuck_chain(q: &Queue, dir: &std::path::Path) -> (Task, Task, Task) {
1797        let mut root = task("root", dir.join("repo"));
1798        root.hold_manual(Some("waiting".to_owned()));
1799        q.put(&mut root).unwrap();
1800        let mut mid = task("mid", dir.join("repo"));
1801        mid.block(vec![root.id.clone()], None);
1802        q.put(&mut mid).unwrap();
1803        let mut leaf = task("leaf", dir.join("repo"));
1804        leaf.block(vec![mid.id.clone()], None);
1805        q.put(&mut leaf).unwrap();
1806        (root, mid, leaf)
1807    }
1808
1809    fn deps_questions(questions: &Questions) -> Vec<Question> {
1810        questions
1811            .list()
1812            .into_iter()
1813            .filter(|q| q.node == DEPS_NODE)
1814            .collect()
1815    }
1816
1817    fn answer_deps(questions: &Questions, choice: usize) {
1818        let mut asked = deps_questions(questions).remove(0);
1819        let c = asked.choices[choice].clone();
1820        asked.answer(Answer::Choice(c)).unwrap();
1821        questions.put(&mut asked).unwrap();
1822    }
1823
1824    #[test]
1825    fn a_stuck_chain_earns_one_question_naming_every_dependant_and_is_not_reasked() {
1826        let (dir, q, questions) = store();
1827        let (root, mid, leaf) = stuck_chain(&q, dir.path());
1828
1829        let first = run_once(&q, &questions, None, Timestamp::now());
1830        assert_eq!(first.asked, std::slice::from_ref(&root.id));
1831        let asked = deps_questions(&questions);
1832        assert_eq!(asked.len(), 1, "one question per root, not per dependant");
1833        assert_eq!(asked[0].run, root.id);
1834        assert_eq!(asked[0].choices.len(), 3);
1835        assert!(asked[0].detail.contains(mid.short()), "{}", asked[0].detail);
1836        assert!(
1837            asked[0].detail.contains(leaf.short()),
1838            "{}",
1839            asked[0].detail
1840        );
1841
1842        let second = run_once(&q, &questions, None, Timestamp::now());
1843        assert!(second.asked.is_empty());
1844        assert_eq!(deps_questions(&questions).len(), 1);
1845        assert!(pending_for(&questions, &q.get(&root.id).unwrap()));
1846    }
1847
1848    #[test]
1849    fn a_stuck_root_with_a_machine_hold_gets_only_the_dependency_question() {
1850        let (dir, q, questions) = store();
1851        let mut root = task("root", dir.path().join("repo"));
1852        root.hold_machine(Some("gate red".to_owned()));
1853        q.put(&mut root).unwrap();
1854        let mut dep = task("dep", dir.path().join("repo"));
1855        dep.block(vec![root.id.clone()], None);
1856        q.put(&mut dep).unwrap();
1857
1858        run_once(&q, &questions, None, Timestamp::now());
1859        run_once(&q, &questions, None, Timestamp::now());
1860        assert_eq!(deps_questions(&questions).len(), 1);
1861        assert_eq!(
1862            questions.list().len(),
1863            1,
1864            "no second question about the hold"
1865        );
1866    }
1867
1868    #[test]
1869    fn a_dependency_that_can_still_run_asks_nothing() {
1870        let (dir, q, questions) = store();
1871        let mut live = task("live", dir.path().join("repo"));
1872        q.put(&mut live).unwrap();
1873        let mut dep = task("dep", dir.path().join("repo"));
1874        dep.block(vec![live.id.clone()], None);
1875        q.put(&mut dep).unwrap();
1876        let report = run_once(&q, &questions, None, Timestamp::now());
1877        assert!(report.asked.is_empty());
1878        assert!(questions.list().is_empty());
1879    }
1880
1881    #[test]
1882    fn answering_release_requeues_the_root_and_is_not_reasked() {
1883        let (dir, q, questions) = store();
1884        let (root, _mid, _leaf) = stuck_chain(&q, dir.path());
1885        run_once(&q, &questions, None, Timestamp::now());
1886        answer_deps(&questions, 0);
1887
1888        let report = run_once(&q, &questions, None, Timestamp::now());
1889        assert_eq!(report.answered, std::slice::from_ref(&root.id));
1890        assert!(report.asked.is_empty(), "applying must not re-ask");
1891        assert_eq!(q.get(&root.id).unwrap().status, TaskStatus::Queued);
1892        let again = run_once(&q, &questions, None, Timestamp::now());
1893        assert!(again.asked.is_empty() && again.answered.is_empty());
1894        assert_eq!(deps_questions(&questions).len(), 1);
1895    }
1896
1897    #[test]
1898    fn answering_detach_frees_the_direct_dependant_and_keeps_the_root() {
1899        let (dir, q, questions) = store();
1900        let (root, mid, leaf) = stuck_chain(&q, dir.path());
1901        run_once(&q, &questions, None, Timestamp::now());
1902        answer_deps(&questions, 2);
1903
1904        let report = run_once(&q, &questions, None, Timestamp::now());
1905        assert!(report.asked.is_empty());
1906        assert_eq!(q.get(&root.id).unwrap().status, TaskStatus::Held);
1907        assert_eq!(q.get(&mid.id).unwrap().status, TaskStatus::Queued);
1908        let leaf = q.get(&leaf.id).unwrap();
1909        assert_eq!(leaf.status, TaskStatus::Blocked, "still waits on mid");
1910        assert_eq!(leaf.blocked_by, std::slice::from_ref(&mid.id));
1911    }
1912
1913    #[test]
1914    fn a_dependant_that_can_progress_through_another_blocker_is_not_stuck() {
1915        let (dir, q, questions) = store();
1916        let (root, mid, _leaf) = stuck_chain(&q, dir.path());
1917        let mut live = task("live", dir.path().join("repo"));
1918        q.put(&mut live).unwrap();
1919        let mut both = q.get(&mid.id).unwrap();
1920        both.block(vec![root.id.clone(), live.id.clone()], None);
1921        q.put(&mut both).unwrap();
1922        // `mid` can still progress through `live`, so nothing is stuck yet.
1923        assert!(
1924            run_once(&q, &questions, None, Timestamp::now())
1925                .asked
1926                .is_empty()
1927        );
1928    }
1929
1930    #[test]
1931    fn answering_discard_detaches_then_removes_the_root() {
1932        let (dir, q, questions) = store();
1933        let (root, mid, _leaf) = stuck_chain(&q, dir.path());
1934        run_once(&q, &questions, None, Timestamp::now());
1935        answer_deps(&questions, 1);
1936
1937        let report = run_once(&q, &questions, None, Timestamp::now());
1938        assert!(q.get(&root.id).is_err());
1939        assert_eq!(q.get(&mid.id).unwrap().status, TaskStatus::Queued);
1940        assert!(
1941            report.asked.is_empty(),
1942            "no per-dependant quarantine question"
1943        );
1944        assert!(report.quarantined.is_empty());
1945    }
1946
1947    #[test]
1948    fn an_unmatched_deps_answer_changes_nothing_and_is_not_reasked() {
1949        let (dir, q, questions) = store();
1950        let (root, mid, _leaf) = stuck_chain(&q, dir.path());
1951        run_once(&q, &questions, None, Timestamp::now());
1952        let mut asked = deps_questions(&questions).remove(0);
1953        asked.choices.clear();
1954        asked.answer(Answer::Text("dunno".to_owned())).unwrap();
1955        questions.put(&mut asked).unwrap();
1956
1957        for _ in 0..2 {
1958            let report = run_once(&q, &questions, None, Timestamp::now());
1959            assert!(report.asked.is_empty() && report.answered.is_empty());
1960        }
1961        assert_eq!(deps_questions(&questions).len(), 1);
1962        assert_eq!(q.get(&root.id).unwrap().status, TaskStatus::Held);
1963        assert_eq!(q.get(&mid.id).unwrap().status, TaskStatus::Blocked);
1964    }
1965
1966    #[test]
1967    fn a_dependency_cycle_terminates_and_is_asked_about_once() {
1968        let (dir, q, questions) = store();
1969        let mut a = task("a", dir.path().join("repo"));
1970        let mut b = task("b", dir.path().join("repo"));
1971        a.block(vec![b.id.clone()], None);
1972        b.block(vec![a.id.clone()], None);
1973        q.put(&mut a).unwrap();
1974        q.put(&mut b).unwrap();
1975
1976        let first = run_once(&q, &questions, None, Timestamp::now());
1977        assert_eq!(first.asked.len(), 1);
1978        let second = run_once(&q, &questions, None, Timestamp::now());
1979        assert!(second.asked.is_empty());
1980        assert_eq!(deps_questions(&questions).len(), 1);
1981    }
1982
1983    #[test]
1984    fn a_missing_dependency_is_still_quarantined_not_asked_about_as_stuck() {
1985        let (dir, q, questions) = store();
1986        let mut t = task("orphan", dir.path().join("repo"));
1987        t.block(vec!["20260101-000000-gone".to_owned()], None);
1988        q.put(&mut t).unwrap();
1989        let report = run_once(&q, &questions, None, Timestamp::now());
1990        assert_eq!(report.quarantined, [t.id.clone()]);
1991        assert!(deps_questions(&questions).is_empty());
1992    }
1993
1994    #[test]
1995    fn a_stale_manual_hold_earns_a_two_choice_question() {
1996        let (dir, q, questions) = store();
1997        let mut t = task("been sitting a while", dir.path().join("repo"));
1998        t.hold_manual(Some("waiting on a decision".to_owned()));
1999        q.put(&mut t).unwrap();
2000        // Back-date the hold past MANUAL_STALE_AFTER without waiting a week.
2001        let mut back = q.get(&t.id).unwrap();
2002        back.updated_at = Timestamp::now() - SignedDuration::new(8 * 24 * 60 * 60, 0);
2003        std::fs::write(
2004            q.path_of(&back.id),
2005            serde_json::to_string_pretty(&back).unwrap(),
2006        )
2007        .unwrap();
2008
2009        let report = run_once(&q, &questions, None, Timestamp::now());
2010        assert_eq!(report.asked, [t.id.clone()]);
2011        let open: Vec<_> = questions
2012            .list()
2013            .into_iter()
2014            .filter(|q| q.status.open())
2015            .collect();
2016        assert_eq!(open.len(), 1);
2017        assert_eq!(open[0].choices.len(), 2);
2018    }
2019
2020    #[test]
2021    fn answering_resume_releases_the_task() {
2022        let (dir, q, questions) = store();
2023        let mut t = task("gate went red", dir.path().join("repo"));
2024        t.hold_machine(Some("gate red".to_owned()));
2025        q.put(&mut t).unwrap();
2026        run_once(&q, &questions, None, Timestamp::now());
2027
2028        let mut asked = questions
2029            .list()
2030            .into_iter()
2031            .find(|q| q.run == t.id)
2032            .unwrap();
2033        asked.answer(Answer::Choice(EN.resume.to_owned())).unwrap();
2034        questions.put(&mut asked).unwrap();
2035
2036        let report = run_once(&q, &questions, None, Timestamp::now());
2037        assert_eq!(report.answered, [t.id.clone()]);
2038        let back = q.get(&t.id).unwrap();
2039        assert_eq!(back.status, TaskStatus::Queued);
2040        assert!(back.hold_source.is_none());
2041    }
2042
2043    /// A task released by a "resume" answer, run, and failed back to `held`.
2044    fn resumed_then_failed(q: &Queue, questions: &Questions, dir: &std::path::Path) -> Task {
2045        let mut t = task("gate went red", dir.join("repo"));
2046        t.hold_machine(Some("gate red".to_owned()));
2047        q.put(&mut t).unwrap();
2048        run_once(q, questions, None, Timestamp::now());
2049        let mut asked = questions
2050            .list()
2051            .into_iter()
2052            .find(|q| q.run == t.id)
2053            .unwrap();
2054        asked.answer(Answer::Choice(EN.resume.to_owned())).unwrap();
2055        questions.put(&mut asked).unwrap();
2056
2057        let report = run_once(q, questions, None, Timestamp::now());
2058        assert_eq!(report.answered, [t.id.clone()]);
2059        let mut back = q.get(&t.id).unwrap();
2060        assert_eq!(back.status, TaskStatus::Queued);
2061        assert_eq!(back.attempts, 0);
2062
2063        back.start("run-1".to_owned());
2064        back.fail("rebase conflict", 1);
2065        assert_eq!(back.status, TaskStatus::Held);
2066        q.put(&mut back).unwrap();
2067        back
2068    }
2069
2070    #[test]
2071    fn a_resume_answer_is_applied_once_and_a_new_machine_hold_is_asked_about() {
2072        let (dir, q, questions) = store();
2073        let t = resumed_then_failed(&q, &questions, dir.path());
2074
2075        let report = run_once(&q, &questions, None, Timestamp::now());
2076        assert!(report.answered.is_empty(), "the old answer must not replay");
2077        assert_eq!(report.asked, std::slice::from_ref(&t.id));
2078        let back = q.get(&t.id).unwrap();
2079        assert_eq!(back.status, TaskStatus::Held);
2080        assert_eq!(
2081            questions
2082                .list()
2083                .into_iter()
2084                .filter(|q| q.status.open())
2085                .count(),
2086            1
2087        );
2088    }
2089
2090    #[test]
2091    fn a_manual_hold_placed_after_a_resume_is_not_undone_by_the_old_answer() {
2092        let (dir, q, questions) = store();
2093        let mut t = resumed_then_failed(&q, &questions, dir.path());
2094        t.hold_manual(Some("operator stopped this".to_owned()));
2095        q.put(&mut t).unwrap();
2096        let before = questions.list().len();
2097
2098        let report = run_once(&q, &questions, None, Timestamp::now());
2099        assert!(report.answered.is_empty());
2100        assert!(report.asked.is_empty());
2101        let back = q.get(&t.id).unwrap();
2102        assert_eq!(back.status, TaskStatus::Held);
2103        assert_eq!(back.hold_source, Some(HoldSource::Manual));
2104        assert_eq!(questions.list().len(), before);
2105    }
2106
2107    #[test]
2108    fn answering_not_yet_keeps_it_held_as_a_manual_hold_and_does_not_reapply() {
2109        let (dir, q, questions) = store();
2110        let mut t = task("gate went red", dir.path().join("repo"));
2111        t.hold_machine(Some("gate red".to_owned()));
2112        q.put(&mut t).unwrap();
2113        run_once(&q, &questions, None, Timestamp::now());
2114
2115        let mut asked = questions
2116            .list()
2117            .into_iter()
2118            .find(|q| q.run == t.id)
2119            .unwrap();
2120        asked.answer(Answer::Choice(EN.wait.to_owned())).unwrap();
2121        questions.put(&mut asked).unwrap();
2122
2123        let report = run_once(&q, &questions, None, Timestamp::now());
2124        assert_eq!(report.answered, [t.id.clone()]);
2125        let back = q.get(&t.id).unwrap();
2126        assert_eq!(back.status, TaskStatus::Held);
2127        assert_eq!(back.hold_source, Some(HoldSource::Manual));
2128        assert!(
2129            back.hold_reason
2130                .as_deref()
2131                .is_some_and(|r| r.contains("gate red")),
2132            "the original cause must survive a \"not yet\" answer, not just the \
2133             triage marker: {:?}",
2134            back.hold_reason
2135        );
2136
2137        // A third pass, same instant: the manual hold is fresh (just
2138        // touched), so nothing more happens - in particular the already
2139        // answered question is not re-applied.
2140        let third = run_once(&q, &questions, None, Timestamp::now());
2141        assert!(third.answered.is_empty());
2142        assert!(third.asked.is_empty());
2143    }
2144
2145    #[test]
2146    fn answering_discard_removes_the_task_entirely() {
2147        let (dir, q, questions) = store();
2148        let mut t = task("gate went red", dir.path().join("repo"));
2149        t.hold_machine(Some("gate red".to_owned()));
2150        q.put(&mut t).unwrap();
2151        run_once(&q, &questions, None, Timestamp::now());
2152
2153        let mut asked = questions
2154            .list()
2155            .into_iter()
2156            .find(|q| q.run == t.id)
2157            .unwrap();
2158        asked.answer(Answer::Choice(EN.discard.to_owned())).unwrap();
2159        questions.put(&mut asked).unwrap();
2160
2161        let report = run_once(&q, &questions, None, Timestamp::now());
2162        assert_eq!(report.answered, [t.id.clone()]);
2163        assert!(
2164            q.get(&t.id).is_err(),
2165            "\"discard it\" (捨ててよい) must actually discard the task, not \
2166             just leave it sitting held forever"
2167        );
2168    }
2169
2170    #[test]
2171    fn an_answer_is_read_by_its_position_in_choices_not_by_the_callers_current_language() {
2172        // Filed while the repo's config reads Japanese...
2173        let (dir, q, questions) = store();
2174        let ja_config = dir.path().join("ja.toml");
2175        std::fs::write(&ja_config, "[graph]\nlanguage = \"ja\"\n").unwrap();
2176        let mut t = task("gate went red", dir.path().join("repo"));
2177        t.hold_machine(Some("gate red".to_owned()));
2178        q.put(&mut t).unwrap();
2179        run_once(&q, &questions, Some(&ja_config), Timestamp::now());
2180
2181        let mut asked = questions
2182            .list()
2183            .into_iter()
2184            .find(|q| q.run == t.id)
2185            .unwrap();
2186        assert_eq!(asked.choices[0], JA.resume, "filed in Japanese");
2187        asked.answer(Answer::Choice(JA.resume.to_owned())).unwrap();
2188        questions.put(&mut asked).unwrap();
2189
2190        // ...but applied against an English config (a later `--config`, or an
2191        // edited repository config). The Japanese "再開してよい" answer must
2192        // still be read as a resume, not silently misread as "keep held"
2193        // because it fails a text comparison against the English wording.
2194        let en_config = dir.path().join("en.toml");
2195        std::fs::write(&en_config, "[graph]\nlanguage = \"en\"\n").unwrap();
2196        let report = run_once(&q, &questions, Some(&en_config), Timestamp::now());
2197        assert_eq!(report.answered, [t.id.clone()]);
2198        let back = q.get(&t.id).unwrap();
2199        assert_eq!(
2200            back.status,
2201            TaskStatus::Queued,
2202            "a resume answer must resume the task regardless of which \
2203             language it is read back in"
2204        );
2205    }
2206
2207    #[test]
2208    fn a_question_falls_back_to_last_error_when_hold_reason_was_never_set() {
2209        // A record written before `Task::fail` started copying `why` into
2210        // `hold_reason` too (or one written by a still older build) carries
2211        // only `last_error`. The question detail must still name a cause
2212        // rather than reading "(none recorded)".
2213        let (dir, q, questions) = store();
2214        let mut t = task("kept failing the gate", dir.path().join("repo"));
2215        t.start("run-1".to_owned());
2216        t.fail("gate red three times running", 1);
2217        assert_eq!(t.status, TaskStatus::Held);
2218        t.hold_reason = None; // simulate a pre-fix or pre-schema record
2219        q.put(&mut t).unwrap();
2220
2221        run_once(&q, &questions, None, Timestamp::now());
2222        let asked = questions
2223            .list()
2224            .into_iter()
2225            .find(|q| q.run == t.id)
2226            .unwrap();
2227        assert!(
2228            asked.detail.contains("gate red three times running"),
2229            "the question must surface `last_error` when there is no \
2230             `hold_reason` to show instead: {}",
2231            asked.detail
2232        );
2233    }
2234
2235    #[test]
2236    fn open_question_for_and_open_task_ids_reflect_only_what_is_still_waiting() {
2237        let (dir, q, questions) = store();
2238        let mut t = task("gate went red", dir.path().join("repo"));
2239        t.hold_machine(Some("gate red".to_owned()));
2240        q.put(&mut t).unwrap();
2241
2242        assert!(open_question_for(&questions, &t.id).is_none());
2243        assert!(!open_task_ids(&questions).contains(&t.id));
2244
2245        run_once(&q, &questions, None, Timestamp::now());
2246        assert!(open_question_for(&questions, &t.id).is_some());
2247        assert!(open_task_ids(&questions).contains(&t.id));
2248
2249        let mut asked = questions
2250            .list()
2251            .into_iter()
2252            .find(|q| q.run == t.id)
2253            .unwrap();
2254        asked.answer(Answer::Choice(EN.resume.to_owned())).unwrap();
2255        questions.put(&mut asked).unwrap();
2256
2257        assert!(
2258            open_question_for(&questions, &t.id).is_none(),
2259            "an answered question is no longer open"
2260        );
2261        assert!(!open_task_ids(&questions).contains(&t.id));
2262    }
2263
2264    #[test]
2265    fn pending_for_stays_true_between_an_answer_and_the_next_run_once_pass() {
2266        // `open_question_for` alone goes `None` the instant the operator
2267        // answers, well before `run_once` - idle-tick only - gets a turn to
2268        // actually apply that answer (see `already_applied`). `pending_for`
2269        // exists so a caller polling far more often than `run_once` does -
2270        // `crate::conduct::apply_one` - does not walk through that gap.
2271        let (dir, q, questions) = store();
2272        let mut t = task("gate went red", dir.path().join("repo"));
2273        t.hold_machine(Some("gate red".to_owned()));
2274        q.put(&mut t).unwrap();
2275
2276        assert!(!pending_for(&questions, &t));
2277
2278        run_once(&q, &questions, None, Timestamp::now());
2279        let held = q.get(&t.id).unwrap();
2280        assert!(pending_for(&questions, &held), "still waiting on an answer");
2281
2282        let mut asked = questions
2283            .list()
2284            .into_iter()
2285            .find(|q| q.run == t.id)
2286            .unwrap();
2287        asked.answer(Answer::Choice(EN.wait.to_owned())).unwrap();
2288        questions.put(&mut asked).unwrap();
2289        assert!(!asked.status.open());
2290
2291        // The race window: answered, but `run_once` has not run again yet.
2292        let still_held = q.get(&t.id).unwrap();
2293        assert!(
2294            pending_for(&questions, &still_held),
2295            "answered but not yet applied is still pending"
2296        );
2297
2298        run_once(&q, &questions, None, Timestamp::now());
2299        let after = q.get(&t.id).unwrap();
2300        assert!(
2301            !pending_for(&questions, &after),
2302            "the answer is applied now, nothing left pending"
2303        );
2304    }
2305}