1use anyhow::{Context, Result};
4use std::path::Path;
5
6use crate::{
7 ask::{Question, Questions},
8 config::Config,
9 queue::{Queue, Task},
10 talk::{self, Talks},
11};
12
13pub fn task_of(q: &Question, tasks: &[Task]) -> Option<String> {
15 let mut matching = tasks
16 .iter()
17 .filter(|t| t.id == q.run || t.runs.contains(&q.run));
18 let task = matching.next()?;
19 matching.next().is_none().then(|| task.id.clone())
20}
21
22pub(crate) fn chat_routable(q: &Question) -> bool {
25 q.node != crate::bump::NOTICE_NODE
26 || q.merge_target.is_some()
27 || (q.seat == "release-watch" && !q.choices.is_empty())
28}
29
30pub fn awaits_decision(q: &Question) -> bool {
36 q.node == crate::land::APPROVAL_NODE
37 || q.merge_target.is_some()
38 || (chat_routable(q)
39 && (!q.actions.is_empty()
42 || q.node == crate::github_text::ASK_NODE
43 || q.node == crate::triage::NODE
44 || q.node == crate::triage::DEPS_NODE
45 || (q.node == crate::reconcile::NODE && q.seat == crate::reconcile::SEAT)
46 || (q.node == crate::bump::NOTICE_NODE && q.seat == "release-watch")))
47}
48
49pub(crate) fn routes(q: &Question, home: &Path) -> bool {
51 if q.routed_task.is_some() {
52 return true;
53 }
54 if standalone_inquiry(home, q) {
55 return false;
56 }
57 if !q.status.open() || !chat_routable(q) {
58 return false;
59 }
60 let tasks = Queue::at(home.join("queue")).list();
61 let watches = crate::release_watch::states_for_questions(home, std::slice::from_ref(q));
62 task_of_with_watches(q, &tasks, &watches).is_some()
63}
64
65pub(crate) fn destination(
67 queue: &Queue,
68 talks: &Talks,
69 task_id: &str,
70) -> Result<(Task, talk::Talk)> {
71 destination_checked(queue, talks, task_id, |_| Ok(()))
72}
73
74pub(crate) fn destination_checked(
76 queue: &Queue,
77 talks: &Talks,
78 task_id: &str,
79 check: impl FnOnce(&Task) -> Result<()>,
80) -> Result<(Task, talk::Talk)> {
81 let mut reserved = None;
82 let mut invalid = None;
83 queue.modify(task_id, |task| {
84 if let Err(error) = check(task) {
85 invalid = Some(error);
86 return false;
87 }
88 let associated = task
89 .chat
90 .clone()
91 .or_else(|| task.filed_by_chat().map(str::to_owned))
92 .or_else(|| crate::consult::chat_talk_of(&queue.list(), task));
93 let id = associated.unwrap_or_else(|| format!("task-{}", task.id));
96 let changed = task.chat.as_ref() != Some(&id);
97 task.chat = Some(id.clone());
98 reserved = Some((task.clone(), id));
99 changed
100 })?;
101 if let Some(error) = invalid {
102 return Err(error);
103 }
104 let (task, id) = reserved.context("task chat destination was not reserved")?;
105 let chat = destination_in(talks, &task.repo, &id)?;
106 Ok((task, chat))
107}
108
109pub(crate) fn destination_in(talks: &Talks, repo: &Path, id: &str) -> Result<talk::Talk> {
112 let load = |id: &str| -> Result<talk::Talk> {
113 if talks.path_of(id).exists() {
114 talks.get(id)
115 } else {
116 let (cfg, _) = Config::discover(repo, None)?;
117 talk::begin_with_id(
118 talks,
119 &cfg,
120 repo.to_path_buf(),
121 None,
122 &talk::Preferred {
123 agent: None,
124 persona: None,
125 implementers: Some(1),
126 },
127 Some(id.to_owned()),
128 )
129 }
130 };
131 load(id)
132}
133
134fn live_record(home: &Path, task: &Task, q: &Question) -> crate::task_inquiry::Inquiry {
136 let run = if q.run == task.id {
137 task.runs.last().map(String::as_str).unwrap_or("none")
138 } else {
139 &q.run
140 };
141 let facts = crate::chat_notify::run_facts(home, run);
142 let clean = |s: &str| -> String {
143 crate::prompt::defuse(&crate::scrub::scrub(s, &crate::scrub::Identity::current()))
144 .chars()
145 .take(12_000)
146 .collect()
147 };
148 let pr = q
149 .merge_target
150 .as_ref()
151 .map(|t| t.pr.as_str())
152 .or(facts.pr.as_deref())
153 .unwrap_or("none");
154 let body = format!(
155 "# {}\n\n{}\n\n{}\n\nTask: {}\nRun: {}\nPR: {}\nState: {}\n",
156 crate::prompt::TASK_MESSAGE_HEADING,
157 clean(&q.summary),
158 clean(&q.detail),
159 task.id,
160 run,
161 clean(pr),
162 task.status.as_str()
163 );
164 let instructions = if let Some(target) = &q.merge_target {
165 format!(
166 "\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",
167 q.id, target.pr, target.head, q.id, q.id
168 )
169 } else if awaits_decision(q) {
170 let offered = if q.choices.is_empty() {
171 String::new()
172 } else {
173 format!(
174 " The recorded options are: {}.",
175 q.choices
176 .iter()
177 .map(|c| format!("`{c}`"))
178 .collect::<Vec<_>>()
179 .join(", ")
180 )
181 };
182 format!(
183 "\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",
184 q.id, q.id
185 )
186 } else {
187 "\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()
188 };
189 let legacy_answer = q.resolution().map(|answer| format!(
190 "\nHistorical saved reply (evidence only, never a new owner request): {}. Inspect the operation receipt; do not replay it.\n", clean(&answer)
191 )).unwrap_or_default();
192 let text = format!(
193 "{body}\nThis automatic report is not an owner instruction. Investigate and report; it authorizes neither repository edits nor new tasks.\n{instructions}{legacy_answer}"
194 );
195 crate::task_inquiry::Inquiry {
196 schema: 1,
197 id: q.id.clone(),
198 task: task.id.clone(),
199 run: task.runs.contains(&q.run).then(|| q.run.clone()),
200 repo: task.repo.clone(),
201 source: format!("{}:{}:{}", q.node, q.seat, q.run),
202 occurrence: None,
203 text,
204 display: format!("{body}{legacy_answer}"),
205 key: format!("question:{}", q.id),
206 evidence: Some(crate::notice_semantics::question(home, task, run, q)),
207 created_at: q.asked_at,
208 delivered_to: None,
209 decision: Some(crate::task_decision::Decision::awaiting(q.summary.clone())),
210 delivery_error: None,
211 archived: false,
212 }
213}
214
215pub fn post(
219 queue: &Queue,
220 talks: &Talks,
221 home: &Path,
222 task_id: &str,
223 q: &Question,
224) -> Result<String> {
225 let task = queue.get(task_id)?;
226 let outbox = crate::task_inquiry::Outbox::at(home);
227 outbox.enqueue(live_record(home, &task, q))?;
228 if q.resolution().is_some()
232 && q.accepted_answer_at.is_some()
233 && q.accepted_answer_at == q.answered_at
234 {
235 accept_fresh_reply(home, q)?;
236 }
237 outbox.deliver(queue, talks, &q.id)
238}
239
240#[derive(serde::Serialize, serde::Deserialize)]
244struct Migration {
245 schema: u32,
246 #[serde(default)]
248 classification_revision: u32,
249 pending: Vec<String>,
250 #[serde(default)]
252 sources: Option<std::collections::BTreeSet<String>>,
253 #[serde(default)]
254 errors: std::collections::BTreeMap<String, String>,
255}
256
257pub(crate) fn migration_sources(home: &Path) -> Result<Option<std::collections::BTreeSet<String>>> {
260 let path = home.join("notifications/task-chat-migration-v1/state.json");
261 let bytes = match std::fs::read(path) {
262 Ok(bytes) => bytes,
263 Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
264 return Ok(Some(Default::default()));
265 }
266 Err(error) => return Err(error.into()),
267 };
268 let state: Migration = serde_json::from_slice(&bytes)?;
269 anyhow::ensure!(state.schema == 1, "unsupported inquiry migration");
270 Ok(state.sources)
271}
272
273pub(crate) fn standalone_inquiry(home: &Path, q: &Question) -> bool {
276 if q.routed_task.is_some() || (q.node == crate::bump::NOTICE_NODE && q.seat == "release-watch")
277 {
278 return false;
279 }
280 if q.legacy_foreground || q.run.is_empty() {
281 return true;
282 }
283 if Queue::at(home.join("queue"))
286 .list()
287 .iter()
288 .any(|task| task.id == q.run || task.runs.contains(&q.run))
289 {
290 return false;
291 }
292 let run = crate::run::RunState::load_under(&q.run, home).ok();
293 if run
294 .as_ref()
295 .and_then(|run| run.origin.as_ref())
296 .is_some_and(|origin| origin.task.is_some())
297 {
298 return false;
299 }
300 (q.node == "ask" && q.seat == "operator")
301 || (q.cwd.is_some()
302 && run
303 .as_ref()
304 .and_then(|run| run.origin.as_ref())
305 .is_some_and(|origin| origin.task.is_none()))
306}
307
308pub(crate) fn migrated_source(home: &Path, id: &str) -> bool {
309 if Questions::at(home.join("questions"))
312 .read_history(id)
313 .is_ok_and(|q| standalone_inquiry(home, &q))
314 {
315 return false;
316 }
317 migration_sources(home).map_or_else(
318 |error| {
319 tracing::warn!("source {id} stays held: {error:#}");
320 true
321 },
322 |sources| sources.as_ref().is_none_or(|ids| ids.contains(id)),
323 )
324}
325
326pub(crate) fn accept_fresh_reply(home: &Path, q: &Question) -> Result<()> {
330 if standalone_inquiry(home, q) {
331 return Ok(());
332 }
333 let outbox = crate::task_inquiry::Outbox::at(home);
334 match outbox.get(&q.id) {
335 Ok(record)
336 if record.decision.as_ref().is_some_and(|decision| {
337 decision.status == crate::task_decision::Status::Resolved
338 }) =>
339 {
340 return Ok(());
341 }
342 Ok(_) => {}
343 Err(error)
344 if error
345 .downcast_ref::<std::io::Error>()
346 .is_some_and(|error| error.kind() == std::io::ErrorKind::NotFound) =>
347 {
348 let tasks = Queue::at(home.join("queue")).list();
349 let watches = crate::release_watch::states_for_questions(home, std::slice::from_ref(q));
350 let task_id = task_of_with_watches(q, &tasks, &watches);
351 let Some(task) = tasks.iter().find(|task| Some(&task.id) == task_id.as_ref()) else {
352 return Ok(());
353 };
354 let mut inquiry = history_record(q, Some(task));
355 inquiry.run = task.runs.contains(&q.run).then(|| q.run.clone());
356 inquiry.archived = false;
357 inquiry.display = format!("{}\n\n{}", q.summary, q.detail);
358 inquiry.text = format!(
359 "{}\n\nAn owner response was recorded. Its effect is not yet confirmed; do not replay it.",
360 inquiry.display
361 );
362 inquiry.decision = Some(crate::task_decision::Decision::awaiting(q.summary.clone()));
363 outbox.enqueue(inquiry)?;
364 }
365 Err(error) => return Err(error),
366 }
367 outbox.update_decision(&q.id, |decision| {
368 let accepted =
369 decision.accept(&format!("decision: {}", q.resolution().unwrap_or_default()))?;
370 let changed = decision.source_answer_at != q.answered_at;
371 decision.source_answer_at = q.answered_at;
372 Ok(accepted || changed)
373 })?;
374 Ok(())
375}
376
377pub(crate) fn saved_reply_requires_confirmation(home: &Path, q: &Question) -> bool {
380 migrated_source(home, &q.id) && source_reply_needs_confirmation(home, q)
381}
382
383pub(crate) fn source_reply_needs_confirmation(home: &Path, q: &Question) -> bool {
384 if q.answer.is_none()
385 || (q.accepted_answer_at.is_some() && q.accepted_answer_at == q.answered_at)
386 {
387 return false;
388 }
389 let request = format!("decision: {}", q.resolution().unwrap_or_default());
390 !crate::task_inquiry::Outbox::at(home)
391 .get(&q.id)
392 .is_ok_and(|record| {
393 record.decision.as_ref().is_some_and(|decision| {
394 decision.request.as_deref() == Some(request.as_str())
395 && decision.source_answer_at.is_some()
396 && decision.source_answer_at == q.answered_at
397 })
398 })
399}
400
401#[derive(serde::Serialize)]
404pub struct MigrationIssue {
405 pub id: String,
407 pub reason: String,
409}
410
411pub fn migration_issues(home: &Path) -> Vec<MigrationIssue> {
414 let read = || -> Result<Vec<MigrationIssue>> {
415 let path = home.join("notifications/task-chat-migration-v1/state.json");
416 let bytes = match std::fs::read(path) {
417 Ok(bytes) => bytes,
418 Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(vec![]),
419 Err(error) => return Err(error.into()),
420 };
421 let migration: Migration = serde_json::from_slice(&bytes)?;
422 anyhow::ensure!(migration.schema == 1, "unsupported inquiry migration");
423 Ok(migration
424 .errors
425 .into_iter()
426 .map(|(id, reason)| MigrationIssue { id, reason })
427 .collect())
428 };
429 let mut issues = read().unwrap_or_else(|error| {
430 vec![MigrationIssue {
431 id: "migration".into(),
432 reason: format!(
433 "Migration journal needs reconciliation: {error:#}. No approval was inferred."
434 ),
435 }]
436 });
437 if !issues.iter().any(|issue| issue.id == "migration") {
438 match std::fs::read_to_string(
439 home.join("notifications/task-chat-migration-v1/last-error.txt"),
440 ) {
441 Ok(reason) => issues.push(MigrationIssue {
442 id: "migration".into(),
443 reason,
444 }),
445 Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
446 Err(error) => issues.push(MigrationIssue {
447 id: "migration".into(),
448 reason: format!("Migration diagnostic is unreadable: {error:#}"),
449 }),
450 }
451 }
452 issues
453}
454
455pub(crate) fn migration_pending(home: &Path) -> Result<std::collections::BTreeSet<String>> {
456 let path = home.join("notifications/task-chat-migration-v1/state.json");
457 let bytes = match std::fs::read(path) {
458 Ok(bytes) => bytes,
459 Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(Default::default()),
460 Err(error) => return Err(error.into()),
461 };
462 let migration: Migration = serde_json::from_slice(&bytes)?;
463 anyhow::ensure!(migration.schema == 1, "unsupported inquiry migration");
464 Ok(migration.pending.into_iter().collect())
465}
466
467fn migrate_batch(
468 queue: &Queue,
469 talks: &Talks,
470 questions: &Questions,
471 home: &Path,
472 watches: &[crate::release_watch::WatchState],
473) -> Result<()> {
474 let dir = home.join("notifications/task-chat-migration-v1");
475 std::fs::create_dir_all(&dir)?;
476 let lock = std::fs::OpenOptions::new()
477 .create(true)
478 .truncate(false)
479 .write(true)
480 .open(dir.join("migration.lock"))?;
481 if let Err(error) = crate::pr_head::try_lock_file(&lock) {
482 if error.kind() == std::io::ErrorKind::WouldBlock || error.raw_os_error() == Some(33) {
483 return Ok(());
484 }
485 return Err(error.into());
486 }
487 let path = dir.join("state.json");
488 let mut migration: Migration = if path.exists() {
489 serde_json::from_slice(&std::fs::read(&path)?)?
490 } else {
491 Migration {
492 schema: 1,
493 classification_revision: 0,
494 pending: {
497 let mut ids = std::collections::BTreeSet::new();
498 match std::fs::read_dir(questions.root()) {
499 Ok(entries) => {
500 for entry in entries {
501 let path = entry?.path();
502 if path.extension().is_some_and(|ext| ext == "json") {
503 let id = path
504 .file_stem()
505 .and_then(|name| name.to_str())
506 .context("saved inquiry filename is not UTF-8")?;
507 ids.insert(id.to_owned());
508 }
509 }
510 }
511 Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
512 Err(error) => return Err(error.into()),
513 }
514 ids.into_iter().collect()
515 },
516 sources: None,
517 errors: Default::default(),
518 }
519 };
520 let needs_boundary = migration.sources.is_none();
521 if needs_boundary {
522 let mut sources: std::collections::BTreeSet<_> =
523 migration.pending.iter().cloned().collect();
524 match std::fs::read_dir(questions.root()) {
525 Ok(entries) => {
526 for entry in entries {
527 let path = entry?.path();
528 if path
529 .extension()
530 .is_some_and(|extension| extension == "json")
531 {
532 let id = path
533 .file_stem()
534 .and_then(|stem| stem.to_str())
535 .context("saved inquiry filename is not UTF-8")?;
536 sources.insert(id.to_owned());
537 }
538 }
539 }
540 Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
541 Err(error) => return Err(error.into()),
542 }
543 migration.pending = sources.iter().cloned().collect();
544 migration.sources = Some(sources);
545 }
546 anyhow::ensure!(migration.schema == 1, "unsupported task inquiry migration");
547 let save = |state: &Migration| -> Result<()> {
548 let temp = path.with_extension("tmp");
549 std::fs::write(&temp, serde_json::to_vec(state)?)?;
550 std::fs::rename(temp, &path)?;
551 Ok(())
552 };
553 let needs_correction = migration.classification_revision < 1;
554 if needs_correction {
555 let mut pending: std::collections::BTreeSet<_> =
558 migration.pending.iter().cloned().collect();
559 pending.extend(migration.sources.iter().flatten().cloned());
560 migration.pending = pending.into_iter().collect();
561 migration.classification_revision = 1;
562 }
563 if !path.exists() || needs_boundary || needs_correction {
566 save(&migration)?;
567 }
568 if migration.pending.is_empty() {
569 return Ok(());
570 }
571 let batch: Vec<_> = migration
572 .pending
573 .drain(..migration.pending.len().min(64))
574 .collect();
575 let tasks = queue.list();
576 for id in batch {
577 let result = (|| -> Result<()> {
578 let q = questions.read_history(&id)?;
579 if standalone_inquiry(home, &q) {
580 if let Some(sources) = &mut migration.sources {
581 sources.remove(&id);
582 }
583 return Ok(());
584 }
585 if q.node == crate::bump::NOTICE_NODE && q.choices.is_empty() {
586 return Ok(());
587 }
588 let task = task_of_with_watches(&q, &tasks, watches)
589 .and_then(|id| tasks.iter().find(|task| task.id == id));
590 let outbox = crate::task_inquiry::Outbox::at(home);
591 let receipt = effect_receipt(home, queue, &q, task.map(|task| task.id.as_str()));
592 let mut record = history_record(&q, task);
593 match receipt {
594 Ok(Some(receipt)) => {
595 let mut decision = crate::task_decision::Decision::awaiting(q.summary.clone());
596 decision.applied(&receipt)?;
597 record.decision = Some(decision);
598 }
599 outcome if pending_intent(home, &q, task, watches) || outcome.is_err() => {
600 if q.status.open()
601 && let Some(task) = task
602 {
603 record = live_record(home, task, &q);
604 }
605 record.archived = false;
606 let mut decision = crate::task_decision::Decision::awaiting(q.summary.clone());
607 if let Err(error) = outcome {
608 decision
609 .fail(&format!("Source receipt needs reconciliation: {error:#}"))?;
610 } else if q.answer.is_some() {
611 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.")?;
612 }
613 record.decision = Some(decision);
614 record.text.push_str("\n\nImported history authorizes no operation. Saved replies require evidence reconciliation or explicit owner settlement; never replay them.");
615 if task.is_none() {
616 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());
617 }
618 }
619 _ => {}
620 }
621 let current = questions.read_history(&id)?;
622 anyhow::ensure!(
623 (current.status, ¤t.answer, current.answered_at)
624 == (q.status, &q.answer, q.answered_at),
625 "source changed while classifying saved history; retry with its current generation"
626 );
627 outbox.reclassify_history(record)?;
628 sync_effect_receipt(home, queue, &q);
629 let imported = outbox.get(&q.id)?;
630 if imported.archived
631 || imported
632 .decision
633 .as_ref()
634 .is_some_and(|d| d.status == crate::task_decision::Status::Resolved)
635 {
636 return Ok(());
637 }
638 if q.status.open()
641 && let Some(task) = task
642 {
643 if q.routed_task.as_ref() != Some(&task.id) {
644 questions.update(&q.id, |source| {
645 source.routed_task = Some(task.id.clone());
646 Ok(())
647 })?;
648 }
649 post(queue, talks, home, &task.id, &q)?;
650 } else if task.is_some() {
651 outbox.deliver(queue, talks, &q.id)?;
654 }
655 Ok(())
656 })();
657 if let Err(error) = result {
658 tracing::warn!("legacy inquiry {id} import: {error:#}");
659 migration.errors.insert(
660 id.clone(),
661 format!(
662 "Saved inquiry needs reconciliation: {error:#}. Import executed no action."
663 ),
664 );
665 migration.pending.push(id);
666 } else {
667 migration.errors.remove(&id);
668 }
669 }
670 save(&migration)
671}
672
673fn pending_intent(
674 home: &Path,
675 q: &Question,
676 task: Option<&Task>,
677 watches: &[crate::release_watch::WatchState],
678) -> bool {
679 if q.status.open() || (q.answer.is_some() && awaits_decision(q)) {
680 return true;
681 }
682 if watches
683 .iter()
684 .any(|watch| watch.question.as_deref() == Some(q.id.as_str()))
685 {
686 return true;
687 }
688 let Some(task) = task else {
689 return q.answer.is_none() || awaits_decision(q);
690 };
691 if task.blocked_by.contains(&q.id) {
692 return true;
693 }
694 if task.status == crate::queue::TaskStatus::Done {
695 return false;
696 }
697 if q.run != task.id && task.runs.last() != Some(&q.run) {
698 return false;
699 }
700 if q.node == crate::github_text::ASK_NODE {
701 return crate::run::RunState::load_under(&q.run, home).is_ok_and(|run| {
702 run.github_text
703 .as_ref()
704 .is_some_and(|gate| gate.question.as_ref() == Some(&q.id))
705 && (run.pr_publication_pending || run.merge.as_ref().is_none_or(|out| !out.ok))
706 });
707 }
708 awaits_decision(q) || (q.routed_chat.is_some() && q.answer.is_none())
709}
710
711fn history_record(q: &Question, task: Option<&Task>) -> crate::task_inquiry::Inquiry {
712 let saved_reply = q.answer.as_ref().map(|answer| match answer {
713 crate::ask::Answer::Choice(text) | crate::ask::Answer::Text(text) => text.as_str(),
714 });
715 let display = format!(
716 "{}\n\n{}\n\nSaved status: {}\nSaved reply (history only): {}",
717 q.summary,
718 q.detail,
719 q.status.as_str(),
720 saved_reply.unwrap_or("none")
721 );
722 crate::task_inquiry::Inquiry {
723 schema: 1,
724 id: q.id.clone(),
725 task: task.map(|task| task.id.clone()).unwrap_or_default(),
726 run: (!q.run.is_empty() && !q.run_names_task()).then(|| q.run.clone()),
727 repo: task.map(|task| task.repo.clone()).unwrap_or_default(),
728 source: format!("{}:{}:{}", q.node, q.seat, q.run),
729 occurrence: None,
730 text: display.clone(),
731 display,
732 key: format!("question:{}", q.id),
733 evidence: None,
734 created_at: q.asked_at,
735 delivered_to: None,
736 decision: None,
737 delivery_error: None,
738 archived: true,
739 }
740}
741
742pub fn sweep(queue: &Queue, talks: &Talks, questions: &Questions, home: &Path) {
745 let tasks = queue.list();
746 let all = questions.list();
747 let watches = crate::release_watch::states_for_questions(home, &all);
748 let migration_error = home.join("notifications/task-chat-migration-v1/last-error.txt");
749 if let Err(error) = migrate_batch(queue, talks, questions, home, &watches) {
750 tracing::warn!("legacy inquiry migration remains pending: {error:#}");
751 if let Err(save) = std::fs::write(
752 &migration_error,
753 format!("Migration remains pending: {error:#}. No approval was inferred."),
754 ) {
755 tracing::warn!("cannot persist migration failure: {save:#}");
756 }
757 } else if let Err(error) = std::fs::remove_file(&migration_error)
758 && error.kind() != std::io::ErrorKind::NotFound
759 {
760 tracing::warn!("cannot clear migration diagnostic: {error:#}");
761 }
762 let deferred = migration_pending(home).unwrap_or_else(|error| {
763 tracing::warn!("legacy delivery boundary is unreadable: {error:#}");
764 all.iter().map(|q| q.id.clone()).collect()
765 });
766 let outbox = crate::task_inquiry::Outbox::at(home);
767 for q in &all {
768 if deferred.contains(&q.id) {
769 continue;
770 }
771 if let Ok(record) = outbox.get(&q.id) {
772 match questions.read_history(&q.id) {
775 Ok(source) => sync_effect_receipt(home, queue, &source),
776 Err(error) => {
777 tracing::warn!("decision {} source history: {error:#}", q.id);
778 let _ = outbox.update_decision(&q.id, |d| {
779 d.fail(&format!("Source history needs reconciliation: {error:#}"))
780 });
781 }
782 }
783 if record.task.is_empty()
786 && chat_routable(q)
787 && let Some(task) = task_of_with_watches(q, &tasks, &watches)
788 {
789 if let Err(error) = post(queue, talks, home, &task, q) {
790 tracing::warn!("decision {} owner recovery: {error:#}", q.id);
791 }
792 }
793 }
794 }
795 for q in all.into_iter().filter(|q| {
796 q.status.open()
797 && chat_routable(q)
798 && !standalone_inquiry(home, q)
799 && !deferred.contains(&q.id)
800 }) {
801 if outbox.get(&q.id).is_ok_and(|record| {
805 record.archived
806 || record.decision.is_some_and(|decision| {
807 decision.status == crate::task_decision::Status::Resolved
808 })
809 }) {
810 continue;
811 }
812 let Some(task_id) = q
813 .routed_task
814 .clone()
815 .or_else(|| task_of_with_watches(&q, &tasks, &watches))
816 else {
817 continue;
818 };
819 let needs_task = chat_routable(&q) && q.routed_task.as_deref() != Some(task_id.as_str());
823 if q.routed_chat.is_some() && !needs_task {
824 continue;
825 }
826 let result = (|| -> Result<()> {
827 let q = if needs_task {
828 questions
829 .update(&q.id, |r| {
830 if chat_routable(r) && r.routed_task.as_deref() != Some(task_id.as_str()) {
831 r.routed_task = Some(task_id.clone());
832 }
833 Ok(())
834 })?
835 .0
836 } else {
837 q.clone()
838 };
839 if q.routed_chat.is_some() {
841 return Ok(());
842 }
843 let chat = post(queue, talks, home, &task_id, &q)?;
844 questions.update(&q.id, |r| {
845 r.routed_chat = Some(chat.clone());
846 if awaits_decision(r) {
847 r.consult.get_or_insert_with(|| crate::ask::ChatConsult {
851 talk: chat.clone(),
852 at: jiff::Timestamp::now(),
853 });
854 } else if chat_routable(r) && r.merge_target.is_none() {
855 r.abandon(format!("forwarded to task chat {chat}"));
856 }
857 Ok(())
858 })?;
859 Ok(())
860 })();
861 if let Err(e) = result {
862 tracing::warn!("task decision {} delivery: {e:#}", q.id);
863 }
864 }
865}
866
867pub(crate) fn sync_effect_receipt(home: &Path, queue: &Queue, q: &Question) {
870 if q.answer.is_some()
871 && q.accepted_answer_at.is_some()
872 && q.accepted_answer_at == q.answered_at
873 && let Err(error) = accept_fresh_reply(home, q)
874 {
875 tracing::warn!("decision {} acceptance: {error:#}", q.id);
876 return;
877 }
878 let outbox = crate::task_inquiry::Outbox::at(home);
879 let Ok(record) = outbox.get(&q.id) else {
880 return;
881 };
882 let Some(decision) = record.decision else {
883 return;
884 };
885 if decision.status == crate::task_decision::Status::Resolved {
886 return;
887 }
888 let result = match effect_receipt(home, queue, q, Some(&record.task)) {
889 Ok(Some(receipt)) => outbox.update_decision(&q.id, |d| d.applied(&receipt)),
890 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.")),
891 Ok(None) => Ok(()),
892 Err(error) => outbox.update_decision(&q.id, |d| d.fail(&format!("Source receipt needs reconciliation: {error:#}"))),
893 };
894 if let Err(error) = result {
895 tracing::warn!("decision {} projection: {error:#}", q.id);
896 }
897}
898
899pub(crate) fn effect_receipt(
900 home: &Path,
901 queue: &Queue,
902 q: &Question,
903 task: Option<&str>,
904) -> Result<Option<String>> {
905 if let Some(task) = task.and_then(|id| queue.get(id).ok())
906 && crate::repair_budget::reconcile::superseded_question(&task, q)
907 {
908 return Ok(Some(format!(
909 "task {}: unanswered dependency question {} superseded by explicit repair receipt reconciliation; no generic resume applied",
910 task.id, q.id
911 )));
912 }
913 if q.resolution().is_none() {
914 return Ok(None);
915 }
916
917 if q.node == crate::land::APPROVAL_NODE
918 && q.resolution().as_deref() == Some(crate::land::REPAIR)
919 {
920 let run = crate::run::RunState::load_under(&q.run, home)?;
921 let Some(repair) = run.merge_repairs.iter().find(|r| r.question == q.id) else {
922 return Ok(None);
923 };
924 anyhow::ensure!(
925 q.merge_target
926 .as_ref()
927 .is_none_or(|target| { target.pr == repair.pr && target.head == repair.head }),
928 "repair receipt targets a different PR or head"
929 );
930 return match repair.phase {
931 crate::run::MergeRepairPhase::Complete => Ok(Some(format!(
932 "run {}: repair and re-review {} completed for {} at {}",
933 q.run, q.id, repair.pr, repair.head
934 ))),
935 crate::run::MergeRepairPhase::Failed => anyhow::bail!(
936 "repair {} failed: {}",
937 q.id,
938 repair
939 .failure
940 .as_deref()
941 .unwrap_or("inspect the run's repair evidence before retrying")
942 ),
943 _ => Ok(None),
946 };
947 }
948
949 if q.node == crate::land::APPROVAL_NODE
950 && q.resolution().as_deref() == Some(crate::merge_decision::WITHDRAW)
951 {
952 let run = crate::run::RunState::load_under(&q.run, home)?;
953 if let Some(receipt) = &run.merge_decision
954 && receipt.question == q.id
955 && receipt.choice == crate::merge_decision::WITHDRAW
956 && receipt.closed
957 && run.status == crate::run::RunStatus::Superseded
958 && run.pr.as_ref().is_some_and(|pr| {
959 pr.url == receipt.target.pr && pr.state.eq_ignore_ascii_case("closed")
960 })
961 && q.merge_target
962 .as_ref()
963 .is_none_or(|target| target == &receipt.target)
964 {
965 return Ok(Some(format!(
966 "run {}: withdrawal {} confirmed PR closure and retired execution",
967 q.run, q.id
968 )));
969 }
970 return Ok(None);
973 }
974
975 if crate::release_watch::quiet_effect_applied(home, q)? {
976 return Ok(Some(format!(
977 "release watch {}: owner choice applied",
978 q.id
979 )));
980 }
981 if matches!(
982 q.node.as_str(),
983 crate::triage::NODE | crate::triage::DEPS_NODE
984 ) && let Some(id) = task
985 .filter(|id| !id.is_empty())
986 .or_else(|| (!q.run.is_empty()).then_some(q.run.as_str()))
987 && queue.triage_discard_applied(id, &q.id)?
988 {
989 return Ok(Some(format!(
990 "task {id}: triage discard {} committed",
991 q.id
992 )));
993 }
994
995 let task = task
996 .filter(|id| !id.is_empty())
997 .map(|id| queue.get(id))
998 .transpose()?;
999 if q.node == crate::land::APPROVAL_NODE
1000 && let Some(choice) = q.resolution()
1001 && (choice.eq_ignore_ascii_case(crate::land::HOLD)
1002 || crate::merge_decision::selected_agent(&choice).is_some())
1003 {
1004 if choice.eq_ignore_ascii_case(crate::land::HOLD)
1007 && let Some(task) = &task
1008 && task.decision_effects.get(&q.id) == Some(&format!("decision: {choice}"))
1009 {
1010 return Ok(Some(format!(
1011 "task {}: landing hold {} committed",
1012 task.id, q.id
1013 )));
1014 }
1015 let run = crate::run::RunState::load_under(&q.run, home)?;
1016 let Some(receipt) = run.merge_decision.as_ref().filter(|receipt| {
1017 receipt.question == q.id
1018 && receipt.choice == choice
1019 && q.merge_target
1020 .as_ref()
1021 .is_none_or(|target| target == &receipt.target)
1022 }) else {
1023 return Ok(None);
1024 };
1025 if choice.eq_ignore_ascii_case(crate::land::HOLD) {
1026 return Ok(task
1027 .filter(|task| task.action_applied(&q.id))
1028 .map(|task| format!("task {}: landing hold {} committed", task.id, q.id)));
1029 }
1030 if receipt.closed
1033 && run.status == crate::run::RunStatus::Superseded
1034 && run.pr.as_ref().is_some_and(|pr| {
1035 pr.url == receipt.target.pr && pr.state.eq_ignore_ascii_case("closed")
1036 })
1037 && let Some(next) = &receipt.replacement_run
1038 && let Some(task) = &task
1039 && task.runs.contains(next)
1040 {
1041 let replacement = crate::run::RunState::load_under(next, home)?;
1042 if replacement.repo == task.repo
1043 && replacement.replaces.as_ref().is_some_and(|r| {
1044 r.question == q.id
1045 && r.run == q.run
1046 && r.pr == receipt.target.pr
1047 && Some(r.agent.as_str()) == crate::merge_decision::selected_agent(&choice)
1048 })
1049 && replacement.passes.iter().any(|pass| pass.task_entry)
1050 {
1051 return Ok(Some(format!(
1052 "run {}: PR closure confirmed; replacement {next} started for {}",
1053 q.run, q.id
1054 )));
1055 }
1056 }
1057 return Ok(None);
1058 }
1059 if matches!(
1060 q.chosen_action(),
1061 Some(crate::ask::ChoiceAction::RecoverBase { .. })
1062 ) {
1063 return crate::base_recovery_control::effect_receipt(
1064 home,
1065 task.as_ref()
1066 .context("base recovery decision has no owning task")?,
1067 q,
1068 );
1069 }
1070 if let Some(action) = q.chosen_action().filter(|a| a.maintenance()) {
1071 let path = home.join("choice-actions").join(format!("{}.json", q.id));
1072 let bytes = match std::fs::read(path) {
1073 Ok(bytes) => bytes,
1074 Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
1075 Err(error) => return Err(error.into()),
1076 };
1077 let value: serde_json::Value = serde_json::from_slice(&bytes)?;
1078 anyhow::ensure!(
1079 value["action"] == serde_json::to_value(action)?,
1080 "maintenance receipt targets a different action"
1081 );
1082 anyhow::ensure!(
1083 value["status"] == "applied",
1084 "maintenance outcome is not confirmed: {}",
1085 value["status"]
1086 );
1087 return Ok(Some(format!("choice-actions/{}.json: applied", q.id)));
1088 }
1089 if q.node == crate::triage::NODE || q.node == crate::triage::DEPS_NODE {
1090 if let Some(task) = &task
1091 && let Some(evidence) = task.decision_effects.get(&q.id)
1092 {
1093 if evidence.starts_with("repair-receipt-blocked:") {
1094 anyhow::ensure!(
1095 evidence == &crate::repair_budget::reconcile::blocked_resume(q)?,
1096 "blocked resume source changed"
1097 );
1098 return Ok(Some(format!(
1099 "task {}: generic resume {} consumed without release; retained repair receipt requires explicit reconcile-repair-grant",
1100 task.id, q.id
1101 )));
1102 }
1103 let (source, _, _, application): (
1104 String,
1105 Option<jiff::Timestamp>,
1106 String,
1107 crate::queue::Resumption,
1108 ) = serde_json::from_str(evidence)
1109 .context("triage application receipt is unreadable")?;
1110 anyhow::ensure!(
1111 source == crate::repair_budget::reconcile::source(q)?
1112 && task
1113 .resumption
1114 .iter()
1115 .chain(&task.resumption_history)
1116 .any(|r| crate::repair_budget::reconcile::application_identity(r)
1117 == application),
1118 "triage source or application evidence changed"
1119 );
1120 }
1121 return Ok(task.filter(|task| task.triage_applied(&q.id)).map(|_| {
1122 format!(
1123 "task triage {} settled by durable application/supersession evidence",
1124 q.id
1125 )
1126 }));
1127 }
1128 if let Some(task) = &task
1129 && task.action_applied(&q.id)
1130 {
1131 if matches!(
1132 q.chosen_action(),
1133 Some(
1134 crate::ask::ChoiceAction::Done
1135 | crate::ask::ChoiceAction::Hold
1136 | crate::ask::ChoiceAction::Requeue
1137 )
1138 ) && task.decision_effects.get(&q.id)
1139 == Some(&format!(
1140 "decision: {}",
1141 q.resolution().expect("answered action")
1142 ))
1143 {
1144 return Ok(Some(format!(
1145 "task {}: exact choice effect {} committed",
1146 task.id, q.id
1147 )));
1148 }
1149 let applied = match q.chosen_action() {
1150 Some(crate::ask::ChoiceAction::Resume { run }) => {
1151 crate::chat_control::resume_started(home, task, &q.id, run)?
1152 }
1153 Some(crate::ask::ChoiceAction::Done) => task.status == crate::queue::TaskStatus::Done,
1154 Some(crate::ask::ChoiceAction::Hold) => {
1155 task.status == crate::queue::TaskStatus::Held
1156 && task.hold_reason.as_ref() == Some(&q.summary)
1157 }
1158 Some(crate::ask::ChoiceAction::Requeue) => task.fresh_start,
1159 _ => false,
1160 };
1161 if applied {
1162 return Ok(Some(format!(
1163 "task {}: intended effect {} confirmed",
1164 task.id, q.id
1165 )));
1166 }
1167 }
1168 if q.node == crate::github_text::ASK_NODE {
1169 let run = crate::run::RunState::load_under(&q.run, home)?;
1170 if let Some(gate) = &run.github_text
1171 && let Some(next) = &gate.question
1172 && next != &q.id
1173 && crate::ask::Questions::at(home.join("questions"))
1174 .get(next)
1175 .is_ok_and(|successor| {
1176 successor.run == q.run
1177 && successor.node == q.node
1178 && successor.asked_at >= q.asked_at
1179 })
1180 {
1181 return Ok(Some(format!(
1182 "publication inquiry {} explicitly superseded by active source gate {next}; original reply will not be consumed",
1183 q.id
1184 )));
1185 }
1186 if let Some(gate) = &run.github_text
1187 && let Some(receipt) = &gate.publication
1188 {
1189 let expected = match crate::github_text::read_reply(q) {
1190 crate::github_text::Reply::Original => crate::run::GithubTextChoice::Original,
1191 crate::github_text::Reply::Rewrite => crate::run::GithubTextChoice::Rewrite,
1192 crate::github_text::Reply::Title(_) => crate::run::GithubTextChoice::MyTitle,
1193 crate::github_text::Reply::Fallback => crate::run::GithubTextChoice::Fallback,
1194 };
1195 if q.resolution().is_some()
1196 && receipt.inquiry == q.id
1197 && receipt.fingerprint == gate.fingerprint
1198 {
1199 anyhow::ensure!(
1200 receipt.choice == expected,
1201 "publication applied a different payload than the saved reply"
1202 );
1203 return Ok(Some(format!(
1204 "publication {} for {}: {:?} applied",
1205 receipt.url, q.id, receipt.choice
1206 )));
1207 }
1208 }
1209 }
1210 if q.node == crate::land::APPROVAL_NODE
1211 && q.resolution().as_deref() == Some(crate::merge_decision::DISMISS)
1212 {
1213 let run = crate::run::RunState::load_under(&q.run, home)?;
1216 let stopped = run
1217 .merge_decision
1218 .as_ref()
1219 .is_some_and(|d| d.question == q.id && d.choice == crate::merge_decision::DISMISS);
1220 let settled = queue.list().iter().all(|task| {
1223 task.runs.last() != Some(&q.run)
1224 || task.status == crate::queue::TaskStatus::Done
1225 || task.action_applied(&q.id)
1226 });
1227 if stopped && settled {
1228 return Ok(Some(format!(
1229 "run {}: obsolete approval {} dismissed; PR unchanged",
1230 q.run, q.id
1231 )));
1232 }
1233 }
1234 if q.node == crate::land::APPROVAL_NODE
1235 && let Some(target) = &q.merge_target
1236 && q.resolution().as_deref() == Some(crate::land::APPROVE)
1237 {
1238 let run = crate::run::RunState::load_under(&q.run, home)?;
1239 if run.pr_merged_head.as_deref() == Some(target.head.as_str())
1240 && run
1241 .pr
1242 .as_ref()
1243 .is_some_and(|pr| pr.url == target.pr && pr.state.eq_ignore_ascii_case("merged"))
1244 {
1245 return Ok(Some(format!(
1246 "run {}: merged {} at {}",
1247 q.run, target.pr, target.head
1248 )));
1249 }
1250 }
1251 Ok(None)
1252}
1253
1254pub fn approval_offered(talk: &talk::Talk, q: &Question) -> bool {
1257 talk.status.open()
1258 && q.status.open()
1259 && q.merge_target.is_some()
1260 && q.routed_chat.as_deref() == Some(talk.id.as_str())
1261 && talk.notified.contains(&format!("question:{}", q.id))
1262 && talk.turns.iter().any(|turn| {
1263 talk::sender(turn, None) == talk::Sender::Persona && turn.body.contains(&q.id)
1264 })
1265}
1266
1267fn task_of_with_watches(
1268 q: &Question,
1269 tasks: &[Task],
1270 watches: &[crate::release_watch::WatchState],
1271) -> Option<String> {
1272 let mut ids = std::collections::BTreeSet::new();
1273 if let Some(id) = task_of(q, tasks) {
1274 ids.insert(id);
1275 }
1276 for reference in crate::consult::question_task_refs(q, watches) {
1277 for task in tasks.iter().filter(|t| match reference {
1278 crate::consult::QuestionTaskRef::Task(id) => t.id == id,
1279 crate::consult::QuestionTaskRef::Run(id) => t.runs.iter().any(|r| r == id),
1280 }) {
1281 ids.insert(task.id.clone());
1282 }
1283 }
1284 if ids.len() == 1 {
1285 ids.pop_first()
1286 } else {
1287 None
1288 }
1289}
1290
1291#[cfg(test)]
1292mod tests {
1293 use super::*;
1294 use crate::ask::{Answer, QuestionStatus};
1295
1296 #[tokio::test]
1297 async fn release_2029_stays_answered_across_partial_import_and_restart() {
1298 use crate::{task_decision::Status, task_inquiry::Outbox};
1299 let home = tempfile::tempdir().unwrap();
1300 let home = home.path();
1301 let questions = Questions::at(home.join("questions"));
1302 let queue = Queue::at(home.join("queue"));
1303 let talks = Talks::at(home.join("talks"));
1304 let outbox = Outbox::at(home);
1305 let mut saved = Vec::new();
1306 for index in 0..66 {
1307 let mut q = Question::new(
1308 String::new(),
1309 crate::bump::NOTICE_NODE.into(),
1310 "release-watch".into(),
1311 "Release approval".into(),
1312 "Saved reviewed head".into(),
1313 vec!["merge".into(), "hold".into()],
1314 );
1315 q.id = format!(
1316 "20261109-014940-871849981cd969b1-0000000000000000-{}",
1317 1964 + index
1318 );
1319 q.merge_target = Some(crate::merge_decision::Target {
1320 pr: "https://example.test/mebae/pull/100".into(),
1321 head: "4d5a46f99a678608d2b883498d8bebd9399c0261".into(),
1322 language: "en".into(),
1323 });
1324 q.answer(Answer::Choice(
1325 if index == 0 { "hold" } else { "merge" }.into(),
1326 ))
1327 .unwrap();
1328 q.answered_at = Some("2026-11-08T17:03:30.66862Z".parse().unwrap());
1329 q.answer_delivered = true;
1330 questions.put(&mut q).unwrap();
1331 saved.push(q);
1332 }
1333 let receipts = home.join("release-watch-receipts");
1335 std::fs::create_dir_all(&receipts).unwrap();
1336 let receipt = crate::release_watch::WatchState {
1337 applied: vec![saved[0].id.clone()],
1338 ..Default::default()
1339 };
1340 std::fs::write(
1341 receipts.join(format!("{}.json", saved[0].id)),
1342 serde_json::to_vec(&receipt).unwrap(),
1343 )
1344 .unwrap();
1345 outbox.enqueue(history_record(&saved[1], None)).unwrap();
1348 let dir = home.join("notifications/task-chat-migration-v1");
1349 std::fs::create_dir_all(&dir).unwrap();
1350 std::fs::write(
1351 dir.join("state.json"),
1352 serde_json::to_vec(&serde_json::json!({
1353 "schema": 1, "sources": saved.iter().map(|q| &q.id).collect::<Vec<_>>(),
1354 "pending": saved[64..].iter().map(|q| &q.id).collect::<Vec<_>>()
1355 }))
1356 .unwrap(),
1357 )
1358 .unwrap();
1359 let source = &saved[65];
1360 assert!(source.id.ends_with("2029"));
1361 let bytes = std::fs::read(questions.path_of(&source.id)).unwrap();
1362 let assert_history = || {
1363 let read = questions.get(&source.id).unwrap();
1364 assert_eq!(read.status, QuestionStatus::Answered);
1365 assert_eq!(read.resolution().as_deref(), Some("merge"));
1366 assert_eq!(read.answered_at, source.answered_at);
1367 assert_eq!(
1368 questions.list().iter().filter(|q| q.status.open()).count(),
1369 0
1370 );
1371 assert!(
1372 questions
1373 .get_for_effects(&source.id)
1374 .unwrap()
1375 .resolution()
1376 .is_none()
1377 );
1378 assert!(
1379 questions
1380 .update(&source.id, |q| q.answer(Answer::Choice("merge".into())))
1381 .is_err()
1382 );
1383 let mut operational = questions.get_for_effects(&source.id).unwrap();
1384 operational.abandon("old deadline");
1385 assert!(
1386 questions.put(&mut operational).is_err(),
1387 "quarantine must not activate a default on timeout"
1388 );
1389 assert_eq!(std::fs::read(questions.path_of(&source.id)).unwrap(), bytes);
1390 };
1391 assert_history();
1392 assert_eq!(
1393 questions
1394 .abandon_for_run("", "retired source owner")
1395 .unwrap(),
1396 0
1397 );
1398 assert_history();
1399 let mut waiting = source.clone();
1400 assert!(matches!(
1401 crate::ask::resume_wait(&mut waiting, &questions, std::time::Duration::ZERO)
1402 .await
1403 .unwrap(),
1404 crate::ask::Wait::Pending
1405 ));
1406 assert_history();
1407 sweep(&queue, &talks, &questions, home);
1408 assert_history();
1409 assert_eq!(migration_pending(home).unwrap().len(), 2);
1410 assert!(
1411 outbox.get(&source.id).is_err(),
1412 "2029 is beyond the first batch"
1413 );
1414 assert_eq!(
1415 outbox.get(&saved[0].id).unwrap().decision.unwrap().status,
1416 Status::Resolved
1417 );
1418 let repaired = outbox.get(&saved[1].id).unwrap();
1419 assert!(!repaired.archived);
1420 assert_eq!(repaired.decision.unwrap().status, Status::RetryNeeded);
1421 for _ in 0..2 {
1423 sweep(
1424 &Queue::at(home.join("queue")),
1425 &Talks::at(home.join("talks")),
1426 &Questions::at(home.join("questions")),
1427 home,
1428 );
1429 assert_history();
1430 }
1431 assert!(migration_pending(home).unwrap().is_empty());
1432 let imported = outbox.get(&source.id).unwrap();
1433 assert!(!imported.archived);
1434 assert!(imported.task.is_empty());
1435 assert!(
1436 imported
1437 .delivery_error
1438 .unwrap()
1439 .contains("missing or ambiguous")
1440 );
1441 let decision = imported.decision.unwrap();
1442 assert_eq!(decision.status, Status::RetryNeeded);
1443 assert!(decision.request.is_none());
1444 assert!(decision.source_answer_at.is_none());
1445 assert!(queue.list().is_empty());
1446 assert!(talks.list().is_empty());
1447 let mut later = saved[1].clone();
1448 later.id = "outside-boundary".into();
1449 questions.put(&mut later).unwrap();
1450 sweep(&queue, &talks, &questions, home);
1451 assert!(
1452 outbox.get(&later.id).is_err(),
1453 "correction must not expand its boundary"
1454 );
1455 }
1456
1457 #[test]
1458 fn history_correction_preserves_accepted_and_completed_decisions() {
1459 let home = tempfile::tempdir().unwrap();
1460 let outbox = crate::task_inquiry::Outbox::at(home.path());
1461 for completed in [false, true] {
1462 let q = Question::new(
1463 String::new(),
1464 crate::bump::NOTICE_NODE.into(),
1465 "release-watch".into(),
1466 "Saved release".into(),
1467 String::new(),
1468 vec!["hold".into()],
1469 );
1470 let mut record = history_record(&q, None);
1471 record.archived = false;
1472 record.decision = Some(crate::task_decision::Decision::awaiting(q.summary.clone()));
1473 outbox.enqueue(record).unwrap();
1474 outbox
1475 .update_decision(&q.id, |d| {
1476 if completed {
1477 d.applied("explicit durable effect receipt")
1478 } else {
1479 d.accept("decision: hold")
1480 }
1481 })
1482 .unwrap();
1483 let before = outbox.get(&q.id).unwrap();
1484 outbox.reclassify_history(history_record(&q, None)).unwrap();
1485 assert_eq!(outbox.get(&q.id).unwrap(), before);
1486 }
1487 }
1488
1489 #[test]
1490 fn routed_merge_accepts_direct_answers_and_checks_optional_button_binding() {
1491 let mut q = Question::new(
1492 "run".into(),
1493 crate::land::APPROVAL_NODE.into(),
1494 "land".into(),
1495 "Merge?".into(),
1496 String::new(),
1497 vec!["merge".into(), "hold".into()],
1498 );
1499 q.routed_task = Some("task".into());
1500 q.routed_chat = Some("chat".into());
1501 q.merge_target = Some(crate::merge_decision::Target {
1502 pr: "https://example.test/pull/1".into(),
1503 head: "head-a".into(),
1504 language: "en".into(),
1505 });
1506 assert!(q.clone().answer(Answer::Choice("merge".into())).is_ok());
1507 assert!(
1508 q.settle_by_deputy("seat", "merge", None).is_err(),
1509 "a routed decision is the task chat's, never a deputy's"
1510 );
1511 assert!(
1512 q.answer_chat_button(Answer::Choice("merge".into()), "other-chat", "head-a")
1513 .is_err()
1514 );
1515 assert!(
1516 q.answer_chat_button(Answer::Choice("merge".into()), "chat", "old-head")
1517 .is_err()
1518 );
1519 assert!(
1520 q.answer_chat_button(Answer::Text("merge".into()), "chat", "head-a")
1521 .is_err()
1522 );
1523 assert_eq!(q.status, QuestionStatus::Open);
1524 q.answer_chat_button(Answer::Choice("merge".into()), "chat", "head-a")
1525 .unwrap();
1526 assert_eq!(q.resolution().as_deref(), Some("merge"));
1527 assert!(
1528 q.answer_chat_button(Answer::Choice("merge".into()), "chat", "head-a")
1529 .is_err()
1530 );
1531 }
1532
1533 #[test]
1534 fn gate_divergence_and_release_questions_route_and_await_a_decision() {
1535 let q = |node: &str, seat: &str, choices: Vec<String>| {
1536 Question::new(
1537 "run".into(),
1538 node.into(),
1539 seat.into(),
1540 "s".into(),
1541 String::new(),
1542 choices,
1543 )
1544 };
1545 let gate = q(
1546 crate::github_text::ASK_NODE,
1547 "posting-gate",
1548 vec!["use fallback".into()],
1549 );
1550 assert!(chat_routable(&gate) && awaits_decision(&gate));
1551 for node in [crate::triage::NODE, crate::triage::DEPS_NODE] {
1554 let triage = q(node, "triage", vec!["hold".into(), "discard".into()]);
1555 assert!(chat_routable(&triage) && awaits_decision(&triage));
1556 }
1557 let mut acted = q("conduct", "conductor", vec!["finish".into(), "hold".into()]);
1558 acted
1559 .actions
1560 .insert("finish".into(), crate::ask::ChoiceAction::Done);
1561 assert!(chat_routable(&acted) && awaits_decision(&acted));
1562 let diverged = q(
1563 crate::reconcile::NODE,
1564 crate::reconcile::SEAT,
1565 vec!["a".into()],
1566 );
1567 assert!(chat_routable(&diverged) && awaits_decision(&diverged));
1568 let release = q(
1569 crate::bump::NOTICE_NODE,
1570 "release-watch",
1571 vec!["hold".into()],
1572 );
1573 assert!(chat_routable(&release) && awaits_decision(&release));
1574 let legacy_release = q(
1575 crate::bump::NOTICE_NODE,
1576 "release-watch",
1577 vec![crate::land::APPROVE.into(), crate::land::HOLD.into()],
1578 );
1579 assert!(chat_routable(&legacy_release));
1580 assert!(awaits_decision(&legacy_release));
1581 assert!(!chat_routable(&q(crate::bump::NOTICE_NODE, "bump", vec![])));
1584 assert!(chat_routable(&q(
1585 crate::land::APPROVAL_NODE,
1586 "land",
1587 vec!["merge".into()]
1588 )));
1589 let q = |node: &str| q(node, "seat", vec![]);
1590 assert!(chat_routable(&q("conduct")) && !awaits_decision(&q("conduct")));
1591 let mut m = q(crate::bump::NOTICE_NODE);
1592 m.merge_target = Some(crate::merge_decision::Target {
1593 pr: "https://example.test/pull/1".into(),
1594 head: "h".into(),
1595 language: "en".into(),
1596 });
1597 assert!(chat_routable(&m));
1598 }
1599
1600 #[test]
1601 fn unreadable_repository_config_keeps_task_routing_and_pending_delivery() {
1602 let home = tempfile::tempdir().unwrap();
1603 let queue = Queue::at(home.path().join("queue"));
1604 let repo = home.path().join("repo");
1605 std::fs::create_dir(&repo).unwrap();
1606 std::fs::write(repo.join("magi.toml"), "this is = [not toml").unwrap();
1607 let mut task = Task::new("t".into(), "i".into(), repo, crate::queue::Source::Human);
1608 queue.put(&mut task).unwrap();
1609 let questions = Questions::at(home.path().join("questions"));
1610 let mut q = Question::new(
1611 task.id.clone(),
1612 "conduct".into(),
1613 "seat".into(),
1614 "s".into(),
1615 String::new(),
1616 vec![],
1617 );
1618 questions.put(&mut q).unwrap();
1619 assert_eq!(q.routed_task.as_deref(), Some(task.id.as_str()));
1620 assert_eq!(
1621 questions.get(&q.id).unwrap().routed_task.as_deref(),
1622 Some(task.id.as_str())
1623 );
1624 let talks = Talks::at(home.path().join("talks"));
1625 sweep(&queue, &talks, &questions, home.path());
1626 let outbox = crate::task_inquiry::Outbox::at(home.path());
1627 outbox.sweep(&queue, &talks).unwrap();
1628 assert!(
1629 migration_issues(home.path())
1630 .iter()
1631 .any(|issue| issue.id == q.id)
1632 );
1633 let pending = outbox.get(&q.id).unwrap();
1634 assert!(pending.delivered_to.is_none());
1635 assert!(talks.list().is_empty());
1636 assert_eq!(
1637 pending.decision.unwrap().status,
1638 crate::task_decision::Status::AwaitingOwner
1639 );
1640 }
1641
1642 #[test]
1643 fn a_delivered_decision_is_not_rewritten_on_every_sweep() {
1644 let home = tempfile::tempdir().unwrap();
1645 let queue = Queue::at(home.path().join("queue"));
1646 let talks = talk::Talks::at(home.path().join("talks"));
1647 let questions = Questions::at(home.path().join("questions"));
1648 let mut task = Task::new(
1649 "t".into(),
1650 "i".into(),
1651 home.path().to_path_buf(),
1652 crate::queue::Source::Human,
1653 );
1654 queue.put(&mut task).unwrap();
1655 let mut q = Question::new(
1656 task.id.clone(),
1657 "conduct".into(),
1658 "conductor".into(),
1659 "Finish?".into(),
1660 String::new(),
1661 vec!["finish".into(), "hold".into()],
1662 );
1663 q.actions
1664 .insert("finish".into(), crate::ask::ChoiceAction::Done);
1665 q.routed_task = Some(task.id.clone());
1666 q.routed_chat = Some("chat".into());
1667 questions.put(&mut q).unwrap();
1668 assert!(awaits_decision(&q));
1669 let path = questions.path_of(&q.id);
1670 let before = std::fs::read(&path).unwrap();
1671 let written = std::fs::metadata(&path).unwrap().modified().unwrap();
1672 std::thread::sleep(std::time::Duration::from_millis(50));
1675 sweep(&queue, &talks, &questions, home.path());
1676 sweep(&queue, &talks, &questions, home.path());
1677 assert_eq!(std::fs::read(&path).unwrap(), before);
1678 assert_eq!(
1679 std::fs::metadata(&path).unwrap().modified().unwrap(),
1680 written
1681 );
1682 }
1683 #[test]
1684 fn repair_receipts_keep_transport_and_failed_repairs_pending() {
1685 use crate::{
1686 ask::ChoiceAction,
1687 run::{MergeRepair, MergeRepairPhase as Phase, RunState},
1688 task_decision::{Decision, Status},
1689 task_inquiry::Outbox,
1690 };
1691 let temp = tempfile::tempdir().unwrap();
1692 let home = temp.path();
1693 let queue = Queue::at(home.join("queue"));
1694 let mut run = RunState::new(
1695 home.into(),
1696 "main".into(),
1697 "base".into(),
1698 "work".into(),
1699 Config::default(),
1700 );
1701 run.reserve_under(home).unwrap();
1702 let mut q = Question::new(
1703 run.id.clone(),
1704 crate::land::APPROVAL_NODE.into(),
1705 "land".into(),
1706 "Repair findings".into(),
1707 String::new(),
1708 vec![crate::land::REPAIR.into()],
1709 );
1710 q.merge_target = Some(crate::merge_decision::Target {
1711 pr: "https://example.test/pull/1".into(),
1712 head: "head".into(),
1713 language: "en".into(),
1714 });
1715 q.actions.insert(
1716 crate::land::REPAIR.into(),
1717 ChoiceAction::Resume {
1718 run: run.id.clone(),
1719 },
1720 );
1721 q.answer(Answer::Choice(crate::land::REPAIR.into()))
1722 .unwrap();
1723 run.next_pass_inquiries = vec![q.id.clone()];
1724 run.begin_pass();
1725 run.save_under(home).unwrap();
1726 let mut task = Task::new(
1727 "work".into(),
1728 "work".into(),
1729 home.into(),
1730 crate::queue::Source::Human,
1731 );
1732 task.runs.push(run.id.clone());
1733 task.mark_action_applied(&q.id);
1734 queue.put(&mut task).unwrap();
1735 let outbox = Outbox::at(home);
1736 let mut record = history_record(&q, Some(&task));
1737 let mut decision = Decision::awaiting(q.summary.clone());
1738 decision
1739 .accept(&format!("decision: {}", crate::land::REPAIR))
1740 .unwrap();
1741 record.decision = Some(decision);
1742 record.archived = false;
1743 outbox.enqueue(record).unwrap();
1744 let check = |expected| {
1745 sync_effect_receipt(home, &Queue::at(home.join("queue")), &q);
1746 let decision = Outbox::at(home).get(&q.id).unwrap().decision.unwrap();
1747 assert_eq!(decision.status, expected);
1748 decision
1749 };
1750 check(Status::Queued); run.merge_repairs.push(MergeRepair {
1752 question: "unrelated".into(),
1753 head: "head".into(),
1754 pr: q.merge_target.as_ref().unwrap().pr.clone(),
1755 reviews: vec![],
1756 gate: vec![],
1757 gate_head: None,
1758 gate_fixes: vec![],
1759 pre_gate: vec![],
1760 phase: Phase::Complete,
1761 failure: None,
1762 });
1763 run.save_under(home).unwrap();
1764 check(Status::Queued);
1765 run.merge_repairs[0].question = q.id.clone();
1766 for phase in [
1767 Phase::Requested,
1768 Phase::Fixing,
1769 Phase::Reviewing,
1770 Phase::Failed,
1771 ] {
1772 run.merge_repairs[0].phase = phase;
1773 run.merge_repairs[0].failure =
1774 (phase == Phase::Failed).then(|| "dirty worktree; inspect before retry".into());
1775 run.save_under(home).unwrap();
1776 let decision = check(if phase == Phase::Failed {
1777 Status::RetryNeeded
1778 } else {
1779 Status::Queued
1780 });
1781 if phase == Phase::Failed {
1782 assert!(decision.error.unwrap().contains("dirty worktree"));
1783 assert!(
1784 !decision.retry_safe,
1785 "a repair failure cannot authorize blind replay"
1786 );
1787 }
1788 }
1789 run.merge_repairs[0].phase = Phase::Complete;
1790 run.merge_repairs[0].head = "different-head".into();
1791 run.save_under(home).unwrap();
1792 check(Status::RetryNeeded);
1793 run.merge_repairs[0].head = "head".into();
1794 run.merge_repairs[0].failure = None;
1795 run.save_under(home).unwrap();
1796 check(Status::Resolved);
1797 check(Status::Resolved);
1798 }
1799
1800 #[test]
1801 fn landing_stop_receipts_require_the_intended_effect_after_restart() {
1802 use crate::{
1803 ask::ChoiceAction,
1804 merge_decision::{self as md, Replacement, Target},
1805 queue::{Source, TaskStatus},
1806 run::{PrRecord, RunState, RunStatus},
1807 task_decision::{Decision, Status},
1808 task_inquiry::Outbox,
1809 };
1810 for choice in [crate::land::HOLD, "reimplement:beta"] {
1811 let temp = tempfile::tempdir().unwrap();
1812 let home = temp.path();
1813 let queue = Queue::at(home.join("queue"));
1814 let mut run = RunState::new(
1815 home.into(),
1816 "main".into(),
1817 "base".into(),
1818 "work".into(),
1819 Config::default(),
1820 );
1821 run.reserve_under(home).unwrap();
1822 run.status = RunStatus::Blocked;
1823 run.driver_exited = true;
1824 run.pr = Some(PrRecord {
1825 url: "https://example.test/pull/1".into(),
1826 number: 1,
1827 state: "open".into(),
1828 checks: "green".into(),
1829 round: 1,
1830 rounds: 2,
1831 red_at_merge: vec![],
1832 });
1833 let mut q = Question::new(
1834 run.id.clone(),
1835 crate::land::APPROVAL_NODE.into(),
1836 "land".into(),
1837 "Stop landing".into(),
1838 String::new(),
1839 vec![choice.into()],
1840 );
1841 q.merge_target = Some(Target {
1842 pr: run.pr.as_ref().unwrap().url.clone(),
1843 head: "head".into(),
1844 language: "en".into(),
1845 });
1846 if choice != crate::land::HOLD {
1847 q.actions.insert(
1848 choice.into(),
1849 ChoiceAction::Resume {
1850 run: run.id.clone(),
1851 },
1852 );
1853 }
1854 q.answer(Answer::Choice(choice.into())).unwrap();
1855 run.next_pass_inquiries = vec![q.id.clone()];
1857 run.begin_pass();
1858 run.save_under(home).unwrap();
1859 let mut task = Task::new("work".into(), "work".into(), home.into(), Source::Human);
1860 task.runs.push(run.id.clone());
1861 task.hold_manual(Some("landing stopped".into()));
1862 task.mark_action_applied(&q.id);
1863 queue.put(&mut task).unwrap();
1864 let mut record = history_record(&q, Some(&task));
1865 let mut decision = Decision::awaiting(q.summary.clone());
1866 decision.accept(&format!("decision: {choice}")).unwrap();
1867 record.decision = Some(decision);
1868 record.archived = false;
1869 Outbox::at(home).enqueue(record).unwrap();
1870 let check = |expected| {
1871 sync_effect_receipt(home, &Queue::at(home.join("queue")), &q);
1872 assert_eq!(
1873 Outbox::at(home)
1874 .get(&q.id)
1875 .unwrap()
1876 .decision
1877 .unwrap()
1878 .status,
1879 expected
1880 );
1881 };
1882 check(Status::Queued);
1883 run.merge_decision = Some(md::Decision {
1884 question: q.id.clone(),
1885 target: q.merge_target.clone().unwrap(),
1886 choice: choice.into(),
1887 closed: false,
1888 replacement_run: None,
1889 replacement_pr: None,
1890 });
1891 run.save_under(home).unwrap();
1892 if choice == crate::land::HOLD {
1893 task.actions_applied.clear();
1895 task.status = TaskStatus::Running;
1896 queue.put(&mut task).unwrap();
1897 check(Status::Queued);
1898 task.hold_manual(Some("landing stopped".into()));
1899 task.mark_action_applied(&q.id);
1900 queue.put(&mut task).unwrap();
1901 task.release_operator("chat", None);
1903 queue.put(&mut task).unwrap();
1904 assert!(
1905 effect_receipt(home, &queue, &q, Some(&task.id))
1906 .unwrap()
1907 .is_some()
1908 );
1909 task.decision_effects
1911 .insert(q.id.clone(), format!("decision: {choice}"));
1912 queue.put(&mut task).unwrap();
1913 run.merge_decision = None;
1914 run.save_under(home).unwrap();
1915 check(Status::Resolved);
1916 } else {
1917 check(Status::Queued); run.merge_decision.as_mut().unwrap().closed = true;
1919 run.status = RunStatus::Superseded;
1920 run.pr.as_mut().unwrap().state = "closed".into();
1921 run.save_under(home).unwrap();
1922 check(Status::Queued); let mut next = RunState::new(
1924 home.into(),
1925 "main".into(),
1926 "base".into(),
1927 "replacement".into(),
1928 Config::default(),
1929 );
1930 next.reserve_under(home).unwrap();
1931 next.replaces = Some(Replacement {
1932 question: q.id.clone(),
1933 run: run.id.clone(),
1934 pr: q.merge_target.as_ref().unwrap().pr.clone(),
1935 agent: "beta".into(),
1936 context: String::new(),
1937 });
1938 next.save_under(home).unwrap();
1939 run.merge_decision.as_mut().unwrap().replacement_run = Some(next.id.clone());
1940 run.save_under(home).unwrap();
1941 task.start(next.id.clone());
1942 queue.put(&mut task).unwrap();
1943 check(Status::Queued); next.next_pass_task_entry = true;
1945 next.begin_pass();
1946 next.save_under(home).unwrap();
1947 check(Status::Resolved);
1948 }
1949 check(Status::Resolved);
1950 }
1951 }
1952
1953 #[test]
1954 fn quiet_release_receipts_resolve_pending_decisions_after_restart() {
1955 use crate::{
1956 task_decision::{Decision, Status},
1957 task_inquiry::Outbox,
1958 };
1959 for choice in [crate::release_watch::HOLD, crate::release_watch::LEAVE_IT] {
1960 let dir = tempfile::tempdir().unwrap();
1961 let home = dir.path();
1962 let queue = Queue::at(home.join("queue"));
1963 let mut task = Task::new(
1964 "release".into(),
1965 "release".into(),
1966 home.into(),
1967 crate::queue::Source::Human,
1968 );
1969 queue.put(&mut task).unwrap();
1970 let mut q = Question::new(
1971 "run".into(),
1972 crate::bump::NOTICE_NODE.into(),
1973 "release-watch".into(),
1974 "release stalled".into(),
1975 String::new(),
1976 vec![choice.into()],
1977 );
1978 q.answer(Answer::Choice(choice.into())).unwrap();
1979 let mut record = history_record(&q, Some(&task));
1980 let mut decision = Decision::awaiting(q.summary.clone());
1981 decision.accept(&format!("decision: {choice}")).unwrap();
1982 record.decision = Some(decision);
1983 record.archived = false;
1984 Outbox::at(home).enqueue(record).unwrap();
1985 sync_effect_receipt(home, &queue, &q);
1986 assert_eq!(
1987 Outbox::at(home)
1988 .get(&q.id)
1989 .unwrap()
1990 .decision
1991 .unwrap()
1992 .status,
1993 Status::Queued
1994 );
1995 let receipts = home.join("release-watch-receipts");
1996 std::fs::create_dir_all(&receipts).unwrap();
1997 let st = crate::release_watch::WatchState {
1998 applied: vec![q.id.clone()],
1999 ..Default::default()
2000 };
2001 std::fs::write(
2002 receipts.join(format!("{}.json", q.id)),
2003 serde_json::to_vec(&st).unwrap(),
2004 )
2005 .unwrap();
2006 for _ in 0..2 {
2007 sync_effect_receipt(home, &Queue::at(home.join("queue")), &q);
2008 assert_eq!(
2009 Outbox::at(home)
2010 .get(&q.id)
2011 .unwrap()
2012 .decision
2013 .unwrap()
2014 .status,
2015 Status::Resolved
2016 );
2017 }
2018 }
2019 }
2020
2021 #[test]
2022 fn dismiss_receipt_resolves_done_tasks_and_later_attempts_without_task_markers() {
2023 use crate::{
2024 ask::Answer,
2025 queue::{Source, Task, TaskStatus},
2026 run::{LandApproval, PrRecord, RunState, RunStatus},
2027 task_decision::{Decision, Status},
2028 task_inquiry::Outbox,
2029 };
2030 for (later_attempt, incomplete) in [(false, false), (true, false), (false, true)] {
2031 let temp = tempfile::tempdir().unwrap();
2032 let home = temp.path();
2033 let queue = Queue::at(home.join("queue"));
2034 let mut state = RunState::new(
2035 home.into(),
2036 "main".into(),
2037 "base".into(),
2038 "work".into(),
2039 Config::default(),
2040 );
2041 state.reserve_under(home).unwrap();
2042 state.status = RunStatus::Blocked;
2043 state.driver_exited = true;
2044 let mut q = Question::new(
2045 state.id.clone(),
2046 crate::land::APPROVAL_NODE.into(),
2047 "land".into(),
2048 "Obsolete approval".into(),
2049 String::new(),
2050 vec![crate::merge_decision::DISMISS.into()],
2051 );
2052 state.land_approval = Some(LandApproval {
2053 question: q.id.clone(),
2054 head: "head".into(),
2055 });
2056 state.pr = Some(PrRecord {
2057 url: "https://example.test/pull/1".into(),
2058 number: 1,
2059 state: "open".into(),
2060 checks: "green".into(),
2061 round: 1,
2062 rounds: 2,
2063 red_at_merge: vec![],
2064 });
2065 state.save_under(home).unwrap();
2066 let mut task = Task::new("work".into(), "work".into(), home.into(), Source::Human);
2067 task.runs.push(state.id.clone());
2068 task.status = TaskStatus::Done;
2069 if later_attempt {
2070 task.runs.push("later-run".into());
2071 task.status = TaskStatus::Queued;
2072 }
2073 if incomplete {
2074 task.status = TaskStatus::Parked;
2075 }
2076 queue.put(&mut task).unwrap();
2077 q.answer(Answer::Choice(crate::merge_decision::DISMISS.into()))
2078 .unwrap();
2079 let outbox = Outbox::at(home);
2080 let mut record = history_record(&q, Some(&task));
2081 let mut decision = Decision::awaiting(q.summary.clone());
2082 decision.accept("decision: dismiss").unwrap();
2083 record.decision = Some(decision);
2084 record.archived = false;
2085 outbox.enqueue(record).unwrap();
2086 if incomplete {
2087 state.merge_decision = Some(crate::merge_decision::Decision {
2090 question: q.id.clone(),
2091 target: crate::merge_decision::Target {
2092 pr: state.pr.as_ref().unwrap().url.clone(),
2093 head: "head".into(),
2094 language: "en".into(),
2095 },
2096 choice: crate::merge_decision::DISMISS.into(),
2097 closed: false,
2098 replacement_run: None,
2099 replacement_pr: None,
2100 });
2101 state.save_under(home).unwrap();
2102 sync_effect_receipt(home, &queue, &q);
2103 assert_eq!(
2104 outbox.get(&q.id).unwrap().decision.unwrap().status,
2105 Status::Queued
2106 );
2107 }
2108 crate::merge_decision::dismiss(home, &q).unwrap();
2109 let after = std::fs::read(queue.path_of(&task.id)).unwrap();
2110 assert_eq!(
2111 queue.get(&task.id).unwrap().action_applied(&q.id),
2112 incomplete
2113 );
2114 for _ in 0..2 {
2115 sync_effect_receipt(home, &queue, &q);
2116 assert_eq!(
2117 Outbox::at(home)
2118 .get(&q.id)
2119 .unwrap()
2120 .decision
2121 .unwrap()
2122 .status,
2123 Status::Resolved
2124 );
2125 assert_eq!(std::fs::read(queue.path_of(&task.id)).unwrap(), after);
2126 }
2127 assert_eq!(
2128 RunState::load_under(&q.run, home)
2129 .unwrap()
2130 .pr
2131 .unwrap()
2132 .state,
2133 "open"
2134 );
2135 }
2136 }
2137}