1use std::path::Path;
38
39use anyhow::{Context, Result, bail, ensure};
40
41use crate::queue::{Queue, Task, TaskStatus};
42use crate::talk::{Talk, Talks};
43
44#[cfg(any(unix, windows))]
45pub(crate) mod bridge;
46
47#[derive(Debug, serde::Serialize, serde::Deserialize)]
50#[serde(tag = "operation", deny_unknown_fields)]
51pub enum Operation {
52 GrantRepair {
54 request: crate::repair_budget::Request,
56 },
57 Add {
59 filing: Box<Filing>,
61 },
62 Done {
64 task: String,
66 },
67 Priority {
69 task: String,
71 priority: i32,
73 },
74 MergePr {
76 repo: String,
78 number: u64,
80 head: String,
82 request: String,
84 },
85 Resume {
87 run: String,
89 },
90 Hold {
92 task: String,
94 reason: String,
96 },
97 Release {
99 task: String,
101 },
102 Retry {
104 task: String,
106 title: Option<String>,
108 instruction: String,
110 },
111 RerunChecks {
113 run: String,
115 request: String,
117 head: String,
119 workflows: Vec<String>,
121 },
122 Decide {
124 question: String,
126 choice: String,
128 #[serde(default)]
130 title: Option<String>,
131 },
132 Answer {
135 question: String,
137 reply: String,
139 #[serde(default)]
141 title: Option<String>,
142 },
143 ReplyOther {
147 question: String,
149 text: String,
151 },
152 ReconcileRetention {
154 task: String,
156 authority: String,
158 apply: Option<String>,
160 },
161 Abandon {
163 run: String,
165 },
166}
167
168#[derive(Debug, serde::Serialize, serde::Deserialize)]
170#[serde(deny_unknown_fields)]
171pub struct Filing {
172 pub title: String,
174 pub instruction: String,
176 pub repo: std::path::PathBuf,
178 pub source: crate::queue::Source,
180 pub sources: crate::refs::Sources,
182 pub hold: Option<String>,
184 pub priority: i32,
186 pub solo: bool,
188 pub urgent: bool,
190 pub implementers: Option<usize>,
192 pub attach: Vec<std::path::PathBuf>,
194}
195
196pub fn has_channel() -> bool {
199 #[cfg(any(unix, windows))]
200 {
201 std::env::var_os(bridge::CHANNEL_ENV).is_some()
202 }
203 #[cfg(not(any(unix, windows)))]
204 {
205 false
206 }
207}
208
209pub async fn dispatch(
212 queue: &Queue,
213 home: &Path,
214 talks: &Talks,
215 talk: &str,
216 operation: Operation,
217) -> Result<String> {
218 #[cfg(unix)]
219 if std::env::var_os(bridge::CHANNEL_ENV).is_some() {
220 match bridge::request(&operation) {
223 Err(error)
224 if error.is::<bridge::Unavailable>()
225 && std::env::var("MAGI_ALLOW_WRITE").as_deref() == Ok("1") => {}
226 result => return result,
227 }
228 }
229 #[cfg(windows)]
230 if std::env::var_os(bridge::CHANNEL_ENV).is_some() {
231 return bridge::request(&operation).await;
232 }
233 execute(queue, home, talks, talk, operation).await
234}
235
236async fn execute(
237 queue: &Queue,
238 home: &Path,
239 talks: &Talks,
240 talk: &str,
241 operation: Operation,
242) -> Result<String> {
243 authorize(talks, talk, crate::queue::CHAT_NODE)?;
244 Ok(match operation {
245 Operation::Add { filing } => {
246 let mut task = Task::new(filing.title, filing.instruction, filing.repo, filing.source);
247 task.sources = filing.sources;
248 if let Some(reason) = filing.hold {
249 task.hold_manual(Some(reason));
250 }
251 task.priority = filing.priority;
252 task.solo = filing.solo;
253 task.urgent = filing.urgent;
254 if filing.implementers.is_some() {
255 task.overrides = Some(crate::queue::RunOverrides {
256 candidates: filing.implementers,
257 ..Default::default()
258 });
259 }
260 if filing.attach.is_empty() {
261 queue.put(&mut task)?;
262 } else {
263 queue.attach_and_put(&mut task, &filing.attach)?;
264 }
265 serde_json::to_string(&task)?
266 }
267 Operation::Done { task } => {
268 let t = done(queue, home, &task)?;
269 format!("done {} {}", t.short(), t.title)
270 }
271 Operation::Priority { task, priority } => {
272 let t = set_priority(queue, &task, priority)?;
273 format!("{} priority now {} - {}", t.short(), t.priority, t.title)
274 }
275 Operation::MergePr {
276 repo,
277 number,
278 head,
279 request,
280 } => {
281 crate::chat_merge::merge(
282 home,
283 talks,
284 talk,
285 crate::chat_merge::Request {
286 repo,
287 number,
288 head,
289 request,
290 },
291 )
292 .await?
293 }
294 Operation::GrantRepair { request } => {
295 serde_json::to_string(
298 &Box::pin(crate::repair_budget::grant(queue, home, request)).await?,
299 )?
300 }
301 Operation::Resume { run } => {
302 let t = resume(queue, home, &run)?;
303 format!(
304 "{}; the loop (`magi serve`) resumes the run under its execution lease",
305 describe(&t, "resume queued for")
306 )
307 }
308 Operation::Hold { task, reason } => describe(&hold(queue, &task, &reason)?, "held"),
309 Operation::Release { task } => describe(&release(queue, &task)?, "released"),
310 Operation::Retry {
311 task,
312 title,
313 instruction,
314 } => describe(
315 &retry(queue, &task, title, &instruction)?,
316 "retry queued for",
317 ),
318 Operation::RerunChecks {
319 run,
320 request,
321 head,
322 workflows,
323 } => {
324 let ids = rerun_checks(queue, home, talk, &run, &request, &head, &workflows).await?;
325 format!("requested a rerun of workflow run(s) {}", ids.join(", "))
326 }
327 Operation::Decide {
328 question,
329 choice,
330 title,
331 } => {
332 let q = record_decision(home, &question, &choice, title.as_deref())?;
333 format!("recorded `{choice}` for decision {}", q.short())
334 }
335 Operation::Answer {
336 question,
337 reply,
338 title,
339 } => crate::ask::record_answer(
340 &crate::ask::Questions::at(home.join("questions")),
341 &question,
342 &reply,
343 title.as_deref(),
344 )?,
345 Operation::ReplyOther { question, text } => crate::consult::reply_other(
346 &crate::ask::Questions::at(home.join("questions")),
347 &question,
348 &text,
349 )?,
350 Operation::ReconcileRetention {
351 task,
352 authority,
353 apply,
354 } => {
355 let path = Box::pin(crate::retention::reconcile::run_chat(
356 home,
357 &task,
358 &authority,
359 apply.as_deref(),
360 crate::retention::reconcile::ChatRequest {
361 talks,
362 conversation: talk,
363 },
364 ))
365 .await?;
366 if apply.is_none() {
367 crate::retention::reconcile::chat_summary(&path)?
369 } else {
370 format!(
371 "Applied saved plan {}",
372 apply.as_deref().unwrap_or_default()
373 )
374 }
375 }
376 Operation::Abandon { run } => {
377 abandon(queue, home, &run)?;
378 format!("abandoned run {run}")
379 }
380 })
381}
382
383pub fn decide(
387 talks: &Talks,
388 home: &Path,
389 talk: &str,
390 question: &str,
391 choice: &str,
392) -> Result<crate::ask::Question> {
393 authorize(talks, talk, crate::queue::CHAT_NODE)?;
394 record_decision(home, question, choice, None)
395}
396
397fn record_decision(
403 home: &Path,
404 question: &str,
405 choice: &str,
406 title: Option<&str>,
407) -> Result<crate::ask::Question> {
408 use crate::ask::{Answer, Questions};
409 let questions = Questions::at(home.join("questions"));
410 let id = questions.resolve_id(question)?;
411 let q = questions.get(&id)?;
412 ensure!(
413 crate::task_chat::awaits_decision(&q),
414 "question {} is not a decision the machinery waits on; answer it with `magi answer`",
415 q.short()
416 );
417 let (q, ()) = questions.update(&q.id, |r| {
418 ensure!(
419 r.status.open(),
420 "question {} is already {}",
421 r.short(),
422 r.status.as_str()
423 );
424 let reply = r.resolve_reply(choice)?.to_owned();
425 let replacement =
426 r.node == crate::github_text::ASK_NODE && reply == crate::github_text::USE_MY_TEXT;
427 ensure!(
428 replacement || title.is_none(),
429 "--title is only valid for a publication decision's `use my text` choice"
430 );
431 let title = if replacement {
432 let title =
433 title.context("use my text needs --title with the literal replacement title")?;
434 ensure!(
435 !title.trim().is_empty(),
436 "replacement title must not be empty"
437 );
438 Some(title.to_owned())
439 } else {
440 None
441 };
442 let answer = if r.free_text() {
443 Answer::Text(reply)
444 } else {
445 Answer::Choice(reply)
446 };
447 r.publication_title = title;
448 r.answer(answer)
449 })?;
450 Ok(q)
451}
452
453pub fn authorize(talks: &Talks, run: &str, node: &str) -> Result<Talk> {
455 if node != crate::queue::CHAT_NODE || run.trim().is_empty() {
456 bail!("task control requires MAGI_NODE=chat and MAGI_RUN from a standing chat");
457 }
458 let id = crate::chat_watch::authorize(talks, run, node)?;
459 talks.get(&id)
460}
461
462fn run_task(queue: &Queue, run: &str) -> Result<Task> {
464 ensure!(
465 crate::run::is_run_id(run),
466 "an execution command needs the full run id"
467 );
468 queue
469 .list()
470 .into_iter()
471 .find(|t| t.runs.iter().any(|r| r == run))
472 .with_context(|| format!("run {run} belongs to no task"))
473}
474
475fn claimed(queue: &Queue, reference: &str) -> Result<(crate::queue::Claim, Task)> {
478 let id = queue.resolve_id(reference)?;
479 let claim = queue
480 .claim(&id)
481 .with_context(|| format!("task {id} is claimed by a running daemon"))?;
482 let task = queue.get(&id)?;
483 Ok((claim, task))
484}
485
486fn check_hold_release(task: &Task, operation: &str) -> Result<()> {
487 match task.status {
488 TaskStatus::Queued
489 | TaskStatus::Held
490 | TaskStatus::Failed
491 | TaskStatus::Blocked
492 | TaskStatus::Parked => Ok(()),
493 TaskStatus::Done => bail!(
494 "cannot {operation} task {} (done): completed work must not be restarted; create a new task instead",
495 task.id
496 ),
497 TaskStatus::Running => bail!(
498 "cannot {operation} task {} (running): its run may still be active; use resume or abandon for the existing run instead",
499 task.id
500 ),
501 }
502}
503
504pub fn done(queue: &Queue, home: &Path, reference: &str) -> Result<Task> {
506 let (_claim, mut task) = claimed(queue, reference)?;
507 task.succeed();
508 crate::daemon::supersede_prior_runs(&task, home);
510 queue.put(&mut task)?;
511 Ok(task)
512}
513
514pub fn set_priority(queue: &Queue, reference: &str, priority: i32) -> Result<Task> {
516 let (_claim, mut task) = claimed(queue, reference)?;
517 task.set_priority(priority)?;
518 queue.put(&mut task)?;
519 Ok(task)
520}
521
522pub fn hold(queue: &Queue, reference: &str, reason: &str) -> Result<Task> {
524 let (_claim, mut task) = claimed(queue, reference)?;
525 check_hold_release(&task, "hold")?;
526 let reason = reason.trim();
527 task.hold_manual((!reason.is_empty()).then(|| reason.to_owned()));
528 queue.put(&mut task)?;
529 Ok(task)
530}
531
532pub fn release(queue: &Queue, reference: &str) -> Result<Task> {
536 let (_claim, mut task) = claimed(queue, reference)?;
537 check_hold_release(&task, "release")?;
538 crate::base_sync_recovery::ensure_generic_release(queue, &task)?;
539 let run = task.runs.last().cloned();
540 let preserved = match run {
541 Some(run) => crate::repair_budget::queue_resumption(queue, &mut task, &run)?,
542 None => false,
543 };
544 if !preserved {
545 task.release_operator("chat", None);
546 }
547 queue.put(&mut task)?;
548 Ok(task)
549}
550
551pub fn retry(
556 queue: &Queue,
557 reference: &str,
558 title: Option<String>,
559 instruction: &str,
560) -> Result<Task> {
561 ensure!(
562 !instruction.trim().is_empty(),
563 "the new instruction is empty"
564 );
565 let (_claim, mut task) = claimed(queue, reference)?;
566 if let Some(state) = crate::base_sync_recovery::held_run(queue, &task)
567 && state
568 .base_sync_recovery
569 .stop
570 .as_ref()
571 .is_some_and(|stop| stop.kind == crate::base_sync_recovery::StopKind::Conflict)
572 {
573 anyhow::bail!(
574 "retry cannot authorize editing a retained base-sync stop. {} Keep the retained review criteria and use a dedicated repair grant for the narrow resolution.",
575 state.base_sync_next_action()
576 );
577 }
578 crate::base_sync_recovery::ensure_generic_release(queue, &task)?;
579 let title = title.unwrap_or_else(|| crate::queue::title_from(instruction, 72));
580 task.edit(title, instruction.to_owned())?;
581 task.release_operator("chat", None);
582 queue.put(&mut task)?;
583 Ok(task)
584}
585
586pub fn resume(queue: &Queue, home: &Path, run: &str) -> Result<Task> {
589 let task = run_task(queue, run)?;
590 ensure!(
591 task.runs.last().map(String::as_str) == Some(run),
592 "only the task's latest run can be resumed"
593 );
594 crate::resume::validate(home, run)?;
595 ensure!(
596 crate::resume::pin_queued(queue, run, None, None)?,
597 "no queued task owns run {run}"
598 );
599 queue.get(&task.id)
600}
601
602pub async fn rerun_checks(
604 queue: &Queue,
605 home: &Path,
606 talk: &str,
607 run: &str,
608 request: &str,
609 head: &str,
610 workflows: &[String],
611) -> Result<Vec<String>> {
612 run_task(queue, run)?;
613 let state = crate::run::RunState::load_under(run, home)?;
614 let pr = &state
615 .pr
616 .as_ref()
617 .context("the run recorded no pull request")?
618 .url;
619 ensure!(
620 crate::ask::valid_asset_name(request),
621 "request must be a safe filename of at most 64 bytes"
622 );
623 let dir = home.join("chat-controls").join(talk);
624 std::fs::create_dir_all(&dir)?;
625 let lock = std::fs::OpenOptions::new()
626 .create(true)
627 .truncate(false)
628 .write(true)
629 .open(dir.join(format!("{request}.lock")))?;
630 crate::pr_head::try_lock_file(&lock)?;
631 let path = dir.join(format!("{request}.json"));
632 let action = serde_json::json!({
633 "run": run, "repo": state.repo, "pr": pr, "head": head, "runs": workflows
634 });
635 if path.exists() {
636 let prior: serde_json::Value = serde_json::from_slice(&std::fs::read(&path)?)?;
637 ensure!(
638 prior["action"] == action,
639 "request ID already binds a different operation"
640 );
641 ensure!(
642 prior["status"] == "applied",
643 "previous request has an uncertain result; inspect its receipt before a new request"
644 );
645 return Ok(workflows.to_vec());
646 }
647 let record = |status: &str| -> Result<()> {
648 let tmp = path.with_extension("tmp");
649 std::fs::write(
650 &tmp,
651 serde_json::to_vec(&serde_json::json!({
652 "action": action, "status": status
653 }))?,
654 )?;
655 std::fs::rename(tmp, &path)?;
656 Ok(())
657 };
658 let operation = format!("chat:{talk}:{request}");
659 crate::daemon::rerun_checks_once(home, &operation, &state.repo, pr, head, workflows, || {
660 record("started")
661 })
662 .await?;
663 record("applied")?;
664 Ok(workflows.to_vec())
665}
666
667pub fn abandon(queue: &Queue, home: &Path, run: &str) -> Result<()> {
671 run_task(queue, run)?;
672 crate::driver::abandon_proven_dead(home, run)
673}
674
675pub fn describe(task: &Task, what: &str) -> String {
677 let status = match task.status {
678 TaskStatus::Queued => "queued",
679 _ => task.status.as_str(),
680 };
681 format!("{what} {} {} ({status})", task.short(), task.title)
682}
683
684#[cfg(test)]
685mod tests {
686 use super::*;
687 use crate::queue::Source;
688 use jiff::Timestamp;
689
690 fn talk(talks: &Talks, id: &str) -> Talk {
691 let mut t: Talk = serde_json::from_value(serde_json::json!({
692 "schema":1,"id":id,"repo":".","agent":"worker","status":"open","turns":[],
693 "created_at":Timestamp::now(),"updated_at":Timestamp::now(),
694 "seat":crate::agent::SeatState::new("talk","worker",1)
695 }))
696 .unwrap();
697 talks.put(&mut t).unwrap();
698 t
699 }
700
701 fn filed(queue: &Queue, talk: &str, text: &str) -> Task {
702 let mut t = Task::new(
703 text.into(),
704 text.into(),
705 ".".into(),
706 Source::Agent {
707 run: talk.into(),
708 node: crate::queue::CHAT_NODE.into(),
709 },
710 );
711 queue.put(&mut t).unwrap();
712 t
713 }
714
715 #[test]
716 fn only_the_chat_seat_of_an_open_talk_is_authorized() {
717 let tmp = tempfile::tempdir().unwrap();
718 let talks = Talks::at(tmp.path().join("talks"));
719 let t = talk(&talks, "talk-a");
720 assert!(authorize(&talks, &t.id, "chat").is_ok());
721 assert!(authorize(&talks, &t.id, "deputy").is_err());
722 assert!(authorize(&talks, &t.id, "").is_err());
723 assert!(authorize(&talks, "", "chat").is_err());
724 assert!(
725 authorize(&talks, "talk-", "chat").is_err(),
726 "prefix is not an id"
727 );
728 }
729
730 #[test]
731 fn tasks_of_any_origin_are_controlled_on_request() {
732 let tmp = tempfile::tempdir().unwrap();
733 let queue = Queue::at(tmp.path().join("queue"));
734 let theirs = filed(&queue, "talk-b", "theirs");
735 let mut hand = Task::new("h".into(), "h".into(), ".".into(), Source::Human);
736 hand.hold_manual(Some("operator".into()));
737 queue.put(&mut hand).unwrap();
738 assert_eq!(
741 hold(&queue, &theirs.id, "wait").unwrap().status,
742 TaskStatus::Held
743 );
744 assert_eq!(
745 release(&queue, &hand.id).unwrap().status,
746 TaskStatus::Queued
747 );
748 let again = retry(&queue, &theirs.id, None, "new").unwrap();
749 assert_eq!(again.instruction, "new");
750 assert_eq!(again.status, TaskStatus::Queued);
751 }
752
753 #[test]
754 fn hold_then_release_keeps_history_and_restarts_attempts() {
755 let tmp = tempfile::tempdir().unwrap();
756 let queue = Queue::at(tmp.path().join("queue"));
757 let mut t = filed(&queue, "talk-a", "work");
758 t.attempts = 3;
759 t.runs.push("20260101-000000-aaaa".into());
760 queue.put(&mut t).unwrap();
761 let held = hold(&queue, &t.id, "owner asked").unwrap();
762 assert_eq!(held.status, TaskStatus::Held);
763 assert_eq!(held.hold_reason.as_deref(), Some("owner asked"));
764 let back = release(&queue, &t.id).unwrap();
765 assert_eq!(back.status, TaskStatus::Queued);
766 assert_eq!(back.attempts, 0);
767 assert_eq!(back.runs, t.runs);
768 assert!(back.resumption.is_some());
769 }
770
771 #[test]
772 fn hold_and_release_refuse_done_and_running_without_saving() {
773 let tmp = tempfile::tempdir().unwrap();
774 let queue = Queue::at(tmp.path().join("queue"));
775 for status in [TaskStatus::Done, TaskStatus::Running] {
776 let mut t = filed(&queue, "talk-a", "work");
777 t.start("20260101-000000-aaaa".into());
778 if status == TaskStatus::Done {
779 t.succeed();
780 }
781 queue.put(&mut t).unwrap();
782 let before = std::fs::read(queue.path_of(&t.id)).unwrap();
783 for operation in ["hold", "release"] {
784 let error = if operation == "hold" {
785 hold(&queue, &t.id, "owner asked")
786 } else {
787 release(&queue, &t.id)
788 }
789 .unwrap_err()
790 .to_string();
791 assert!(error.contains(operation), "{error}");
792 assert!(error.contains(&t.id), "{error}");
793 assert!(error.contains(status.as_str()), "{error}");
794 let guidance = if status == TaskStatus::Done {
795 "create a new task"
796 } else {
797 "use resume or abandon"
798 };
799 assert!(error.contains(guidance), "{error}");
800 assert_eq!(std::fs::read(queue.path_of(&t.id)).unwrap(), before);
801 }
802 }
803 }
804
805 #[test]
806 fn hold_and_release_allow_unfinished_inactive_tasks() {
807 let tmp = tempfile::tempdir().unwrap();
808 let queue = Queue::at(tmp.path().join("queue"));
809 for status in [
810 TaskStatus::Queued,
811 TaskStatus::Held,
812 TaskStatus::Failed,
813 TaskStatus::Blocked,
814 TaskStatus::Parked,
815 ] {
816 for operation in ["hold", "release"] {
817 let mut t = filed(&queue, "talk-a", "work");
818 t.status = status;
819 t.hold_reason = Some("old reason".into());
820 t.attempts = 3;
821 t.runs.push("20260101-000000-aaaa".into());
822 queue.put(&mut t).unwrap();
823 let changed = if operation == "hold" {
824 let held = hold(&queue, &t.id, " new reason ").unwrap();
825 assert_eq!(held.status, TaskStatus::Held);
826 assert_eq!(held.hold_reason.as_deref(), Some("new reason"));
827 assert_eq!(held.attempts, t.attempts);
828 held
829 } else {
830 let released = release(&queue, &t.id).unwrap();
831 assert_eq!(released.status, TaskStatus::Queued);
832 assert_eq!(released.attempts, 0);
833 assert_eq!(released.resumption.as_ref().unwrap().source, "chat");
834 released
835 };
836 assert_eq!(changed.runs, t.runs);
837 assert_eq!(queue.get(&t.id).unwrap().status, changed.status);
838 }
839 }
840 }
841
842 #[test]
843 fn retry_edits_and_requeues_in_one_save() {
844 let tmp = tempfile::tempdir().unwrap();
845 let queue = Queue::at(tmp.path().join("queue"));
846 let mut t = filed(&queue, "talk-a", "old text");
847 t.runs.push("20260101-000000-aaaa".into());
848 t.attempts = 2;
849 t.hold_manual(Some("stopped".into()));
850 queue.put(&mut t).unwrap();
851 let again = retry(&queue, &t.id, None, "new text").unwrap();
852 assert_eq!(again.instruction, "new text");
853 assert_eq!(again.status, TaskStatus::Queued);
854 assert_eq!(again.attempts, 0);
855 assert_eq!(again.runs, t.runs, "run history is kept");
856 assert_eq!(again.resumption.as_ref().unwrap().source, "chat");
857 assert_eq!(again.resumption.as_ref().unwrap().instruction, "new text");
858 let mut running = filed(&queue, "talk-a", "busy");
860 running.start("20260101-000000-bbbb".into());
861 queue.put(&mut running).unwrap();
862 assert!(retry(&queue, &running.id, None, "x").is_err());
863 assert_eq!(queue.get(&running.id).unwrap().instruction, "busy");
864 assert!(retry(&queue, &t.id, None, " ").is_err());
865 }
866
867 #[test]
868 fn execution_commands_need_the_full_id_of_a_recorded_run() {
869 let tmp = tempfile::tempdir().unwrap();
870 let queue = Queue::at(tmp.path().join("queue"));
871 let mut t = filed(&queue, "talk-b", "work");
872 t.runs.push("20260101-000000-aaaa".into());
873 queue.put(&mut t).unwrap();
874 assert_eq!(
875 run_task(&queue, "20260101-000000-aaaa").unwrap().id,
876 t.id,
877 "any chat may address another chat's run"
878 );
879 assert!(run_task(&queue, "aaaa").is_err());
880 assert!(run_task(&queue, "20260101-000000-bbbb").is_err());
881 assert!(resume(&queue, tmp.path(), "aaaa").is_err());
882 }
883
884 #[test]
885 fn abandon_needs_no_phrase_but_refuses_unrecorded_and_unknown_runs() {
886 let tmp = tempfile::tempdir().unwrap();
887 let queue = Queue::at(tmp.path().join("queue"));
888 let mut t = filed(&queue, "talk-b", "work");
889 t.runs.push("20260101-000000-aaaa".into());
890 queue.put(&mut t).unwrap();
891 assert!(abandon(&queue, tmp.path(), "20260101-000000-bbbb").is_err());
893 assert!(abandon(&queue, tmp.path(), "20260101-000000-aaaa").is_err());
896 }
897}