Skip to main content

magi/
task_chat.rs

1//! Durable task-decision outbox. Questions remain the transport from restricted
2//! seats; only the daemon writes the task link and the talk's own draft.
3use crate::task_inquiry::HistoryResolution;
4use anyhow::{Context, Result};
5use std::path::Path;
6
7use crate::{
8    ask::{Question, Questions},
9    config::Config,
10    queue::{Queue, Task},
11    talk::{self, Talks},
12};
13
14/// Never guess when more than one task claims the same run.
15pub fn task_of(q: &Question, tasks: &[Task]) -> Option<String> {
16    let mut matching = tasks
17        .iter()
18        .filter(|t| t.id == q.run || t.runs.contains(&q.run));
19    let task = matching.next()?;
20    matching.next().is_none().then(|| task.id.clone())
21}
22
23/// Informational bump notices have no decision. Every actionable task inquiry
24/// routes to chat, including recovery of approvals without a saved target.
25pub(crate) fn chat_routable(q: &Question) -> bool {
26    q.node != crate::bump::NOTICE_NODE
27        || q.merge_target.is_some()
28        || (q.seat == "release-watch" && !q.choices.is_empty())
29}
30
31/// Routed questions whose answer is consumed by machinery (the posting gate,
32/// the branch-divergence reconcile, the release watcher) rather than by a
33/// step-1 control command. They stay open after delivery and the chat settles
34/// them with `magi task control decide`, including merge and recovery
35/// decisions: the agent records the owner's request as it is.
36pub fn awaits_decision(q: &Question) -> bool {
37    q.node == crate::land::APPROVAL_NODE
38        || q.merge_target.is_some()
39        || (chat_routable(q)
40            // A structured action (done, resume, requeue ...) is applied by the
41            // daemon from the recorded answer, so the record must stay open.
42            && (!q.actions.is_empty()
43                || q.node == crate::github_text::ASK_NODE
44                || q.node == crate::triage::NODE
45                || q.node == crate::triage::DEPS_NODE
46                || (q.node == crate::reconcile::NODE && q.seat == crate::reconcile::SEAT)
47                || (q.node == crate::bump::NOTICE_NODE && q.seat == "release-watch")))
48}
49
50/// Also recognize legacy and watch-linked records before the first sweep.
51pub(crate) fn routes(q: &Question, home: &Path) -> bool {
52    if q.routed_task.is_some() {
53        return true;
54    }
55    if standalone_inquiry(home, q) {
56        return false;
57    }
58    if !q.status.open() || !chat_routable(q) {
59        return false;
60    }
61    let tasks = Queue::at(home.join("queue")).list();
62    let watches = crate::release_watch::states_for_questions(home, std::slice::from_ref(q));
63    task_of_with_watches(q, &tasks, &watches).is_some()
64}
65
66/// Shared task destination reservation for decisions and attention reports.
67pub(crate) fn destination(
68    queue: &Queue,
69    talks: &Talks,
70    task_id: &str,
71) -> Result<(Task, talk::Talk)> {
72    destination_checked(queue, talks, task_id, |_| Ok(()))
73}
74
75/// Validate an inquiry's ownership inside the task destination reservation.
76pub(crate) fn destination_checked(
77    queue: &Queue,
78    talks: &Talks,
79    task_id: &str,
80    check: impl FnOnce(&Task) -> Result<()>,
81) -> Result<(Task, talk::Talk)> {
82    let mut reserved = None;
83    let mut invalid = None;
84    queue.modify(task_id, |task| {
85        if let Err(error) = check(task) {
86            invalid = Some(error);
87            return false;
88        }
89        let associated = task
90            .chat
91            .clone()
92            .or_else(|| task.filed_by_chat().map(str::to_owned))
93            .or_else(|| crate::consult::chat_talk_of(&queue.list(), task));
94        // Persist ownership before any talk operation. A failed delivery keeps
95        // this reservation so the next sweep uses exactly the same destination.
96        let id = associated.unwrap_or_else(|| format!("task-{}", task.id));
97        let changed = task.chat.as_ref() != Some(&id);
98        task.chat = Some(id.clone());
99        reserved = Some((task.clone(), id));
100        changed
101    })?;
102    if let Some(error) = invalid {
103        return Err(error);
104    }
105    let (task, id) = reserved.context("task chat destination was not reserved")?;
106    let chat = destination_in(talks, &task.repo, &id)?;
107    Ok((task, chat))
108}
109
110/// Stable IDs also reserve run-only and home-wide operations conversations.
111/// Creation is serialized by `begin_with_id`; the first repo context persists.
112pub(crate) fn destination_in(talks: &Talks, repo: &Path, id: &str) -> Result<talk::Talk> {
113    let load = |id: &str| -> Result<talk::Talk> {
114        if talks.path_of(id).exists() {
115            talks.get(id)
116        } else {
117            let (cfg, _) = Config::discover(repo, None)?;
118            talk::begin_with_id(
119                talks,
120                &cfg,
121                repo.to_path_buf(),
122                None,
123                &talk::Preferred {
124                    agent: None,
125                    persona: None,
126                    implementers: Some(1),
127                },
128                Some(id.to_owned()),
129            )
130        }
131    };
132    load(id)
133}
134
135/// Build task-owned discussion and control guidance for current intent.
136pub(crate) fn live_record(home: &Path, task: &Task, q: &Question) -> crate::task_inquiry::Inquiry {
137    let run = if q.run == task.id {
138        task.runs.last().map(String::as_str).unwrap_or("none")
139    } else {
140        &q.run
141    };
142    let facts = crate::chat_notify::run_facts(home, run);
143    let clean = |s: &str| -> String {
144        crate::prompt::defuse(&crate::scrub::scrub(s, &crate::scrub::Identity::current()))
145            .chars()
146            .take(12_000)
147            .collect()
148    };
149    let pr = q
150        .merge_target
151        .as_ref()
152        .map(|t| t.pr.as_str())
153        .or(facts.pr.as_deref())
154        .unwrap_or("none");
155    let body = format!(
156        "# {}\n\n{}\n\n{}\n\nTask: {}\nRun: {}\nPR: {}\nState: {}\n",
157        crate::prompt::TASK_MESSAGE_HEADING,
158        clean(&q.summary),
159        clean(&q.detail),
160        task.id,
161        run,
162        clean(pr),
163        task.status.as_str()
164    );
165    let instructions = if let Some(target) = &q.merge_target {
166        format!(
167            "\nMerge decision {} for PR {} at head {}: explain the decision and include this full question ID in your reply to offer the chat buttons. Buttons are optional; when the owner asks to merge, record it with `magi task control decide {} merge` (exactly this head is merged). For non-merge recovery (repair, dismiss, withdraw or replacement), carry out what the owner asks with `magi task control decide {} <option>`. Silence is a hold.\n",
168            q.id, target.pr, target.head, q.id, q.id
169        )
170    } else if awaits_decision(q) {
171        let offered = if q.choices.is_empty() {
172            String::new()
173        } else {
174            format!(
175                " The recorded options are: {}.",
176                q.choices
177                    .iter()
178                    .map(|c| format!("`{c}`"))
179                    .collect::<Vec<_>>()
180                    .join(", ")
181            )
182        };
183        format!(
184            "\nDecision {}: discuss it with the owner as free text.{offered} When the owner decides, record it with `magi task control decide {} <option>`. For a publication `use my text` decision, add `--title <literal replacement title>` to pass the title as data. Do not start a deputy/waiter. Silence is a hold.\n",
185            q.id, q.id
186        )
187    } else {
188        "\nDiscuss this free-text decision with the owner. Apply decisions only through `magi task control`. Do not answer the legacy question or start a deputy/waiter.\n".into()
189    };
190    let legacy_answer = q.resolution().map(|answer| format!(
191        "\nHistorical saved reply (evidence only, never a new owner request): {}. Inspect the operation receipt; do not replay it.\n", clean(&answer)
192    )).unwrap_or_default();
193    let text = format!(
194        "{body}\nThis automatic report is not an owner instruction. Investigate and report; it authorizes neither repository edits nor new tasks.\n{instructions}{legacy_answer}"
195    );
196    crate::task_inquiry::Inquiry {
197        schema: 1,
198        id: q.id.clone(),
199        task: task.id.clone(),
200        run: task.runs.contains(&q.run).then(|| q.run.clone()),
201        repo: task.repo.clone(),
202        source: format!("{}:{}:{}", q.node, q.seat, q.run),
203        occurrence: None,
204        text,
205        display: format!("{body}{legacy_answer}"),
206        key: format!("question:{}", q.id),
207        evidence: Some(crate::notice_semantics::question(home, task, run, q)),
208        created_at: q.asked_at,
209        delivered_to: None,
210        decision: Some(crate::task_decision::Decision::awaiting(q.summary.clone())),
211        delivery_error: None,
212        archived: false,
213    }
214}
215
216/// Reserve the destination under the task lock, then deliver without it.
217/// A stable creation id and persisted link let retries recover interrupted delivery.
218/// Never wait for a talk lock while holding the task write lock.
219pub fn post(
220    queue: &Queue,
221    talks: &Talks,
222    home: &Path,
223    task_id: &str,
224    q: &Question,
225) -> Result<String> {
226    post_in(queue, talks, home, task_id, q, &InquiryOwnership::default())
227}
228
229fn post_in(
230    queue: &Queue,
231    talks: &Talks,
232    home: &Path,
233    task_id: &str,
234    q: &Question,
235    ownership: &InquiryOwnership,
236) -> Result<String> {
237    let task = queue.get(task_id)?;
238    let outbox = crate::task_inquiry::Outbox::at(home);
239    outbox.enqueue(live_record(home, &task, q))?;
240    // Fresh consent can predate task ownership. Once the inquiry has its
241    // owner, bind that exact response before chat creation/delivery can fail.
242    // Saved replies without the live acceptance generation remain history.
243    if q.resolution().is_some()
244        && q.accepted_answer_at.is_some()
245        && q.accepted_answer_at == q.answered_at
246    {
247        accept_fresh_reply(home, q, ownership)?;
248    }
249    outbox.deliver(queue, talks, &q.id)
250}
251
252/// Snapshot reader for the finite legacy population. New operational records
253/// follow the ordinary route below; history is processed once and never wakes
254/// a conversation just because an upgrade or scheduler restart occurred.
255#[derive(serde::Serialize, serde::Deserialize)]
256struct Migration {
257    schema: u32,
258    /// Finite, restartable correction of imports made by the reopening view.
259    #[serde(default)]
260    classification_revision: u32,
261    pending: Vec<String>,
262    /// Immutable boundary, retained after individual imports finish.
263    #[serde(default)]
264    sources: Option<std::collections::BTreeSet<String>>,
265    #[serde(default)]
266    errors: std::collections::BTreeMap<String, String>,
267}
268
269/// Whether a saved source belongs to the finite history import. A corrupt
270/// boundary is a hold, never evidence that its replies may be executed.
271pub(crate) fn migration_sources(home: &Path) -> Result<Option<std::collections::BTreeSet<String>>> {
272    let path = home.join("notifications/task-chat-migration-v1/state.json");
273    let bytes = match std::fs::read(path) {
274        Ok(bytes) => bytes,
275        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
276            return Ok(Some(Default::default()));
277        }
278        Err(error) => return Err(error.into()),
279    };
280    let state: Migration = serde_json::from_slice(&bytes)?;
281    anyhow::ensure!(state.schema == 1, "unsupported inquiry migration");
282    Ok(state.sources)
283}
284
285/// Ownership evidence scoped to one scan, with no process-wide cache.
286#[derive(Default)]
287pub(crate) struct InquiryOwnership {
288    /// Task id / run id -> the distinct tasks naming it, built from one queue
289    /// read.
290    owned: std::cell::OnceCell<std::collections::HashMap<String, Vec<String>>>,
291    origins: std::cell::RefCell<std::collections::HashMap<String, (bool, bool)>>,
292}
293
294impl InquiryOwnership {
295    pub(crate) fn from_tasks(tasks: &[Task]) -> Self {
296        let index = Self::default();
297        let _ = index.owned.set(Self::owned_ids(tasks));
298        index
299    }
300
301    fn owned_ids(tasks: &[Task]) -> std::collections::HashMap<String, Vec<String>> {
302        let mut map: std::collections::HashMap<String, Vec<String>> =
303            std::collections::HashMap::new();
304        for task in tasks {
305            let mut seen = std::collections::HashSet::new();
306            for key in std::iter::once(&task.id).chain(task.runs.iter()) {
307                if seen.insert(key.as_str()) {
308                    map.entry(key.clone()).or_default().push(task.id.clone());
309                }
310            }
311        }
312        map
313    }
314
315    fn index(&self, home: &Path) -> &std::collections::HashMap<String, Vec<String>> {
316        self.owned
317            .get_or_init(|| Self::owned_ids(&Queue::at(home.join("queue")).list()))
318    }
319
320    /// Same decision as [`task_of`], answered from the shared index.
321    pub(crate) fn task_of(&self, home: &Path, q: &Question) -> Option<String> {
322        match self.index(home).get(&q.run)?.as_slice() {
323            [only] => Some(only.clone()),
324            _ => None,
325        }
326    }
327}
328
329/// A foreground ask without run/task attribution retains legacy ownership.
330/// Release-watch inquiries may have an empty run but still belong to a task.
331pub(crate) fn standalone_inquiry(home: &Path, q: &Question) -> bool {
332    standalone_inquiry_in(home, q, &InquiryOwnership::default())
333}
334
335pub(crate) fn standalone_inquiry_in(
336    home: &Path,
337    q: &Question,
338    ownership: &InquiryOwnership,
339) -> bool {
340    if q.routed_task.is_some() || (q.node == crate::bump::NOTICE_NODE && q.seat == "release-watch")
341    {
342        return false;
343    }
344    if q.legacy_foreground || q.run.is_empty() {
345        return true;
346    }
347    // Older foreground asks have no explicit route marker. Recognize only
348    // positive legacy provenance, never infer it from a missing task alone.
349    if ownership.index(home).contains_key(&q.run) {
350        return false;
351    }
352    let (task_origin, foreground_origin) = *ownership
353        .origins
354        .borrow_mut()
355        .entry(q.run.clone())
356        .or_insert_with(|| {
357            let run = crate::run::RunState::load_under(&q.run, home).ok();
358            let origin = run.as_ref().and_then(|run| run.origin.as_ref());
359            (
360                origin.is_some_and(|origin| origin.task.is_some()),
361                origin.is_some_and(|origin| origin.task.is_none()),
362            )
363        });
364    if task_origin {
365        return false;
366    }
367    (q.node == "ask" && q.seat == "operator") || (q.cwd.is_some() && foreground_origin)
368}
369
370pub(crate) fn migrated_source(home: &Path, id: &str) -> bool {
371    migrated_source_in(home, id, &InquiryOwnership::default())
372}
373
374pub(crate) fn migrated_source_in(home: &Path, id: &str, ownership: &InquiryOwnership) -> bool {
375    // Also repairs the effective scope of older, overbroad journals without
376    // decoding the entire history on each scheduler lap.
377    if Questions::at(home.join("questions"))
378        .read_history(id)
379        .is_ok_and(|q| standalone_inquiry_in(home, &q, ownership))
380    {
381        return false;
382    }
383    migration_sources(home).map_or_else(
384        |error| {
385            tracing::warn!("source {id} stays held: {error:#}");
386            true
387        },
388        |sources| sources.as_ref().is_none_or(|ids| ids.contains(id)),
389    )
390}
391
392/// A live answer update is distinct from importing a saved reply. Persist its
393/// exact generation before Questions exposes it to an effect consumer, even
394/// when the first migration sweep has not run yet. Queuing is not resolution.
395pub(crate) fn accept_fresh_reply(
396    home: &Path,
397    q: &Question,
398    ownership: &InquiryOwnership,
399) -> Result<()> {
400    if standalone_inquiry_in(home, q, ownership) {
401        return Ok(());
402    }
403    let outbox = crate::task_inquiry::Outbox::at(home);
404    match outbox.get(&q.id) {
405        Ok(record)
406            if record.decision.as_ref().is_some_and(|decision| {
407                decision.status == crate::task_decision::Status::Resolved
408            }) =>
409        {
410            return Ok(());
411        }
412        Ok(_) => {}
413        Err(error)
414            if error
415                .downcast_ref::<std::io::Error>()
416                .is_some_and(|error| error.kind() == std::io::ErrorKind::NotFound) =>
417        {
418            let tasks = Queue::at(home.join("queue")).list();
419            let watches = crate::release_watch::states_for_questions(home, std::slice::from_ref(q));
420            let task_id = task_of_with_watches(q, &tasks, &watches);
421            let Some(task) = tasks.iter().find(|task| Some(&task.id) == task_id.as_ref()) else {
422                return Ok(());
423            };
424            let mut inquiry = history_record(q, Some(task));
425            inquiry.run = task.runs.contains(&q.run).then(|| q.run.clone());
426            inquiry.archived = false;
427            inquiry.display = format!("{}\n\n{}", q.summary, q.detail);
428            inquiry.text = format!(
429                "{}\n\nAn owner response was recorded. Its effect is not yet confirmed; do not replay it.",
430                inquiry.display
431            );
432            inquiry.decision = Some(crate::task_decision::Decision::awaiting(q.summary.clone()));
433            outbox.enqueue(inquiry)?;
434        }
435        Err(error) => return Err(error),
436    }
437    outbox.update_decision(&q.id, |decision| {
438        let accepted =
439            decision.accept(&format!("decision: {}", q.resolution().unwrap_or_default()))?;
440        let changed = decision.source_answer_at != q.answered_at;
441        decision.source_answer_at = q.answered_at;
442        Ok(accepted || changed)
443    })?;
444    Ok(())
445}
446
447/// Import never turns a saved reply into an executable request. Only a fresh
448/// owner answer can authorize consumption of a quarantined source reply.
449pub(crate) fn saved_reply_requires_confirmation(home: &Path, q: &Question) -> bool {
450    migrated_source(home, &q.id) && source_reply_needs_confirmation(home, q)
451}
452
453pub(crate) fn source_reply_needs_confirmation(home: &Path, q: &Question) -> bool {
454    if q.answer.is_none()
455        || (q.accepted_answer_at.is_some() && q.accepted_answer_at == q.answered_at)
456    {
457        return false;
458    }
459    let request = format!("decision: {}", q.resolution().unwrap_or_default());
460    !crate::task_inquiry::Outbox::at(home)
461        .get(&q.id)
462        .is_ok_and(|record| {
463            record.decision.as_ref().is_some_and(|decision| {
464                decision.request.as_deref() == Some(request.as_str())
465                    && decision.source_answer_at.is_some()
466                    && decision.source_answer_at == q.answered_at
467            })
468        })
469}
470
471/// A migration source which still needs operator reconciliation. Reading the
472/// pending list never acknowledges or removes these failures.
473#[derive(serde::Serialize)]
474pub struct MigrationIssue {
475    /// Exact source identity; ownership may be unknowable until it is repaired.
476    pub id: String,
477    /// Why import remains pending. No action or approval has been executed.
478    pub reason: String,
479}
480
481/// Report persistent import failures alongside readable native inquiries.
482/// Even a damaged migration journal must not hide the rest of the pending list.
483pub fn migration_issues(home: &Path) -> Vec<MigrationIssue> {
484    let read = || -> Result<Vec<MigrationIssue>> {
485        let path = home.join("notifications/task-chat-migration-v1/state.json");
486        let bytes = match std::fs::read(path) {
487            Ok(bytes) => bytes,
488            Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(vec![]),
489            Err(error) => return Err(error.into()),
490        };
491        let migration: Migration = serde_json::from_slice(&bytes)?;
492        anyhow::ensure!(migration.schema == 1, "unsupported inquiry migration");
493        Ok(migration
494            .errors
495            .into_iter()
496            .map(|(id, reason)| MigrationIssue { id, reason })
497            .collect())
498    };
499    let mut issues = read().unwrap_or_else(|error| {
500        vec![MigrationIssue {
501            id: "migration".into(),
502            reason: format!(
503                "Migration journal needs reconciliation: {error:#}. No approval was inferred."
504            ),
505        }]
506    });
507    if !issues.iter().any(|issue| issue.id == "migration") {
508        match std::fs::read_to_string(
509            home.join("notifications/task-chat-migration-v1/last-error.txt"),
510        ) {
511            Ok(reason) => issues.push(MigrationIssue {
512                id: "migration".into(),
513                reason,
514            }),
515            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
516            Err(error) => issues.push(MigrationIssue {
517                id: "migration".into(),
518                reason: format!("Migration diagnostic is unreadable: {error:#}"),
519            }),
520        }
521    }
522    issues
523}
524
525pub(crate) fn migration_pending(home: &Path) -> Result<std::collections::BTreeSet<String>> {
526    let path = home.join("notifications/task-chat-migration-v1/state.json");
527    let bytes = match std::fs::read(path) {
528        Ok(bytes) => bytes,
529        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(Default::default()),
530        Err(error) => return Err(error.into()),
531    };
532    let migration: Migration = serde_json::from_slice(&bytes)?;
533    anyhow::ensure!(migration.schema == 1, "unsupported inquiry migration");
534    Ok(migration.pending.into_iter().collect())
535}
536
537const CLASSIFICATION_REVISION: u32 = 2;
538
539fn migrate_batch(
540    queue: &Queue,
541    talks: &Talks,
542    questions: &Questions,
543    home: &Path,
544    watches: &[crate::release_watch::WatchState],
545) -> Result<()> {
546    let dir = home.join("notifications/task-chat-migration-v1");
547    std::fs::create_dir_all(&dir)?;
548    let lock = std::fs::OpenOptions::new()
549        .create(true)
550        .truncate(false)
551        .write(true)
552        .open(dir.join("migration.lock"))?;
553    if let Err(error) = crate::pr_head::try_lock_file(&lock) {
554        if error.kind() == std::io::ErrorKind::WouldBlock || error.raw_os_error() == Some(33) {
555            return Ok(());
556        }
557        return Err(error.into());
558    }
559    let path = dir.join("state.json");
560    let mut migration: Migration = if path.exists() {
561        serde_json::from_slice(&std::fs::read(&path)?)?
562    } else {
563        Migration {
564            schema: 1,
565            classification_revision: 0,
566            // list() intentionally skips unreadable records for the old UI.
567            // A finite migration boundary must include their filenames too.
568            pending: {
569                let mut ids = std::collections::BTreeSet::new();
570                match std::fs::read_dir(questions.root()) {
571                    Ok(entries) => {
572                        for entry in entries {
573                            let path = entry?.path();
574                            if path.extension().is_some_and(|ext| ext == "json") {
575                                let id = path
576                                    .file_stem()
577                                    .and_then(|name| name.to_str())
578                                    .context("saved inquiry filename is not UTF-8")?;
579                                ids.insert(id.to_owned());
580                            }
581                        }
582                    }
583                    Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
584                    Err(error) => return Err(error.into()),
585                }
586                ids.into_iter().collect()
587            },
588            sources: None,
589            errors: Default::default(),
590        }
591    };
592    let needs_boundary = migration.sources.is_none();
593    if needs_boundary {
594        let mut sources: std::collections::BTreeSet<_> =
595            migration.pending.iter().cloned().collect();
596        match std::fs::read_dir(questions.root()) {
597            Ok(entries) => {
598                for entry in entries {
599                    let path = entry?.path();
600                    if path
601                        .extension()
602                        .is_some_and(|extension| extension == "json")
603                    {
604                        let id = path
605                            .file_stem()
606                            .and_then(|stem| stem.to_str())
607                            .context("saved inquiry filename is not UTF-8")?;
608                        sources.insert(id.to_owned());
609                    }
610                }
611            }
612            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
613            Err(error) => return Err(error.into()),
614        }
615        migration.pending = sources.iter().cloned().collect();
616        migration.sources = Some(sources);
617    }
618    anyhow::ensure!(migration.schema == 1, "unsupported task inquiry migration");
619    let save = |state: &Migration| -> Result<()> {
620        let temp = path.with_extension("tmp");
621        std::fs::write(&temp, serde_json::to_vec(state)?)?;
622        std::fs::rename(temp, &path)?;
623        Ok(())
624    };
625    let needs_correction = migration.classification_revision < CLASSIFICATION_REVISION;
626    if needs_correction {
627        // Revisit exactly the saved boundary, including already imported
628        // sources. Never discover a new generation during compatibility repair.
629        let mut pending: std::collections::BTreeSet<_> =
630            migration.pending.iter().cloned().collect();
631        pending.extend(migration.sources.iter().flatten().cloned());
632        migration.pending = pending.into_iter().collect();
633        migration.classification_revision = CLASSIFICATION_REVISION;
634    }
635    // Persist the boundary before delivering anything. Receipt loss can repeat
636    // a batch, but the original inquiry/transcript keys make that repeat inert.
637    if !path.exists() || needs_boundary || needs_correction {
638        save(&migration)?;
639    }
640    if migration.pending.is_empty() {
641        return Ok(());
642    }
643    let batch: Vec<_> = migration
644        .pending
645        .drain(..migration.pending.len().min(64))
646        .collect();
647    let tasks = queue.list();
648    let ownership = InquiryOwnership::from_tasks(&tasks);
649    for id in batch {
650        let result = (|| -> Result<()> {
651            let q = retire_finished_triage(queue, questions, home, &questions.read_history(&id)?)?;
652            if standalone_inquiry_in(home, &q, &ownership) {
653                if let Some(sources) = &mut migration.sources {
654                    sources.remove(&id);
655                }
656                return Ok(());
657            }
658            if q.node == crate::bump::NOTICE_NODE && q.choices.is_empty() {
659                return Ok(());
660            }
661            let task = task_of_with_watches(&q, &tasks, watches)
662                .and_then(|id| tasks.iter().find(|task| task.id == id));
663            let outbox = crate::task_inquiry::Outbox::at(home);
664            let receipt = effect_receipt(home, queue, &q, task.map(|task| task.id.as_str()));
665            let mut record = history_record(&q, task);
666            let history = history_reason(home, &q);
667            let mut resolution = history
668                .as_ref()
669                .map(|(_, kind)| *kind)
670                .unwrap_or(HistoryResolution::Applied);
671            match (receipt, history) {
672                (Ok(Some(receipt)), _) => {
673                    resolution = HistoryResolution::Applied;
674                    let mut decision = crate::task_decision::Decision::awaiting(q.summary.clone());
675                    decision.applied(&receipt)?;
676                    record.decision = Some(decision);
677                }
678                (_, Some((reason, retire))) => {
679                    let mut decision = crate::task_decision::Decision::awaiting(q.summary.clone());
680                    if retire == HistoryResolution::Retired {
681                        decision.retire(&reason)?;
682                    } else {
683                        decision.applied(&reason)?;
684                    }
685                    record.decision = Some(decision);
686                }
687                (outcome, None) if pending_intent(home, &q, task, watches) || outcome.is_err() => {
688                    if q.status.open()
689                        && let Some(task) = task
690                    {
691                        record = live_record(home, task, &q);
692                    }
693                    record.archived = false;
694                    let mut decision = crate::task_decision::Decision::awaiting(q.summary.clone());
695                    if let Err(error) = outcome {
696                        decision
697                            .fail(&format!("Source receipt needs reconciliation: {error:#}"))?;
698                    } else if q.answer.is_some() {
699                        decision.fail("Saved reply has no confirmed effect receipt. Use reconcile-decision to check durable evidence, or settle-decision with an explicit reason. Import authorized no operation.")?;
700                    }
701                    record.decision = Some(decision);
702                    record.text.push_str("\n\nImported history authorizes no operation. Saved replies require evidence reconciliation or explicit owner settlement; never replay them.");
703                    if task.is_none() {
704                        record.delivery_error = Some("Owning task is missing or ambiguous. Restore the original ownership, or use task control settle-decision with this inquiry ID and a reason. Import executed no operation.".into());
705                    }
706                }
707                _ => {}
708            }
709            let current = questions.read_history(&id)?;
710            anyhow::ensure!(
711                (current.status, &current.answer, current.answered_at)
712                    == (q.status, &q.answer, q.answered_at),
713                "source changed while classifying saved history; retry with its current generation"
714            );
715            outbox.reclassify_history(record, resolution)?;
716            sync_effect_receipt_in(home, queue, &q, &ownership);
717            let imported = outbox.get(&q.id)?;
718            if imported.archived
719                || imported
720                    .decision
721                    .as_ref()
722                    .is_some_and(|d| d.status == crate::task_decision::Status::Resolved)
723            {
724                return Ok(());
725            }
726            // Only genuinely unanswered intent retains legacy task routing.
727            // Saved answers and their source JSON remain immutable history.
728            if q.status.open()
729                && let Some(task) = task
730            {
731                if q.routed_task.as_ref() != Some(&task.id) {
732                    questions.update_in(&q.id, &ownership, |source| {
733                        source.routed_task = Some(task.id.clone());
734                        Ok(())
735                    })?;
736                }
737                post_in(queue, talks, home, &task.id, &q, &ownership)?;
738            } else if task.is_some() {
739                // Native discussion of unknown effects is supported without
740                // reopening or rerouting the immutable answered source.
741                outbox.deliver(queue, talks, &q.id)?;
742            }
743            Ok(())
744        })();
745        if let Err(error) = result {
746            tracing::warn!("legacy inquiry {id} import: {error:#}");
747            migration.errors.insert(
748                id.clone(),
749                format!(
750                    "Saved inquiry needs reconciliation: {error:#}. Import executed no action."
751                ),
752            );
753            migration.pending.push(id);
754        } else {
755            migration.errors.remove(&id);
756        }
757    }
758    save(&migration)
759}
760
761/// Classification uses saved state only: importing never executes a reply.
762/// Retirement remains distinct from positive application evidence.
763fn history_reason(home: &Path, q: &Question) -> Option<(String, HistoryResolution)> {
764    // Every abandoned, unanswered source is history, including one forwarded to
765    // a task chat: abandonment is silence, already settled as a hold, and the
766    // owner is shown the task's own hold/block and current questions instead.
767    if q.answer.is_none() && q.status == crate::ask::QuestionStatus::Abandoned {
768        return Some(("Source abandoned: silence already settled as a hold; existing task holds and blocks are unchanged".into(), HistoryResolution::Retired));
769    }
770    q.answer.as_ref()?;
771    if q.node == crate::bump::NOTICE_NODE && q.seat == "release-watch" {
772        return crate::release_watch::retired_question(home, q)
773            .ok()
774            .filter(|retired| *retired)
775            .map(|_| {
776                (
777                    "Migration evidence: release PR watch retired after PR completion".into(),
778                    HistoryResolution::Applied,
779                )
780            });
781    }
782    if q.node != crate::land::APPROVAL_NODE && q.merge_target.is_none() {
783        return None;
784    }
785    let run = crate::run::RunState::load_under(&q.run, home).ok()?;
786    if run.status != crate::run::RunStatus::Merged
787        || !run.merge.as_ref().is_some_and(|out| {
788            out.ok
789                && !out.empty
790                && (out.mode == crate::config::MergeMode::Local
791                    || run.pr.as_ref().is_some_and(|pr| pr.state == "merged"))
792        })
793    {
794        return None;
795    }
796    if let Some(target) = &q.merge_target
797        && !run.pr.as_ref().is_some_and(|pr| {
798            pr.url == target.pr && run.pr_merged_head.as_ref() == Some(&target.head)
799        })
800    {
801        return None;
802    }
803    Some((
804        format!(
805            "Migration evidence: run {} durably records a successful merge",
806            q.run
807        ),
808        HistoryResolution::Applied,
809    ))
810}
811
812/// Task state read directly, never inferred from absence in `Queue::list()`
813/// (a listing skips unreadable records). `Missing` needs no record with the
814/// exact id and no prefix match from `resolve_id`; a prefix match, an
815/// ambiguous prefix or a damaged record is `Unknown` and keeps the question open.
816enum TaskState {
817    Done,
818    Other,
819    Missing,
820    Unknown,
821}
822
823fn task_state(queue: &Queue, id: &str) -> Result<TaskState> {
824    match std::fs::read(queue.path_of(id)) {
825        Ok(bytes) => match serde_json::from_slice::<Task>(&bytes) {
826            Ok(task) if task.id == id => Ok(if task.status == crate::queue::TaskStatus::Done {
827                TaskState::Done
828            } else {
829                TaskState::Other
830            }),
831            _ => Ok(TaskState::Unknown),
832        },
833        Err(error) if error.kind() == std::io::ErrorKind::NotFound => match queue.resolve_id(id) {
834            Err(error) if error.to_string().starts_with("no task matches") => {
835                Ok(TaskState::Missing)
836            }
837            _ => Ok(TaskState::Unknown),
838        },
839        Err(error) => Err(error.into()),
840    }
841}
842
843fn retire_finished_triage(
844    queue: &Queue,
845    questions: &Questions,
846    home: &Path,
847    q: &Question,
848) -> Result<Question> {
849    if !matches!(
850        q.node.as_str(),
851        crate::triage::NODE | crate::triage::DEPS_NODE
852    ) || !q.status.open()
853        || q.answer.is_some()
854    {
855        return Ok(q.clone());
856    }
857    // Only these producers put the exact task ID in run. Missing tasks with
858    // conflicting routing/native ownership may still matter: never guess from
859    // a filtered queue listing, a run association, or an unreadable record.
860    if !q.run_names_task()
861        || matches!(q.run.as_str(), "" | "." | "..")
862        || q.run.contains(['/', '\\'])
863        || q.routed_task.as_ref().is_some_and(|task| task != &q.run)
864    {
865        return Ok(q.clone());
866    }
867    let outbox = crate::task_inquiry::Outbox::at(home);
868    match outbox.get(&q.id) {
869        Ok(record)
870            if (!record.task.is_empty() && record.task != q.run)
871                || record
872                    .decision
873                    .as_ref()
874                    .is_some_and(|d| d.request.is_some()) =>
875        {
876            return Ok(q.clone());
877        }
878        Err(error)
879            if !error
880                .downcast_ref::<std::io::Error>()
881                .is_some_and(|e| e.kind() == std::io::ErrorKind::NotFound) =>
882        {
883            return Err(error);
884        }
885        _ => {}
886    }
887    let reason = match task_state(queue, &q.run)? {
888        TaskState::Done => format!("task {} is done; nothing left to decide", q.run),
889        TaskState::Missing => format!(
890            "task {} is no longer in the queue; nothing left to decide",
891            q.run
892        ),
893        TaskState::Other | TaskState::Unknown => return Ok(q.clone()),
894    };
895    // Retire the native inquiry first. A stop between the two writes then leaves
896    // the source open, so the next pass repeats this (idempotent) function; the
897    // reverse order would leave an unresolved inquiry behind a closed source.
898    let mut preview = q.clone();
899    preview.abandon(&reason);
900    let mut record = history_record(&preview, None);
901    let mut decision = crate::task_decision::Decision::awaiting(preview.summary.clone());
902    decision.retire(&reason)?;
903    record.decision = Some(decision);
904    outbox.reclassify_history(record, HistoryResolution::Retired)?;
905    let source = questions
906        .update(&q.id, |source| {
907            if source.status.open()
908                && source.answer.is_none()
909                && source.run == q.run
910                && source.routed_task == q.routed_task
911            {
912                source.abandon(&reason);
913            }
914            Ok(())
915        })?
916        .0;
917    Ok(source)
918}
919
920fn pending_intent(
921    home: &Path,
922    q: &Question,
923    task: Option<&Task>,
924    watches: &[crate::release_watch::WatchState],
925) -> bool {
926    if q.status.open() || (q.answer.is_some() && awaits_decision(q)) {
927        return true;
928    }
929    if watches
930        .iter()
931        .any(|watch| watch.question.as_deref() == Some(q.id.as_str()))
932    {
933        return true;
934    }
935    let Some(task) = task else {
936        return q.answer.is_none() || awaits_decision(q);
937    };
938    if task.blocked_by.contains(&q.id) {
939        return true;
940    }
941    if task.status == crate::queue::TaskStatus::Done {
942        return false;
943    }
944    if q.run != task.id && task.runs.last() != Some(&q.run) {
945        return false;
946    }
947    if q.node == crate::github_text::ASK_NODE {
948        return crate::run::RunState::load_under(&q.run, home).is_ok_and(|run| {
949            run.github_text
950                .as_ref()
951                .is_some_and(|gate| gate.question.as_ref() == Some(&q.id))
952                && (run.pr_publication_pending || run.merge.as_ref().is_none_or(|out| !out.ok))
953        });
954    }
955    awaits_decision(q) || (q.routed_chat.is_some() && q.answer.is_none())
956}
957
958fn history_record(q: &Question, task: Option<&Task>) -> crate::task_inquiry::Inquiry {
959    let saved_reply = q.answer.as_ref().map(|answer| match answer {
960        crate::ask::Answer::Choice(text) | crate::ask::Answer::Text(text) => text.as_str(),
961    });
962    let display = format!(
963        "{}\n\n{}\n\nSaved status: {}\nSaved reply (history only): {}",
964        q.summary,
965        q.detail,
966        q.status.as_str(),
967        saved_reply.unwrap_or("none")
968    );
969    crate::task_inquiry::Inquiry {
970        schema: 1,
971        id: q.id.clone(),
972        task: task.map(|task| task.id.clone()).unwrap_or_default(),
973        run: (!q.run.is_empty() && !q.run_names_task()).then(|| q.run.clone()),
974        repo: task.map(|task| task.repo.clone()).unwrap_or_default(),
975        source: format!("{}:{}:{}", q.node, q.seat, q.run),
976        occurrence: None,
977        text: display.clone(),
978        display,
979        key: format!("question:{}", q.id),
980        evidence: None,
981        created_at: q.asked_at,
982        delivered_to: None,
983        decision: None,
984        delivery_error: None,
985        archived: true,
986    }
987}
988
989/// Queue once before retiring the ordinary question. Merge records stay open
990/// as the existing land/release consent authority, including their deadlines.
991pub fn sweep(queue: &Queue, talks: &Talks, questions: &Questions, home: &Path) {
992    let tasks = queue.list();
993    let all: Vec<_> = questions
994        .list()
995        .into_iter()
996        .map(|q| {
997            retire_finished_triage(queue, questions, home, &q).unwrap_or_else(|error| {
998                tracing::warn!("triage {} retirement: {error:#}", q.id);
999                q
1000            })
1001        })
1002        .collect();
1003    let watches = crate::release_watch::states_for_questions(home, &all);
1004    let migration_error = home.join("notifications/task-chat-migration-v1/last-error.txt");
1005    if let Err(error) = migrate_batch(queue, talks, questions, home, &watches) {
1006        tracing::warn!("legacy inquiry migration remains pending: {error:#}");
1007        if let Err(save) = std::fs::write(
1008            &migration_error,
1009            format!("Migration remains pending: {error:#}. No approval was inferred."),
1010        ) {
1011            tracing::warn!("cannot persist migration failure: {save:#}");
1012        }
1013    } else if let Err(error) = std::fs::remove_file(&migration_error)
1014        && error.kind() != std::io::ErrorKind::NotFound
1015    {
1016        tracing::warn!("cannot clear migration diagnostic: {error:#}");
1017    }
1018    let deferred = migration_pending(home).unwrap_or_else(|error| {
1019        tracing::warn!("legacy delivery boundary is unreadable: {error:#}");
1020        all.iter().map(|q| q.id.clone()).collect()
1021    });
1022    let outbox = crate::task_inquiry::Outbox::at(home);
1023    let ownership = InquiryOwnership::from_tasks(&tasks);
1024    for q in &all {
1025        if deferred.contains(&q.id) {
1026            continue;
1027        }
1028        if let Ok(record) = outbox.get(&q.id) {
1029            // Completed imports and owner settlements retain their original
1030            // ownership and prose; recovery must not redeliver them.
1031            if record.archived
1032                || record.decision.as_ref().is_some_and(|decision| {
1033                    decision.status == crate::task_decision::Status::Resolved
1034                })
1035            {
1036                continue;
1037            }
1038            // Execution views quarantine imported replies. Receipt projection
1039            // needs their original payload, without making it executable.
1040            match questions.read_history(&q.id) {
1041                Ok(source) => sync_effect_receipt_in(home, queue, &source, &ownership),
1042                Err(error) => {
1043                    tracing::warn!("decision {} source history: {error:#}", q.id);
1044                    let _ = outbox.update_decision(&q.id, |d| {
1045                        d.fail(&format!("Source history needs reconciliation: {error:#}"))
1046                    });
1047                }
1048            }
1049            // Missing ownership is recoverable, but never guessed or routed
1050            // around the compatibility policy while its consumer still exists.
1051            if record.task.is_empty()
1052                && chat_routable(q)
1053                && let Some(task) = task_of_with_watches(q, &tasks, &watches)
1054            {
1055                if let Err(error) = post_in(queue, talks, home, &task, q, &ownership) {
1056                    tracing::warn!("decision {} owner recovery: {error:#}", q.id);
1057                }
1058            }
1059        }
1060    }
1061    for q in all.into_iter().filter(|q| {
1062        q.status.open()
1063            && chat_routable(q)
1064            && !standalone_inquiry_in(home, q, &ownership)
1065            && !deferred.contains(&q.id)
1066    }) {
1067        // The pre-migration scan may have projected a not-yet-imported source
1068        // as open. Recheck the native result before scheduling delivery: the
1069        // batch may just have classified it as passive completed history.
1070        if outbox.get(&q.id).is_ok_and(|record| {
1071            record.archived
1072                || record.decision.is_some_and(|decision| {
1073                    decision.status == crate::task_decision::Status::Resolved
1074                })
1075        }) {
1076            continue;
1077        }
1078        let Some(task_id) = q
1079            .routed_task
1080            .clone()
1081            .or_else(|| task_of_with_watches(&q, &tasks, &watches))
1082        else {
1083            continue;
1084        };
1085        // A delivered decision that waits for the owner is left alone: it is
1086        // rewritten only while it still lacks its task link (R2-1-1 / R2-2-1:
1087        // every poll used to lock and rewrite it).
1088        let needs_task = chat_routable(&q) && q.routed_task.as_deref() != Some(task_id.as_str());
1089        if q.routed_chat.is_some() && !needs_task {
1090            continue;
1091        }
1092        let result = (|| -> Result<()> {
1093            let q = if needs_task {
1094                questions
1095                    .update(&q.id, |r| {
1096                        if chat_routable(r) && r.routed_task.as_deref() != Some(task_id.as_str()) {
1097                            r.routed_task = Some(task_id.clone());
1098                        }
1099                        Ok(())
1100                    })?
1101                    .0
1102            } else {
1103                q.clone()
1104            };
1105            // Already queued approvals must not reopen a chat on every poll.
1106            if q.routed_chat.is_some() {
1107                return Ok(());
1108            }
1109            let chat = post_in(queue, talks, home, &task_id, &q, &ownership)?;
1110            questions.update_in(&q.id, &ownership, |r| {
1111                r.routed_chat = Some(chat.clone());
1112                if awaits_decision(r) {
1113                    // Its answer is still read by the machinery behind it; the
1114                    // consultation link keeps compatibility consumers and
1115                    // conversation context associated with the decision.
1116                    r.consult.get_or_insert_with(|| crate::ask::ChatConsult {
1117                        talk: chat.clone(),
1118                        at: jiff::Timestamp::now(),
1119                    });
1120                } else if chat_routable(r) && r.merge_target.is_none() {
1121                    r.abandon(format!("forwarded to task chat {chat}"));
1122                }
1123                Ok(())
1124            })?;
1125            Ok(())
1126        })();
1127        if let Err(e) = result {
1128            tracing::warn!("task decision {} delivery: {e:#}", q.id);
1129        }
1130    }
1131}
1132
1133/// Project only authoritative durable application evidence. Answered, delivered
1134/// and read fields are deliberately not treated as effect receipts.
1135pub(crate) fn sync_effect_receipt(home: &Path, queue: &Queue, q: &Question) {
1136    sync_effect_receipt_in(home, queue, q, &InquiryOwnership::default())
1137}
1138
1139fn sync_effect_receipt_in(home: &Path, queue: &Queue, q: &Question, ownership: &InquiryOwnership) {
1140    if q.answer.is_some()
1141        && q.accepted_answer_at.is_some()
1142        && q.accepted_answer_at == q.answered_at
1143        && let Err(error) = accept_fresh_reply(home, q, ownership)
1144    {
1145        tracing::warn!("decision {} acceptance: {error:#}", q.id);
1146        return;
1147    }
1148    let outbox = crate::task_inquiry::Outbox::at(home);
1149    let Ok(record) = outbox.get(&q.id) else {
1150        return;
1151    };
1152    let Some(decision) = record.decision else {
1153        return;
1154    };
1155    if decision.status == crate::task_decision::Status::Resolved {
1156        return;
1157    }
1158    let result = match effect_receipt(home, queue, q, Some(&record.task)) {
1159        Ok(Some(receipt)) => outbox.update_decision(&q.id, |d| d.applied(&receipt)),
1160        Ok(None) if q.answer.is_some() && decision.request.is_none() => outbox.update_decision(&q.id, |d| d.fail("Saved reply has no confirmed effect receipt. Inspect its outcome; migration did not replay the reply. Discussion without a queued effect can be explicitly settled.")),
1161        Ok(None) => Ok(()),
1162        Err(error) => outbox.update_decision(&q.id, |d| d.fail(&format!("Source receipt needs reconciliation: {error:#}"))),
1163    };
1164    if let Err(error) = result {
1165        tracing::warn!("decision {} projection: {error:#}", q.id);
1166    }
1167}
1168
1169pub(crate) fn effect_receipt(
1170    home: &Path,
1171    queue: &Queue,
1172    q: &Question,
1173    task: Option<&str>,
1174) -> Result<Option<String>> {
1175    if let Some(task) = task.and_then(|id| queue.get(id).ok())
1176        && crate::repair_budget::reconcile::superseded_question(&task, q)
1177    {
1178        return Ok(Some(format!(
1179            "task {}: unanswered dependency question {} superseded by explicit repair receipt reconciliation; no generic resume applied",
1180            task.id, q.id
1181        )));
1182    }
1183    if q.resolution().is_none() {
1184        return Ok(None);
1185    }
1186
1187    if q.node == crate::land::APPROVAL_NODE
1188        && q.resolution().as_deref() == Some(crate::land::REPAIR)
1189    {
1190        let run = crate::run::RunState::load_under(&q.run, home)?;
1191        let Some(repair) = run.merge_repairs.iter().find(|r| r.question == q.id) else {
1192            return Ok(None);
1193        };
1194        anyhow::ensure!(
1195            q.merge_target
1196                .as_ref()
1197                .is_none_or(|target| { target.pr == repair.pr && target.head == repair.head }),
1198            "repair receipt targets a different PR or head"
1199        );
1200        return match repair.phase {
1201            crate::run::MergeRepairPhase::Complete => Ok(Some(format!(
1202                "run {}: repair and re-review {} completed for {} at {}",
1203                q.run, q.id, repair.pr, repair.head
1204            ))),
1205            crate::run::MergeRepairPhase::Failed => anyhow::bail!(
1206                "repair {} failed: {}",
1207                q.id,
1208                repair
1209                    .failure
1210                    .as_deref()
1211                    .unwrap_or("inspect the run's repair evidence before retrying")
1212            ),
1213            // A Resume pass is only transport; even a finished fixer still
1214            // owes the requested fresh review and gate.
1215            _ => Ok(None),
1216        };
1217    }
1218
1219    if q.node == crate::land::APPROVAL_NODE
1220        && q.resolution().as_deref() == Some(crate::merge_decision::WITHDRAW)
1221    {
1222        let run = crate::run::RunState::load_under(&q.run, home)?;
1223        if let Some(receipt) = &run.merge_decision
1224            && receipt.question == q.id
1225            && receipt.choice == crate::merge_decision::WITHDRAW
1226            && receipt.closed
1227            && run.status == crate::run::RunStatus::Superseded
1228            && run.pr.as_ref().is_some_and(|pr| {
1229                pr.url == receipt.target.pr && pr.state.eq_ignore_ascii_case("closed")
1230            })
1231            && q.merge_target
1232                .as_ref()
1233                .is_none_or(|target| target == &receipt.target)
1234        {
1235            return Ok(Some(format!(
1236                "run {}: withdrawal {} confirmed PR closure and retired execution",
1237                q.run, q.id
1238            )));
1239        }
1240        // Resume is only this legacy choice's transport. Its execution-start
1241        // marker cannot confirm closure or complete a withdrawal decision.
1242        return Ok(None);
1243    }
1244
1245    if crate::release_watch::quiet_effect_applied(home, q)? {
1246        return Ok(Some(format!(
1247            "release watch {}: owner choice applied",
1248            q.id
1249        )));
1250    }
1251    if matches!(
1252        q.node.as_str(),
1253        crate::triage::NODE | crate::triage::DEPS_NODE
1254    ) && let Some(id) = task
1255        .filter(|id| !id.is_empty())
1256        .or_else(|| (!q.run.is_empty()).then_some(q.run.as_str()))
1257        && queue.triage_discard_applied(id, &q.id)?
1258    {
1259        return Ok(Some(format!(
1260            "task {id}: triage discard {} committed",
1261            q.id
1262        )));
1263    }
1264
1265    let task = task
1266        .filter(|id| !id.is_empty())
1267        .map(|id| queue.get(id))
1268        .transpose()?;
1269    if q.node == crate::land::APPROVAL_NODE
1270        && let Some(choice) = q.resolution()
1271        && (choice.eq_ignore_ascii_case(crate::land::HOLD)
1272            || crate::merge_decision::selected_agent(&choice).is_some())
1273    {
1274        // New holds carry a receipt in the same task write as the effect,
1275        // independent even of reopening the old run's landing checkpoint.
1276        if choice.eq_ignore_ascii_case(crate::land::HOLD)
1277            && let Some(task) = &task
1278            && task.decision_effects.get(&q.id) == Some(&format!("decision: {choice}"))
1279        {
1280            return Ok(Some(format!(
1281                "task {}: landing hold {} committed",
1282                task.id, q.id
1283            )));
1284        }
1285        let run = crate::run::RunState::load_under(&q.run, home)?;
1286        let Some(receipt) = run.merge_decision.as_ref().filter(|receipt| {
1287            receipt.question == q.id
1288                && receipt.choice == choice
1289                && q.merge_target
1290                    .as_ref()
1291                    .is_none_or(|target| target == &receipt.target)
1292        }) else {
1293            return Ok(None);
1294        };
1295        if choice.eq_ignore_ascii_case(crate::land::HOLD) {
1296            return Ok(task
1297                .filter(|task| task.action_applied(&q.id))
1298                .map(|task| format!("task {}: landing hold {} committed", task.id, q.id)));
1299        }
1300        // Resume only transports a replacement request to the old driver.
1301        // Neither that pass nor a queued replacement proves dispatch occurred.
1302        if receipt.closed
1303            && run.status == crate::run::RunStatus::Superseded
1304            && run.pr.as_ref().is_some_and(|pr| {
1305                pr.url == receipt.target.pr && pr.state.eq_ignore_ascii_case("closed")
1306            })
1307            && let Some(next) = &receipt.replacement_run
1308            && let Some(task) = &task
1309            && task.runs.contains(next)
1310        {
1311            let replacement = crate::run::RunState::load_under(next, home)?;
1312            if replacement.repo == task.repo
1313                && replacement.replaces.as_ref().is_some_and(|r| {
1314                    r.question == q.id
1315                        && r.run == q.run
1316                        && r.pr == receipt.target.pr
1317                        && Some(r.agent.as_str()) == crate::merge_decision::selected_agent(&choice)
1318                })
1319                && replacement.passes.iter().any(|pass| pass.task_entry)
1320            {
1321                return Ok(Some(format!(
1322                    "run {}: PR closure confirmed; replacement {next} started for {}",
1323                    q.run, q.id
1324                )));
1325            }
1326        }
1327        return Ok(None);
1328    }
1329    if matches!(
1330        q.chosen_action(),
1331        Some(crate::ask::ChoiceAction::RecoverBase { .. })
1332    ) {
1333        return crate::base_recovery_control::effect_receipt(
1334            home,
1335            task.as_ref()
1336                .context("base recovery decision has no owning task")?,
1337            q,
1338        );
1339    }
1340    if let Some(action) = q.chosen_action().filter(|a| a.maintenance()) {
1341        let path = home.join("choice-actions").join(format!("{}.json", q.id));
1342        let bytes = match std::fs::read(path) {
1343            Ok(bytes) => bytes,
1344            Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
1345            Err(error) => return Err(error.into()),
1346        };
1347        let value: serde_json::Value = serde_json::from_slice(&bytes)?;
1348        anyhow::ensure!(
1349            value["action"] == serde_json::to_value(action)?,
1350            "maintenance receipt targets a different action"
1351        );
1352        anyhow::ensure!(
1353            value["status"] == "applied",
1354            "maintenance outcome is not confirmed: {}",
1355            value["status"]
1356        );
1357        return Ok(Some(format!("choice-actions/{}.json: applied", q.id)));
1358    }
1359    if q.node == crate::triage::NODE || q.node == crate::triage::DEPS_NODE {
1360        if let Some(task) = &task
1361            && let Some(evidence) = task.decision_effects.get(&q.id)
1362        {
1363            if evidence.starts_with("repair-receipt-blocked:") {
1364                anyhow::ensure!(
1365                    evidence == &crate::repair_budget::reconcile::blocked_resume(q)?,
1366                    "blocked resume source changed"
1367                );
1368                return Ok(Some(format!(
1369                    "task {}: generic resume {} consumed without release; retained repair receipt requires explicit reconcile-repair-grant",
1370                    task.id, q.id
1371                )));
1372            }
1373            let (source, _, _, application): (
1374                String,
1375                Option<jiff::Timestamp>,
1376                String,
1377                crate::queue::Resumption,
1378            ) = serde_json::from_str(evidence)
1379                .context("triage application receipt is unreadable")?;
1380            anyhow::ensure!(
1381                source == crate::repair_budget::reconcile::source(q)?
1382                    && task
1383                        .resumption
1384                        .iter()
1385                        .chain(&task.resumption_history)
1386                        .any(|r| crate::repair_budget::reconcile::application_identity(r)
1387                            == application),
1388                "triage source or application evidence changed"
1389            );
1390        }
1391        return Ok(task.filter(|task| task.triage_applied(&q.id)).map(|_| {
1392            format!(
1393                "task triage {} settled by durable application/supersession evidence",
1394                q.id
1395            )
1396        }));
1397    }
1398    if let Some(task) = &task
1399        && task.action_applied(&q.id)
1400    {
1401        if matches!(
1402            q.chosen_action(),
1403            Some(
1404                crate::ask::ChoiceAction::Done
1405                    | crate::ask::ChoiceAction::Hold
1406                    | crate::ask::ChoiceAction::Requeue
1407            )
1408        ) && task.decision_effects.get(&q.id)
1409            == Some(&format!(
1410                "decision: {}",
1411                q.resolution().expect("answered action")
1412            ))
1413        {
1414            return Ok(Some(format!(
1415                "task {}: exact choice effect {} committed",
1416                task.id, q.id
1417            )));
1418        }
1419        let applied = match q.chosen_action() {
1420            Some(crate::ask::ChoiceAction::Resume { run }) => {
1421                crate::chat_control::resume_started(home, task, &q.id, run)?
1422            }
1423            Some(crate::ask::ChoiceAction::Done) => task.status == crate::queue::TaskStatus::Done,
1424            Some(crate::ask::ChoiceAction::Hold) => {
1425                task.status == crate::queue::TaskStatus::Held
1426                    && task.hold_reason.as_ref() == Some(&q.summary)
1427            }
1428            Some(crate::ask::ChoiceAction::Requeue) => task.fresh_start,
1429            _ => false,
1430        };
1431        if applied {
1432            return Ok(Some(format!(
1433                "task {}: intended effect {} confirmed",
1434                task.id, q.id
1435            )));
1436        }
1437    }
1438    if q.node == crate::github_text::ASK_NODE {
1439        let run = crate::run::RunState::load_under(&q.run, home)?;
1440        if let Some(gate) = &run.github_text
1441            && let Some(next) = &gate.question
1442            && next != &q.id
1443            && crate::ask::Questions::at(home.join("questions"))
1444                .get(next)
1445                .is_ok_and(|successor| {
1446                    successor.run == q.run
1447                        && successor.node == q.node
1448                        && successor.asked_at >= q.asked_at
1449                })
1450        {
1451            return Ok(Some(format!(
1452                "publication inquiry {} explicitly superseded by active source gate {next}; original reply will not be consumed",
1453                q.id
1454            )));
1455        }
1456        if let Some(gate) = &run.github_text
1457            && let Some(receipt) = &gate.publication
1458        {
1459            let expected = match crate::github_text::read_reply(q) {
1460                crate::github_text::Reply::Original => crate::run::GithubTextChoice::Original,
1461                crate::github_text::Reply::Rewrite => crate::run::GithubTextChoice::Rewrite,
1462                crate::github_text::Reply::Title(_) => crate::run::GithubTextChoice::MyTitle,
1463                crate::github_text::Reply::Fallback => crate::run::GithubTextChoice::Fallback,
1464            };
1465            if q.resolution().is_some()
1466                && receipt.inquiry == q.id
1467                && receipt.fingerprint == gate.fingerprint
1468            {
1469                anyhow::ensure!(
1470                    receipt.choice == expected,
1471                    "publication applied a different payload than the saved reply"
1472                );
1473                return Ok(Some(format!(
1474                    "publication {} for {}: {:?} applied",
1475                    receipt.url, q.id, receipt.choice
1476                )));
1477            }
1478        }
1479    }
1480    if q.node == crate::land::APPROVAL_NODE
1481        && q.resolution().as_deref() == Some(crate::merge_decision::DISMISS)
1482    {
1483        // The durable run stop is the dismissal receipt. Done tasks and
1484        // later attempts deliberately retain their existing task outcome.
1485        let run = crate::run::RunState::load_under(&q.run, home)?;
1486        let stopped = run
1487            .merge_decision
1488            .as_ref()
1489            .is_some_and(|d| d.question == q.id && d.choice == crate::merge_decision::DISMISS);
1490        // A still-active latest owner needs its queue transition too. A
1491        // crash after saving the stop but before that write is not completion.
1492        let settled = queue.list().iter().all(|task| {
1493            task.runs.last() != Some(&q.run)
1494                || task.status == crate::queue::TaskStatus::Done
1495                || task.action_applied(&q.id)
1496        });
1497        if stopped && settled {
1498            return Ok(Some(format!(
1499                "run {}: obsolete approval {} dismissed; PR unchanged",
1500                q.run, q.id
1501            )));
1502        }
1503    }
1504    if q.node == crate::land::APPROVAL_NODE
1505        && let Some(target) = &q.merge_target
1506        && q.resolution().as_deref() == Some(crate::land::APPROVE)
1507    {
1508        let run = crate::run::RunState::load_under(&q.run, home)?;
1509        if run.pr_merged_head.as_deref() == Some(target.head.as_str())
1510            && run
1511                .pr
1512                .as_ref()
1513                .is_some_and(|pr| pr.url == target.pr && pr.state.eq_ignore_ascii_case("merged"))
1514        {
1515            return Ok(Some(format!(
1516                "run {}: merged {} at {}",
1517                q.run, target.pr, target.head
1518            )));
1519        }
1520    }
1521    Ok(None)
1522}
1523
1524/// Buttons are offered by a real persona reply after the persisted delivery.
1525/// Generated reports and owner free text can never offer approval themselves.
1526pub fn approval_offered(talk: &talk::Talk, q: &Question) -> bool {
1527    talk.status.open()
1528        && q.status.open()
1529        && q.merge_target.is_some()
1530        && q.routed_chat.as_deref() == Some(talk.id.as_str())
1531        && talk.notified.contains(&format!("question:{}", q.id))
1532        && talk.turns.iter().any(|turn| {
1533            talk::sender(turn, None) == talk::Sender::Persona && turn.body.contains(&q.id)
1534        })
1535}
1536
1537fn task_of_with_watches(
1538    q: &Question,
1539    tasks: &[Task],
1540    watches: &[crate::release_watch::WatchState],
1541) -> Option<String> {
1542    let mut ids = std::collections::BTreeSet::new();
1543    if let Some(id) = task_of(q, tasks) {
1544        ids.insert(id);
1545    }
1546    for reference in crate::consult::question_task_refs(q, watches) {
1547        for task in tasks.iter().filter(|t| match reference {
1548            crate::consult::QuestionTaskRef::Task(id) => t.id == id,
1549            crate::consult::QuestionTaskRef::Run(id) => t.runs.iter().any(|r| r == id),
1550        }) {
1551            ids.insert(task.id.clone());
1552        }
1553    }
1554    if ids.len() == 1 {
1555        ids.pop_first()
1556    } else {
1557        None
1558    }
1559}
1560
1561#[cfg(test)]
1562mod tests {
1563    use super::*;
1564    use crate::ask::{Answer, QuestionStatus};
1565
1566    #[tokio::test]
1567    async fn release_2029_stays_answered_across_partial_import_and_restart() {
1568        use crate::{task_decision::Status, task_inquiry::Outbox};
1569        let home = tempfile::tempdir().unwrap();
1570        let home = home.path();
1571        let questions = Questions::at(home.join("questions"));
1572        let queue = Queue::at(home.join("queue"));
1573        let talks = Talks::at(home.join("talks"));
1574        let outbox = Outbox::at(home);
1575        let mut saved = Vec::new();
1576        for index in 0..66 {
1577            let mut q = Question::new(
1578                String::new(),
1579                crate::bump::NOTICE_NODE.into(),
1580                "release-watch".into(),
1581                "Release approval".into(),
1582                "Saved reviewed head".into(),
1583                vec!["merge".into(), "hold".into()],
1584            );
1585            q.id = format!(
1586                "20261109-014940-871849981cd969b1-0000000000000000-{}",
1587                1964 + index
1588            );
1589            q.merge_target = Some(crate::merge_decision::Target {
1590                pr: "https://example.test/mebae/pull/100".into(),
1591                head: "4d5a46f99a678608d2b883498d8bebd9399c0261".into(),
1592                language: "en".into(),
1593            });
1594            q.answer(Answer::Choice(
1595                if index == 0 { "hold" } else { "merge" }.into(),
1596            ))
1597            .unwrap();
1598            q.answered_at = Some("2026-11-08T17:03:30.66862Z".parse().unwrap());
1599            q.answer_delivered = true;
1600            questions.put(&mut q).unwrap();
1601            saved.push(q);
1602        }
1603        // A real effect receipt is different from answer delivery or missing ownership.
1604        let receipts = home.join("release-watch-receipts");
1605        std::fs::create_dir_all(&receipts).unwrap();
1606        let receipt = crate::release_watch::WatchState {
1607            applied: vec![saved[0].id.clone()],
1608            ..Default::default()
1609        };
1610        std::fs::write(
1611            receipts.join(format!("{}.json", saved[0].id)),
1612            serde_json::to_vec(&receipt).unwrap(),
1613        )
1614        .unwrap();
1615        // Simulate a partially completed v1 import, including a mistaken passive
1616        // classification that is no longer in pending.
1617        outbox.enqueue(history_record(&saved[1], None)).unwrap();
1618        let dir = home.join("notifications/task-chat-migration-v1");
1619        std::fs::create_dir_all(&dir).unwrap();
1620        std::fs::write(
1621            dir.join("state.json"),
1622            serde_json::to_vec(&serde_json::json!({
1623                "schema": 1, "sources": saved.iter().map(|q| &q.id).collect::<Vec<_>>(),
1624                "pending": saved[64..].iter().map(|q| &q.id).collect::<Vec<_>>()
1625            }))
1626            .unwrap(),
1627        )
1628        .unwrap();
1629        let source = &saved[65];
1630        assert!(source.id.ends_with("2029"));
1631        let bytes = std::fs::read(questions.path_of(&source.id)).unwrap();
1632        let assert_history = || {
1633            let read = questions.get(&source.id).unwrap();
1634            assert_eq!(read.status, QuestionStatus::Answered);
1635            assert_eq!(read.resolution().as_deref(), Some("merge"));
1636            assert_eq!(read.answered_at, source.answered_at);
1637            assert_eq!(
1638                questions.list().iter().filter(|q| q.status.open()).count(),
1639                0
1640            );
1641            assert!(
1642                questions
1643                    .get_for_effects(&source.id)
1644                    .unwrap()
1645                    .resolution()
1646                    .is_none()
1647            );
1648            assert!(
1649                questions
1650                    .update(&source.id, |q| q.answer(Answer::Choice("merge".into())))
1651                    .is_err()
1652            );
1653            let mut operational = questions.get_for_effects(&source.id).unwrap();
1654            operational.abandon("old deadline");
1655            assert!(
1656                questions.put(&mut operational).is_err(),
1657                "quarantine must not activate a default on timeout"
1658            );
1659            assert_eq!(std::fs::read(questions.path_of(&source.id)).unwrap(), bytes);
1660        };
1661        assert_history();
1662        assert_eq!(
1663            questions
1664                .abandon_for_run("", "retired source owner")
1665                .unwrap(),
1666            0
1667        );
1668        assert_history();
1669        let mut waiting = source.clone();
1670        assert!(matches!(
1671            crate::ask::resume_wait(&mut waiting, &questions, std::time::Duration::ZERO)
1672                .await
1673                .unwrap(),
1674            crate::ask::Wait::Pending
1675        ));
1676        assert_history();
1677        sweep(&queue, &talks, &questions, home);
1678        assert_history();
1679        assert_eq!(migration_pending(home).unwrap().len(), 2);
1680        assert!(
1681            outbox.get(&source.id).is_err(),
1682            "2029 is beyond the first batch"
1683        );
1684        assert_eq!(
1685            outbox.get(&saved[0].id).unwrap().decision.unwrap().status,
1686            Status::Resolved
1687        );
1688        let repaired = outbox.get(&saved[1].id).unwrap();
1689        assert!(!repaired.archived);
1690        assert_eq!(repaired.decision.unwrap().status, Status::RetryNeeded);
1691        // Reopening all stores exercises the persisted correction cursor.
1692        for _ in 0..2 {
1693            sweep(
1694                &Queue::at(home.join("queue")),
1695                &Talks::at(home.join("talks")),
1696                &Questions::at(home.join("questions")),
1697                home,
1698            );
1699            assert_history();
1700        }
1701        assert!(migration_pending(home).unwrap().is_empty());
1702        let imported = outbox.get(&source.id).unwrap();
1703        assert!(!imported.archived);
1704        assert!(imported.task.is_empty());
1705        assert!(
1706            imported
1707                .delivery_error
1708                .unwrap()
1709                .contains("missing or ambiguous")
1710        );
1711        let decision = imported.decision.unwrap();
1712        assert_eq!(decision.status, Status::RetryNeeded);
1713        assert!(decision.request.is_none());
1714        assert!(decision.source_answer_at.is_none());
1715        assert!(queue.list().is_empty());
1716        assert!(talks.list().is_empty());
1717        let mut later = saved[1].clone();
1718        later.id = "outside-boundary".into();
1719        questions.put(&mut later).unwrap();
1720        sweep(&queue, &talks, &questions, home);
1721        assert!(
1722            outbox.get(&later.id).is_err(),
1723            "correction must not expand its boundary"
1724        );
1725    }
1726
1727    #[test]
1728    fn migration_revision_retires_proven_and_abandoned_history() {
1729        use crate::{
1730            ask::Answer,
1731            queue::{Source, TaskStatus},
1732            run::{MergeOutcome, RunState, RunStatus},
1733            task_decision::{Decision, Status},
1734            task_inquiry::Outbox,
1735        };
1736        let temp = tempfile::tempdir().unwrap();
1737        let home = temp.path();
1738        let queue = Queue::at(home.join("queue"));
1739        let questions = Questions::at(home.join("questions"));
1740        let talks = Talks::at(home.join("talks"));
1741        let outbox = Outbox::at(home);
1742        let mut run = RunState::new(
1743            home.into(),
1744            "main".into(),
1745            "base".into(),
1746            "work".into(),
1747            Config::default(),
1748        );
1749        run.reserve_under(home).unwrap();
1750        run.status = RunStatus::Merged;
1751        run.merge = Some(MergeOutcome {
1752            mode: crate::config::MergeMode::Local,
1753            ok: true,
1754            empty: false,
1755            detail: String::new(),
1756        });
1757        run.save_under(home).unwrap();
1758        let mut task = Task::new("work".into(), "work".into(), home.into(), Source::Human);
1759        task.status = TaskStatus::Done;
1760        task.runs.push(run.id.clone());
1761        queue.put(&mut task).unwrap();
1762        let mut sources = Vec::new();
1763        for (node, run_id, answered) in [
1764            (crate::land::APPROVAL_NODE, run.id.as_str(), true),
1765            (crate::land::APPROVAL_NODE, "unproven", true),
1766            (crate::conduct::NODE, task.id.as_str(), false),
1767            (crate::triage::NODE, task.id.as_str(), false),
1768        ] {
1769            let mut q = Question::new(
1770                run_id.into(),
1771                node.into(),
1772                "seat".into(),
1773                "Decision".into(),
1774                String::new(),
1775                vec!["yes".into()],
1776            );
1777            if answered {
1778                q.answer(Answer::Choice("yes".into())).unwrap();
1779            } else if node == crate::conduct::NODE {
1780                q.abandon("expired; held");
1781            }
1782            questions.put(&mut q).unwrap();
1783            sources.push(q);
1784        }
1785        // Revision 1 already imported these as unresolved decisions.
1786        for q in &sources {
1787            let mut record = history_record(q, None);
1788            record.archived = false;
1789            let mut decision = Decision::awaiting(q.summary.clone());
1790            decision
1791                .fail("Saved reply has no confirmed effect receipt")
1792                .unwrap();
1793            record.decision = Some(decision);
1794            outbox.enqueue(record).unwrap();
1795        }
1796        // A settled import must remain byte-for-byte equivalent after repair.
1797        let mut settled = sources[0].clone();
1798        settled.id = "settled-history".into();
1799        questions.put(&mut settled).unwrap();
1800        let mut record = history_record(&settled, None);
1801        let mut decision = Decision::awaiting(settled.summary.clone());
1802        decision.settle("owner settled after inspection").unwrap();
1803        record.decision = Some(decision);
1804        record.archived = false;
1805        outbox.enqueue(record).unwrap();
1806        let settled_before = outbox.get(&settled.id).unwrap();
1807        sources.push(settled);
1808        let dir = home.join("notifications/task-chat-migration-v1");
1809        std::fs::create_dir_all(&dir).unwrap();
1810        std::fs::write(
1811            dir.join("state.json"),
1812            serde_json::to_vec(&serde_json::json!({
1813                "schema": 1, "classification_revision": 1, "pending": [],
1814                "sources": sources.iter().map(|q| &q.id).collect::<Vec<_>>()
1815            }))
1816            .unwrap(),
1817        )
1818        .unwrap();
1819        for _ in 0..2 {
1820            sweep(&queue, &talks, &questions, home);
1821        }
1822        for index in [0, 2, 3] {
1823            let record = outbox.get(&sources[index].id).unwrap();
1824            assert!(record.archived);
1825            let decision = record.decision.unwrap();
1826            assert_eq!(decision.status, Status::Resolved);
1827            assert!(decision.error.is_none());
1828            assert!(!decision.legacy_settled);
1829        }
1830        assert_eq!(
1831            outbox.get(&sources[1].id).unwrap().decision.unwrap().status,
1832            Status::RetryNeeded
1833        );
1834        let triage = questions.read_history(&sources[3].id).unwrap();
1835        assert_eq!(triage.status, crate::ask::QuestionStatus::Abandoned);
1836        assert!(triage.detail.contains("nothing left to decide"));
1837        assert_eq!(outbox.get(&sources[4].id).unwrap(), settled_before);
1838        // Done by itself is not proof that an answered merge decision applied.
1839        run.merge.as_mut().unwrap().empty = true;
1840        run.save_under(home).unwrap();
1841        assert!(history_reason(home, &sources[0]).is_none());
1842        run.merge.as_mut().unwrap().empty = false;
1843        run.merge.as_mut().unwrap().mode = crate::config::MergeMode::Pr;
1844        run.pr = Some(crate::run::PrRecord {
1845            url: "https://example.test/project/repo/pull/1".into(),
1846            number: 1,
1847            state: "open".into(),
1848            checks: "green".into(),
1849            round: 1,
1850            rounds: 1,
1851            red_at_merge: vec![],
1852        });
1853        run.save_under(home).unwrap();
1854        assert!(
1855            history_reason(home, &sources[0]).is_none(),
1856            "publication alone is insufficient"
1857        );
1858        run.pr.as_mut().unwrap().state = "merged".into();
1859        run.pr_merged_head = Some("merged-head".into());
1860        run.save_under(home).unwrap();
1861        let mut bound = sources[0].clone();
1862        bound.merge_target = Some(crate::merge_decision::Target {
1863            pr: run.pr.as_ref().unwrap().url.clone(),
1864            head: "merged-head".into(),
1865            language: "en".into(),
1866        });
1867        assert!(history_reason(home, &bound).is_some());
1868        bound.merge_target.as_mut().unwrap().head = "other-head".into();
1869        assert!(history_reason(home, &bound).is_none());
1870    }
1871
1872    #[test]
1873    fn triage_retirement_preserves_ambiguous_ownership_and_forwarded_discussion() {
1874        let temp = tempfile::tempdir().unwrap();
1875        let home = temp.path();
1876        let queue = Queue::at(home.join("queue"));
1877        let questions = Questions::at(home.join("questions"));
1878        let mut q = Question::new(
1879            "missing-task".into(),
1880            crate::triage::NODE.into(),
1881            "triage".into(),
1882            "Decide".into(),
1883            String::new(),
1884            vec![],
1885        );
1886        q.routed_task = Some("another-task".into());
1887        questions.put(&mut q).unwrap();
1888        assert!(
1889            retire_finished_triage(&queue, &questions, home, &q)
1890                .unwrap()
1891                .status
1892                .open()
1893        );
1894        q = questions
1895            .update(&q.id, |q| {
1896                q.routed_task = None;
1897                Ok(())
1898            })
1899            .unwrap()
1900            .0;
1901        assert_eq!(
1902            retire_finished_triage(&queue, &questions, home, &q)
1903                .unwrap()
1904                .status,
1905            crate::ask::QuestionStatus::Abandoned
1906        );
1907        // An id that is only a prefix of an existing task is not "missing".
1908        assert!(matches!(
1909            task_state(&queue, "abc").unwrap(),
1910            TaskState::Missing
1911        ));
1912        std::fs::create_dir_all(home.join("queue")).unwrap();
1913        std::fs::write(home.join("queue").join("abcdef.json"), "{}").unwrap();
1914        assert!(matches!(
1915            task_state(&queue, "abc").unwrap(),
1916            TaskState::Unknown
1917        ));
1918        let mut forwarded = Question::new(
1919            "task".into(),
1920            "implement".into(),
1921            "seat".into(),
1922            "Discuss".into(),
1923            String::new(),
1924            vec![],
1925        );
1926        forwarded.routed_chat = Some("chat".into());
1927        forwarded.abandon("forwarded to task chat");
1928        assert!(history_reason(home, &forwarded).is_some());
1929    }
1930
1931    #[test]
1932    fn release_watch_history_requires_readable_existing_store() {
1933        use crate::ask::Answer;
1934        let temp = tempfile::tempdir().unwrap();
1935        let home = temp.path();
1936        let mut q = Question::new(
1937            "run".into(),
1938            crate::bump::NOTICE_NODE.into(),
1939            "release-watch".into(),
1940            "Release".into(),
1941            String::new(),
1942            vec!["merge".into()],
1943        );
1944        q.merge_target = Some(crate::merge_decision::Target {
1945            pr: "https://example.test/project/repo/pull/1".into(),
1946            head: "head".into(),
1947            language: "en".into(),
1948        });
1949        q.answer(Answer::Choice("merge".into())).unwrap();
1950        assert!(history_reason(home, &q).is_none());
1951        let dir = home.join("release-watch");
1952        std::fs::create_dir(&dir).unwrap();
1953        assert!(history_reason(home, &q).is_some());
1954        let active = dir.join(format!("{}.json", crate::notices::id_of("project/repo#1")));
1955        // Use the same owner/repository key as the watcher, rather than the URL.
1956        std::fs::write(&active, b"{}").unwrap();
1957        assert!(history_reason(home, &q).is_none());
1958        std::fs::remove_file(active).unwrap();
1959        std::fs::write(dir.join("broken.json"), "invalid").unwrap();
1960        assert!(history_reason(home, &q).is_none());
1961        std::fs::write(
1962            dir.join("broken.json"),
1963            serde_json::to_vec(&crate::release_watch::WatchState {
1964                question: Some(q.id.clone()),
1965                ..Default::default()
1966            })
1967            .unwrap(),
1968        )
1969        .unwrap();
1970        assert!(history_reason(home, &q).is_none());
1971    }
1972
1973    #[test]
1974    fn history_correction_preserves_accepted_and_completed_decisions() {
1975        let home = tempfile::tempdir().unwrap();
1976        let outbox = crate::task_inquiry::Outbox::at(home.path());
1977        for completed in [false, true] {
1978            let q = Question::new(
1979                String::new(),
1980                crate::bump::NOTICE_NODE.into(),
1981                "release-watch".into(),
1982                "Saved release".into(),
1983                String::new(),
1984                vec!["hold".into()],
1985            );
1986            let mut record = history_record(&q, None);
1987            record.archived = false;
1988            record.decision = Some(crate::task_decision::Decision::awaiting(q.summary.clone()));
1989            outbox.enqueue(record).unwrap();
1990            outbox
1991                .update_decision(&q.id, |d| {
1992                    if completed {
1993                        d.applied("explicit durable effect receipt")
1994                    } else {
1995                        d.accept("decision: hold")
1996                    }
1997                })
1998                .unwrap();
1999            let before = outbox.get(&q.id).unwrap();
2000            outbox
2001                .reclassify_history(history_record(&q, None), HistoryResolution::Retired)
2002                .unwrap();
2003            assert_eq!(outbox.get(&q.id).unwrap(), before);
2004        }
2005    }
2006
2007    #[test]
2008    fn routed_merge_accepts_direct_answers_and_checks_optional_button_binding() {
2009        let mut q = Question::new(
2010            "run".into(),
2011            crate::land::APPROVAL_NODE.into(),
2012            "land".into(),
2013            "Merge?".into(),
2014            String::new(),
2015            vec!["merge".into(), "hold".into()],
2016        );
2017        q.routed_task = Some("task".into());
2018        q.routed_chat = Some("chat".into());
2019        q.merge_target = Some(crate::merge_decision::Target {
2020            pr: "https://example.test/pull/1".into(),
2021            head: "head-a".into(),
2022            language: "en".into(),
2023        });
2024        assert!(q.clone().answer(Answer::Choice("merge".into())).is_ok());
2025        assert!(
2026            q.settle_by_deputy("seat", "merge", None).is_err(),
2027            "a routed decision is the task chat's, never a deputy's"
2028        );
2029        assert!(
2030            q.answer_chat_button(Answer::Choice("merge".into()), "other-chat", "head-a")
2031                .is_err()
2032        );
2033        assert!(
2034            q.answer_chat_button(Answer::Choice("merge".into()), "chat", "old-head")
2035                .is_err()
2036        );
2037        assert!(
2038            q.answer_chat_button(Answer::Text("merge".into()), "chat", "head-a")
2039                .is_err()
2040        );
2041        assert_eq!(q.status, QuestionStatus::Open);
2042        q.answer_chat_button(Answer::Choice("merge".into()), "chat", "head-a")
2043            .unwrap();
2044        assert_eq!(q.resolution().as_deref(), Some("merge"));
2045        assert!(
2046            q.answer_chat_button(Answer::Choice("merge".into()), "chat", "head-a")
2047                .is_err()
2048        );
2049    }
2050
2051    #[test]
2052    fn gate_divergence_and_release_questions_route_and_await_a_decision() {
2053        let q = |node: &str, seat: &str, choices: Vec<String>| {
2054            Question::new(
2055                "run".into(),
2056                node.into(),
2057                seat.into(),
2058                "s".into(),
2059                String::new(),
2060                choices,
2061            )
2062        };
2063        let gate = q(
2064            crate::github_text::ASK_NODE,
2065            "posting-gate",
2066            vec!["use fallback".into()],
2067        );
2068        assert!(chat_routable(&gate) && awaits_decision(&gate));
2069        // Triage discard / dependency decisions are applied by the daemon from
2070        // the recorded answer, so they stay open until the chat settles them.
2071        for node in [crate::triage::NODE, crate::triage::DEPS_NODE] {
2072            let triage = q(node, "triage", vec!["hold".into(), "discard".into()]);
2073            assert!(chat_routable(&triage) && awaits_decision(&triage));
2074        }
2075        let mut acted = q("conduct", "conductor", vec!["finish".into(), "hold".into()]);
2076        acted
2077            .actions
2078            .insert("finish".into(), crate::ask::ChoiceAction::Done);
2079        assert!(chat_routable(&acted) && awaits_decision(&acted));
2080        let diverged = q(
2081            crate::reconcile::NODE,
2082            crate::reconcile::SEAT,
2083            vec!["a".into()],
2084        );
2085        assert!(chat_routable(&diverged) && awaits_decision(&diverged));
2086        let release = q(
2087            crate::bump::NOTICE_NODE,
2088            "release-watch",
2089            vec!["hold".into()],
2090        );
2091        assert!(chat_routable(&release) && awaits_decision(&release));
2092        let legacy_release = q(
2093            crate::bump::NOTICE_NODE,
2094            "release-watch",
2095            vec![crate::land::APPROVE.into(), crate::land::HOLD.into()],
2096        );
2097        assert!(chat_routable(&legacy_release));
2098        assert!(awaits_decision(&legacy_release));
2099        // A choice-less bump notice is informational; a targetless approval
2100        // still needs an owner discussion and safe recovery in its chat.
2101        assert!(!chat_routable(&q(crate::bump::NOTICE_NODE, "bump", vec![])));
2102        assert!(chat_routable(&q(
2103            crate::land::APPROVAL_NODE,
2104            "land",
2105            vec!["merge".into()]
2106        )));
2107        let q = |node: &str| q(node, "seat", vec![]);
2108        assert!(chat_routable(&q("conduct")) && !awaits_decision(&q("conduct")));
2109        let mut m = q(crate::bump::NOTICE_NODE);
2110        m.merge_target = Some(crate::merge_decision::Target {
2111            pr: "https://example.test/pull/1".into(),
2112            head: "h".into(),
2113            language: "en".into(),
2114        });
2115        assert!(chat_routable(&m));
2116    }
2117
2118    #[test]
2119    fn unreadable_repository_config_keeps_task_routing_and_pending_delivery() {
2120        let home = tempfile::tempdir().unwrap();
2121        let queue = Queue::at(home.path().join("queue"));
2122        let repo = home.path().join("repo");
2123        std::fs::create_dir(&repo).unwrap();
2124        std::fs::write(repo.join("magi.toml"), "this is = [not toml").unwrap();
2125        let mut task = Task::new("t".into(), "i".into(), repo, crate::queue::Source::Human);
2126        queue.put(&mut task).unwrap();
2127        let questions = Questions::at(home.path().join("questions"));
2128        let mut q = Question::new(
2129            task.id.clone(),
2130            "conduct".into(),
2131            "seat".into(),
2132            "s".into(),
2133            String::new(),
2134            vec![],
2135        );
2136        questions.put(&mut q).unwrap();
2137        assert_eq!(q.routed_task.as_deref(), Some(task.id.as_str()));
2138        assert_eq!(
2139            questions.get(&q.id).unwrap().routed_task.as_deref(),
2140            Some(task.id.as_str())
2141        );
2142        let talks = Talks::at(home.path().join("talks"));
2143        sweep(&queue, &talks, &questions, home.path());
2144        let outbox = crate::task_inquiry::Outbox::at(home.path());
2145        outbox.sweep(&queue, &talks).unwrap();
2146        assert!(
2147            migration_issues(home.path())
2148                .iter()
2149                .any(|issue| issue.id == q.id)
2150        );
2151        let pending = outbox.get(&q.id).unwrap();
2152        assert!(pending.delivered_to.is_none());
2153        assert!(talks.list().is_empty());
2154        assert_eq!(
2155            pending.decision.unwrap().status,
2156            crate::task_decision::Status::AwaitingOwner
2157        );
2158    }
2159
2160    #[test]
2161    fn a_delivered_decision_is_not_rewritten_on_every_sweep() {
2162        let home = tempfile::tempdir().unwrap();
2163        let queue = Queue::at(home.path().join("queue"));
2164        let talks = talk::Talks::at(home.path().join("talks"));
2165        let questions = Questions::at(home.path().join("questions"));
2166        let mut task = Task::new(
2167            "t".into(),
2168            "i".into(),
2169            home.path().to_path_buf(),
2170            crate::queue::Source::Human,
2171        );
2172        queue.put(&mut task).unwrap();
2173        let mut q = Question::new(
2174            task.id.clone(),
2175            "conduct".into(),
2176            "conductor".into(),
2177            "Finish?".into(),
2178            String::new(),
2179            vec!["finish".into(), "hold".into()],
2180        );
2181        q.actions
2182            .insert("finish".into(), crate::ask::ChoiceAction::Done);
2183        q.routed_task = Some(task.id.clone());
2184        q.routed_chat = Some("chat".into());
2185        questions.put(&mut q).unwrap();
2186        assert!(awaits_decision(&q));
2187        let path = questions.path_of(&q.id);
2188        let before = std::fs::read(&path).unwrap();
2189        let written = std::fs::metadata(&path).unwrap().modified().unwrap();
2190        // A rewrite of identical bytes still replaces the file; give it a
2191        // timestamp it could not share with the original write.
2192        std::thread::sleep(std::time::Duration::from_millis(50));
2193        sweep(&queue, &talks, &questions, home.path());
2194        sweep(&queue, &talks, &questions, home.path());
2195        assert_eq!(std::fs::read(&path).unwrap(), before);
2196        assert_eq!(
2197            std::fs::metadata(&path).unwrap().modified().unwrap(),
2198            written
2199        );
2200    }
2201    #[test]
2202    fn repair_receipts_keep_transport_and_failed_repairs_pending() {
2203        use crate::{
2204            ask::ChoiceAction,
2205            run::{MergeRepair, MergeRepairPhase as Phase, RunState},
2206            task_decision::{Decision, Status},
2207            task_inquiry::Outbox,
2208        };
2209        let temp = tempfile::tempdir().unwrap();
2210        let home = temp.path();
2211        let queue = Queue::at(home.join("queue"));
2212        let mut run = RunState::new(
2213            home.into(),
2214            "main".into(),
2215            "base".into(),
2216            "work".into(),
2217            Config::default(),
2218        );
2219        run.reserve_under(home).unwrap();
2220        let mut q = Question::new(
2221            run.id.clone(),
2222            crate::land::APPROVAL_NODE.into(),
2223            "land".into(),
2224            "Repair findings".into(),
2225            String::new(),
2226            vec![crate::land::REPAIR.into()],
2227        );
2228        q.merge_target = Some(crate::merge_decision::Target {
2229            pr: "https://example.test/pull/1".into(),
2230            head: "head".into(),
2231            language: "en".into(),
2232        });
2233        q.actions.insert(
2234            crate::land::REPAIR.into(),
2235            ChoiceAction::Resume {
2236                run: run.id.clone(),
2237            },
2238        );
2239        q.answer(Answer::Choice(crate::land::REPAIR.into()))
2240            .unwrap();
2241        run.next_pass_inquiries = vec![q.id.clone()];
2242        run.begin_pass();
2243        run.save_under(home).unwrap();
2244        let mut task = Task::new(
2245            "work".into(),
2246            "work".into(),
2247            home.into(),
2248            crate::queue::Source::Human,
2249        );
2250        task.runs.push(run.id.clone());
2251        task.mark_action_applied(&q.id);
2252        queue.put(&mut task).unwrap();
2253        let outbox = Outbox::at(home);
2254        let mut record = history_record(&q, Some(&task));
2255        let mut decision = Decision::awaiting(q.summary.clone());
2256        decision
2257            .accept(&format!("decision: {}", crate::land::REPAIR))
2258            .unwrap();
2259        record.decision = Some(decision);
2260        record.archived = false;
2261        outbox.enqueue(record).unwrap();
2262        let check = |expected| {
2263            sync_effect_receipt(home, &Queue::at(home.join("queue")), &q);
2264            let decision = Outbox::at(home).get(&q.id).unwrap().decision.unwrap();
2265            assert_eq!(decision.status, expected);
2266            decision
2267        };
2268        check(Status::Queued); // Resume started; no repair request was consumed yet.
2269        run.merge_repairs.push(MergeRepair {
2270            question: "unrelated".into(),
2271            head: "head".into(),
2272            pr: q.merge_target.as_ref().unwrap().pr.clone(),
2273            reviews: vec![],
2274            gate: vec![],
2275            gate_head: None,
2276            gate_fixes: vec![],
2277            pre_gate: vec![],
2278            phase: Phase::Complete,
2279            failure: None,
2280        });
2281        run.save_under(home).unwrap();
2282        check(Status::Queued);
2283        run.merge_repairs[0].question = q.id.clone();
2284        for phase in [
2285            Phase::Requested,
2286            Phase::Fixing,
2287            Phase::Reviewing,
2288            Phase::Failed,
2289        ] {
2290            run.merge_repairs[0].phase = phase;
2291            run.merge_repairs[0].failure =
2292                (phase == Phase::Failed).then(|| "dirty worktree; inspect before retry".into());
2293            run.save_under(home).unwrap();
2294            let decision = check(if phase == Phase::Failed {
2295                Status::RetryNeeded
2296            } else {
2297                Status::Queued
2298            });
2299            if phase == Phase::Failed {
2300                assert!(decision.error.unwrap().contains("dirty worktree"));
2301                assert!(
2302                    !decision.retry_safe,
2303                    "a repair failure cannot authorize blind replay"
2304                );
2305            }
2306        }
2307        run.merge_repairs[0].phase = Phase::Complete;
2308        run.merge_repairs[0].head = "different-head".into();
2309        run.save_under(home).unwrap();
2310        check(Status::RetryNeeded);
2311        run.merge_repairs[0].head = "head".into();
2312        run.merge_repairs[0].failure = None;
2313        run.save_under(home).unwrap();
2314        check(Status::Resolved);
2315        check(Status::Resolved);
2316    }
2317
2318    #[test]
2319    fn landing_stop_receipts_require_the_intended_effect_after_restart() {
2320        use crate::{
2321            ask::ChoiceAction,
2322            merge_decision::{self as md, Replacement, Target},
2323            queue::{Source, TaskStatus},
2324            run::{PrRecord, RunState, RunStatus},
2325            task_decision::{Decision, Status},
2326            task_inquiry::Outbox,
2327        };
2328        for choice in [crate::land::HOLD, "reimplement:beta"] {
2329            let temp = tempfile::tempdir().unwrap();
2330            let home = temp.path();
2331            let queue = Queue::at(home.join("queue"));
2332            let mut run = RunState::new(
2333                home.into(),
2334                "main".into(),
2335                "base".into(),
2336                "work".into(),
2337                Config::default(),
2338            );
2339            run.reserve_under(home).unwrap();
2340            run.status = RunStatus::Blocked;
2341            run.driver_exited = true;
2342            run.pr = Some(PrRecord {
2343                url: "https://example.test/pull/1".into(),
2344                number: 1,
2345                state: "open".into(),
2346                checks: "green".into(),
2347                round: 1,
2348                rounds: 2,
2349                red_at_merge: vec![],
2350            });
2351            let mut q = Question::new(
2352                run.id.clone(),
2353                crate::land::APPROVAL_NODE.into(),
2354                "land".into(),
2355                "Stop landing".into(),
2356                String::new(),
2357                vec![choice.into()],
2358            );
2359            q.merge_target = Some(Target {
2360                pr: run.pr.as_ref().unwrap().url.clone(),
2361                head: "head".into(),
2362                language: "en".into(),
2363            });
2364            if choice != crate::land::HOLD {
2365                q.actions.insert(
2366                    choice.into(),
2367                    ChoiceAction::Resume {
2368                        run: run.id.clone(),
2369                    },
2370                );
2371            }
2372            q.answer(Answer::Choice(choice.into())).unwrap();
2373            // The old run consumed the Resume transport, but closure may fail.
2374            run.next_pass_inquiries = vec![q.id.clone()];
2375            run.begin_pass();
2376            run.save_under(home).unwrap();
2377            let mut task = Task::new("work".into(), "work".into(), home.into(), Source::Human);
2378            task.runs.push(run.id.clone());
2379            task.hold_manual(Some("landing stopped".into()));
2380            task.mark_action_applied(&q.id);
2381            queue.put(&mut task).unwrap();
2382            let mut record = history_record(&q, Some(&task));
2383            let mut decision = Decision::awaiting(q.summary.clone());
2384            decision.accept(&format!("decision: {choice}")).unwrap();
2385            record.decision = Some(decision);
2386            record.archived = false;
2387            Outbox::at(home).enqueue(record).unwrap();
2388            let check = |expected| {
2389                sync_effect_receipt(home, &Queue::at(home.join("queue")), &q);
2390                assert_eq!(
2391                    Outbox::at(home)
2392                        .get(&q.id)
2393                        .unwrap()
2394                        .decision
2395                        .unwrap()
2396                        .status,
2397                    expected
2398                );
2399            };
2400            check(Status::Queued);
2401            run.merge_decision = Some(md::Decision {
2402                question: q.id.clone(),
2403                target: q.merge_target.clone().unwrap(),
2404                choice: choice.into(),
2405                closed: false,
2406                replacement_run: None,
2407                replacement_pr: None,
2408            });
2409            run.save_under(home).unwrap();
2410            if choice == crate::land::HOLD {
2411                // A checkpoint alone is insufficient until the task hold commits.
2412                task.actions_applied.clear();
2413                task.status = TaskStatus::Running;
2414                queue.put(&mut task).unwrap();
2415                check(Status::Queued);
2416                task.hold_manual(Some("landing stopped".into()));
2417                task.mark_action_applied(&q.id);
2418                queue.put(&mut task).unwrap();
2419                // A later release must not erase the already committed hold.
2420                task.release_operator("chat", None);
2421                queue.put(&mut task).unwrap();
2422                assert!(
2423                    effect_receipt(home, &queue, &q, Some(&task.id))
2424                        .unwrap()
2425                        .is_some()
2426                );
2427                // New receipts also survive reopening/removing the run checkpoint.
2428                task.decision_effects
2429                    .insert(q.id.clone(), format!("decision: {choice}"));
2430                queue.put(&mut task).unwrap();
2431                run.merge_decision = None;
2432                run.save_under(home).unwrap();
2433                check(Status::Resolved);
2434            } else {
2435                check(Status::Queued); // Failed closure, despite the old pass marker.
2436                run.merge_decision.as_mut().unwrap().closed = true;
2437                run.status = RunStatus::Superseded;
2438                run.pr.as_mut().unwrap().state = "closed".into();
2439                run.save_under(home).unwrap();
2440                check(Status::Queued); // Closure and queueing are not replacement execution.
2441                let mut next = RunState::new(
2442                    home.into(),
2443                    "main".into(),
2444                    "base".into(),
2445                    "replacement".into(),
2446                    Config::default(),
2447                );
2448                next.reserve_under(home).unwrap();
2449                next.replaces = Some(Replacement {
2450                    question: q.id.clone(),
2451                    run: run.id.clone(),
2452                    pr: q.merge_target.as_ref().unwrap().pr.clone(),
2453                    agent: "beta".into(),
2454                    context: String::new(),
2455                });
2456                next.save_under(home).unwrap();
2457                run.merge_decision.as_mut().unwrap().replacement_run = Some(next.id.clone());
2458                run.save_under(home).unwrap();
2459                task.start(next.id.clone());
2460                queue.put(&mut task).unwrap();
2461                check(Status::Queued); // Crash before the replacement enters execution.
2462                next.next_pass_task_entry = true;
2463                next.begin_pass();
2464                next.save_under(home).unwrap();
2465                check(Status::Resolved);
2466            }
2467            check(Status::Resolved);
2468        }
2469    }
2470
2471    #[test]
2472    fn quiet_release_receipts_resolve_pending_decisions_after_restart() {
2473        use crate::{
2474            task_decision::{Decision, Status},
2475            task_inquiry::Outbox,
2476        };
2477        for choice in [crate::release_watch::HOLD, crate::release_watch::LEAVE_IT] {
2478            let dir = tempfile::tempdir().unwrap();
2479            let home = dir.path();
2480            let queue = Queue::at(home.join("queue"));
2481            let mut task = Task::new(
2482                "release".into(),
2483                "release".into(),
2484                home.into(),
2485                crate::queue::Source::Human,
2486            );
2487            queue.put(&mut task).unwrap();
2488            let mut q = Question::new(
2489                "run".into(),
2490                crate::bump::NOTICE_NODE.into(),
2491                "release-watch".into(),
2492                "release stalled".into(),
2493                String::new(),
2494                vec![choice.into()],
2495            );
2496            q.answer(Answer::Choice(choice.into())).unwrap();
2497            let mut record = history_record(&q, Some(&task));
2498            let mut decision = Decision::awaiting(q.summary.clone());
2499            decision.accept(&format!("decision: {choice}")).unwrap();
2500            record.decision = Some(decision);
2501            record.archived = false;
2502            Outbox::at(home).enqueue(record).unwrap();
2503            sync_effect_receipt(home, &queue, &q);
2504            assert_eq!(
2505                Outbox::at(home)
2506                    .get(&q.id)
2507                    .unwrap()
2508                    .decision
2509                    .unwrap()
2510                    .status,
2511                Status::Queued
2512            );
2513            let receipts = home.join("release-watch-receipts");
2514            std::fs::create_dir_all(&receipts).unwrap();
2515            let st = crate::release_watch::WatchState {
2516                applied: vec![q.id.clone()],
2517                ..Default::default()
2518            };
2519            std::fs::write(
2520                receipts.join(format!("{}.json", q.id)),
2521                serde_json::to_vec(&st).unwrap(),
2522            )
2523            .unwrap();
2524            for _ in 0..2 {
2525                sync_effect_receipt(home, &Queue::at(home.join("queue")), &q);
2526                assert_eq!(
2527                    Outbox::at(home)
2528                        .get(&q.id)
2529                        .unwrap()
2530                        .decision
2531                        .unwrap()
2532                        .status,
2533                    Status::Resolved
2534                );
2535            }
2536        }
2537    }
2538
2539    #[test]
2540    fn dismiss_receipt_resolves_done_tasks_and_later_attempts_without_task_markers() {
2541        use crate::{
2542            ask::Answer,
2543            queue::{Source, Task, TaskStatus},
2544            run::{LandApproval, PrRecord, RunState, RunStatus},
2545            task_decision::{Decision, Status},
2546            task_inquiry::Outbox,
2547        };
2548        for (later_attempt, incomplete) in [(false, false), (true, false), (false, true)] {
2549            let temp = tempfile::tempdir().unwrap();
2550            let home = temp.path();
2551            let queue = Queue::at(home.join("queue"));
2552            let mut state = RunState::new(
2553                home.into(),
2554                "main".into(),
2555                "base".into(),
2556                "work".into(),
2557                Config::default(),
2558            );
2559            state.reserve_under(home).unwrap();
2560            state.status = RunStatus::Blocked;
2561            state.driver_exited = true;
2562            let mut q = Question::new(
2563                state.id.clone(),
2564                crate::land::APPROVAL_NODE.into(),
2565                "land".into(),
2566                "Obsolete approval".into(),
2567                String::new(),
2568                vec![crate::merge_decision::DISMISS.into()],
2569            );
2570            state.land_approval = Some(LandApproval {
2571                question: q.id.clone(),
2572                head: "head".into(),
2573            });
2574            state.pr = Some(PrRecord {
2575                url: "https://example.test/pull/1".into(),
2576                number: 1,
2577                state: "open".into(),
2578                checks: "green".into(),
2579                round: 1,
2580                rounds: 2,
2581                red_at_merge: vec![],
2582            });
2583            state.save_under(home).unwrap();
2584            let mut task = Task::new("work".into(), "work".into(), home.into(), Source::Human);
2585            task.runs.push(state.id.clone());
2586            task.status = TaskStatus::Done;
2587            if later_attempt {
2588                task.runs.push("later-run".into());
2589                task.status = TaskStatus::Queued;
2590            }
2591            if incomplete {
2592                task.status = TaskStatus::Parked;
2593            }
2594            queue.put(&mut task).unwrap();
2595            q.answer(Answer::Choice(crate::merge_decision::DISMISS.into()))
2596                .unwrap();
2597            let outbox = Outbox::at(home);
2598            let mut record = history_record(&q, Some(&task));
2599            let mut decision = Decision::awaiting(q.summary.clone());
2600            decision.accept("decision: dismiss").unwrap();
2601            record.decision = Some(decision);
2602            record.archived = false;
2603            outbox.enqueue(record).unwrap();
2604            if incomplete {
2605                // Crash window: the run stop was saved, but the latest
2606                // task transition has not yet committed.
2607                state.merge_decision = Some(crate::merge_decision::Decision {
2608                    question: q.id.clone(),
2609                    target: crate::merge_decision::Target {
2610                        pr: state.pr.as_ref().unwrap().url.clone(),
2611                        head: "head".into(),
2612                        language: "en".into(),
2613                    },
2614                    choice: crate::merge_decision::DISMISS.into(),
2615                    closed: false,
2616                    replacement_run: None,
2617                    replacement_pr: None,
2618                });
2619                state.save_under(home).unwrap();
2620                sync_effect_receipt(home, &queue, &q);
2621                assert_eq!(
2622                    outbox.get(&q.id).unwrap().decision.unwrap().status,
2623                    Status::Queued
2624                );
2625            }
2626            crate::merge_decision::dismiss(home, &q).unwrap();
2627            let after = std::fs::read(queue.path_of(&task.id)).unwrap();
2628            assert_eq!(
2629                queue.get(&task.id).unwrap().action_applied(&q.id),
2630                incomplete
2631            );
2632            for _ in 0..2 {
2633                sync_effect_receipt(home, &queue, &q);
2634                assert_eq!(
2635                    Outbox::at(home)
2636                        .get(&q.id)
2637                        .unwrap()
2638                        .decision
2639                        .unwrap()
2640                        .status,
2641                    Status::Resolved
2642                );
2643                assert_eq!(std::fs::read(queue.path_of(&task.id)).unwrap(), after);
2644            }
2645            assert_eq!(
2646                RunState::load_under(&q.run, home)
2647                    .unwrap()
2648                    .pr
2649                    .unwrap()
2650                    .state,
2651                "open"
2652            );
2653        }
2654    }
2655}